Loading...
Searching...
No Matches
MArrayMathBase.h
Go to the documentation of this file.
//# 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: casa-feedback@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
#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
casacore::MArrayMathBase_global_functions_Array_basic_functions::MArrayFunctorBase
Define the base class for functors to perform a reduction function on an MArray object.
Definition MArrayMathBase.h:261
casacore::MArrayMathBase_global_functions_Array_basic_functions::MArrayFunctorBase::~MArrayFunctorBase
virtual ~MArrayFunctorBase()
Definition MArrayMathBase.h:263
casacore::MArrayMathBase_global_functions_Array_basic_functions::MArrayFunctorBase::operator()
virtual RES operator()(const MArray< T > &) const =0
casacore::MArray
Definition MArray.h:68
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::False
const Bool False
Definition aipstype.h:42
casacore::value
NewDelAllocator< T > NewDelAllocator< T >::value
Definition Allocator.h:368
casacore::MArrayMathBase_global_functions_Array_basic_functions
Definition MArrayMathBase.h:63
casacore::MArrayMathBase_global_functions_Array_basic_functions::accumulateMasked
T accumulateMasked(ARRAYITER abegin, ARRAYITER aend, MASKITER mbegin, OPER oper)
Define STL-like accumulate function operating on arrays with masks.
Definition MArrayMathBase.h:71
casacore::MArrayMathBase_global_functions_Array_basic_functions::compareAnyRightMasked
bool compareAnyRightMasked(InputIterator1 first1, InputIterator1 last1, T right, MaskIterator mask1, CompareOperator op)
For use with a constant right value.
Definition MArrayMathBase.h:244
casacore::MArrayMathBase_global_functions_Array_basic_functions::compareAnyLeftMasked
bool compareAnyLeftMasked(InputIterator1 first1, InputIterator1 last1, T left, MaskIterator mask1, CompareOperator op)
For use with a constant left value.
Definition MArrayMathBase.h:228
casacore::MArrayMathBase_global_functions_Array_basic_functions::compareAllRightMasked
bool compareAllRightMasked(InputIterator1 first1, InputIterator1 last1, T right, MaskIterator mask1, CompareOperator op)
For use with a constant right value.
Definition MArrayMathBase.h:177
casacore::MArrayMathBase_global_functions_Array_basic_functions::countNEMasked
size_t countNEMasked(ARRAYITER abegin, ARRAYITER aend, MASKITER mbegin, const T &value)
Count the number of unmasked values not matching the given value.
Definition MArrayMathBase.h:113
casacore::MArrayMathBase_global_functions_Array_basic_functions::compareAllMasked
bool compareAllMasked(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, MaskIterator mask1, MaskIterator mask2, CompareOperator op)
Define a function to compare the unmasked elements of two sequences.
Definition MArrayMathBase.h:130
casacore::MArrayMathBase_global_functions_Array_basic_functions::compareAnyMasked
bool compareAnyMasked(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, MaskIterator mask1, MaskIterator mask2, CompareOperator op)
Define a function to compare the unmasked elements of two sequences.
Definition MArrayMathBase.h:197
casacore::MArrayMathBase_global_functions_Array_basic_functions::accumulateMasked
T accumulateMasked(ARRAYITER abegin, ARRAYITER aend, MASKITER mbegin, T accum, OPER oper)
The second function uses an externally initialized accumulator (e.g.
Definition MArrayMathBase.h:87
casacore::MArrayMathBase_global_functions_Array_basic_functions::compareAllMasked
bool compareAllMasked(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, MaskIterator mask1, CompareOperator op)
Definition MArrayMathBase.h:144
casacore::MArrayMathBase_global_functions_Array_basic_functions::compareAllLeftMasked
bool compareAllLeftMasked(InputIterator1 first1, InputIterator1 last1, T left, MaskIterator mask1, CompareOperator op)
For use with a constant left value.
Definition MArrayMathBase.h:161
casacore::MArrayMathBase_global_functions_Array_basic_functions::compareAnyMasked
bool compareAnyMasked(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, MaskIterator mask1, CompareOperator op)
Definition MArrayMathBase.h:211
casacore::MArrayMathBase_global_functions_Array_basic_functions::countMasked
size_t countMasked(ARRAYITER abegin, ARRAYITER aend, MASKITER mbegin, const T &value)
Count the number of unmasked values matching the given value.
Definition MArrayMathBase.h:100