/usr/include/casacore/tables/TaQL/MArrayMathBase.h is in casacore-dev 2.2.0-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 | //# MArrayMathBase.h: Basic functions and classes for math on MArray objects
//# Copyright (C) 2012
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//# Internet email: aips2-request@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
//#
//# $Id: MArrayMathBase.h 21262 2012-09-07 12:38:36Z gervandiepen $
#ifndef CASA_MARRAYMATHBASE_H
#define CASA_MARRAYMATHBASE_H
#include <casacore/casa/aips.h>
#include <casacore/casa/Arrays/ArrayMathBase.h>
namespace casacore {
//# Forward declarations.
template<typename T> class MArray;
// <summary>
// Basic functions and classes for math on MArray objects
// </summary>
//
// <reviewed reviewer="UNKNOWN" date="" tests="tMArrayMath">
//
// <prerequisite>
// <li> <linkto class=MArray>MArray</linkto>
// </prerequisite>
//
// <synopsis>
// This header file defines several STL-like functions to work on
// iterators with a mask.
//
// Furthermore, abstract base classes are defined for functors to be used
// in functions like slidingXXX.
// Virtual functions instead of templated functions are used to avoid
// code bloat when used in functions like partialArrayMath. Because a
// reduction operation usually takes much more time than the call, using
// virtual functions hardly imposes a performance penalty.
// </synopsis>
//
// <group name="Array basic functions">
// Define STL-like accumulate function operating on arrays with masks.
// A mask value True means masked-off, thus is not taken into account.
// <group>
// <br>The first function initializes the accumulator to the first
// unmasked value. This is useful if it is not possible to initialize
// it externally (e.g. for a function like min).
template<typename T, typename ARRAYITER, typename MASKITER, typename OPER>
T accumulateMasked (ARRAYITER abegin, ARRAYITER aend, MASKITER mbegin,
OPER oper)
{
T accum = T();
for (; abegin!=aend; ++abegin, ++mbegin) {
if (!*mbegin) { accum = *abegin; ++abegin; ++mbegin; break; }
}
for (; abegin!=aend; ++abegin, ++mbegin) {
if (!*mbegin) accum = oper(accum, *abegin);
}
return accum;
}
// The second function uses an externally initialized accumulator
// (e.g. needed for sum).
template<typename T, typename ARRAYITER, typename MASKITER, typename OPER>
T accumulateMasked (ARRAYITER abegin, ARRAYITER aend, MASKITER mbegin,
T accum, OPER oper)
{
for (; abegin!=aend; ++abegin, ++mbegin) {
if (!*mbegin) accum = oper(accum, *abegin);
}
return accum;
}
// </group>
// Count the number of unmasked values matching the given value.
// It is similar to std::count, but a mask is applied.
template<typename T, typename ARRAYITER, typename MASKITER>
size_t countMasked (ARRAYITER abegin, ARRAYITER aend, MASKITER mbegin,
const T& value)
{
size_t n = 0;
for (; abegin!=aend; ++abegin, ++mbegin) {
if (!*mbegin && *abegin == value) ++n;
}
return n;
}
// Count the number of unmasked values not matching the given value.
// It is similar to std::count, but a mask is applied.
template<typename T, typename ARRAYITER, typename MASKITER>
size_t countNEMasked (ARRAYITER abegin, ARRAYITER aend, MASKITER mbegin,
const T& value)
{
size_t n = 0;
for (; abegin!=aend; ++abegin, ++mbegin) {
if (!*mbegin && *abegin != value) ++n;
}
return n;
}
// Define a function to compare the unmasked elements of two sequences.
// It returns true if all unmasked elements compare true or if there are
// no unmasked elements.
// An example compare operator is <src>std::equal_to</src>.
// <group>
template<typename InputIterator1, typename InputIterator2,
typename MaskIterator, typename CompareOperator>
inline bool compareAllMasked (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2,
MaskIterator mask1, MaskIterator mask2,
CompareOperator op)
{
for (; first1!=last1; ++first1, ++first2, ++mask1, ++mask2) {
if (!*mask1 && !*mask2) {
if (!op(*first1, *first2)) return False;
}
}
return true;
}
template<typename InputIterator1, typename InputIterator2,
typename MaskIterator, typename CompareOperator>
inline bool compareAllMasked (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2,
MaskIterator mask1,
CompareOperator op)
{
for (; first1!=last1; ++first1, ++first2, ++mask1) {
if (!*mask1) {
if (!op(*first1, *first2)) return False;
}
}
return true;
}
// For use with a constant left value.
// This avoids use of bind1st or bind2nd which can fail for gcc-4.3.
// (see ArrayMath.h).
template<typename InputIterator1, typename T,
typename MaskIterator, typename CompareOperator>
inline bool compareAllLeftMasked (InputIterator1 first1, InputIterator1 last1,
T left, MaskIterator mask1,
CompareOperator op)
{
for (; first1!=last1; ++first1, ++mask1) {
if (!*mask1) {
if (!op(left, *first1)) return False;
}
}
return true;
}
// For use with a constant right value.
// This avoids use of bind1st or bind2nd which can fail for gcc-4.3.
// (see ArrayMath.h).
template<typename InputIterator1, typename T,
typename MaskIterator, typename CompareOperator>
inline bool compareAllRightMasked(InputIterator1 first1, InputIterator1 last1,
T right, MaskIterator mask1,
CompareOperator op)
{
for (; first1!=last1; ++first1, ++mask1) {
if (!*mask1) {
if (!op(*first1, right)) return False;
}
}
return true;
}
// </group>
// Define a function to compare the unmasked elements of two sequences.
// It returns true if any element compares true.
// If there are no unmasked elements, it returns False.
// An example compare operator is <src>std::equal_to</src>.
// <group>
template<typename InputIterator1, typename InputIterator2,
typename MaskIterator, typename CompareOperator>
inline bool compareAnyMasked (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2,
MaskIterator mask1, MaskIterator mask2,
CompareOperator op)
{
for (; first1!=last1; ++first1, ++first2, ++mask1, ++mask2) {
if (!*mask1 && !*mask2) {
if (op(*first1, *first2)) return true;
}
}
return False;
}
template<typename InputIterator1, typename InputIterator2,
typename MaskIterator, typename CompareOperator>
inline bool compareAnyMasked (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2,
MaskIterator mask1,
CompareOperator op)
{
for (; first1!=last1; ++first1, ++first2, ++mask1) {
if (!*mask1) {
if (op(*first1, *first2)) return true;
}
}
return False;
}
// For use with a constant left value.
// This avoids use of bind1st or bind2nd which can fail for gcc-4.3.
// (see ArrayMath.h).
template<typename InputIterator1, typename T,
typename MaskIterator, typename CompareOperator>
inline bool compareAnyLeftMasked (InputIterator1 first1, InputIterator1 last1,
T left, MaskIterator mask1,
CompareOperator op)
{
for (; first1!=last1; ++first1, ++mask1) {
if (!*mask1) {
if (op(left, *first1)) return true;
}
}
return False;
}
// For use with a constant right value.
// This avoids use of bind1st or bind2nd which can fail for gcc-4.3.
// (see ArrayMath.h).
template<typename InputIterator1, typename T,
typename MaskIterator, typename CompareOperator>
inline bool compareAnyRightMasked(InputIterator1 first1, InputIterator1 last1,
T right, MaskIterator mask1,
CompareOperator op)
{
for (; first1!=last1; ++first1, ++mask1) {
if (!*mask1) {
if (op(*first1, right)) return true;
}
}
return False;
}
// </group>
// Define the base class for functors to perform a reduction function on an
// MArray object. The functors themselves are defined elsewhere.
template<typename T, typename RES=T> class MArrayFunctorBase {
public:
virtual ~MArrayFunctorBase() {}
virtual RES operator() (const MArray<T>&) const = 0;
};
// </group>
} //# end namespace
#endif
|