Loading...
Searching...
No Matches
MArray.h
Go to the documentation of this file.
//# MArray.h: Class to handle an Array with an optional mask
//# 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_MARRAY_H
#define CASA_MARRAY_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/tables/TaQL/MArrayBase.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
// <summary>
// Class to handle an Array with an optional mask
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
// </reviewed>
// <prerequisite>
//# Classes you should understand before using this one.
// <li> <linkto class=Array>Array</linkto>
// <li> <linkto class=MArrayBase>MArrayBase</linkto>
// </prerequisite>
// <synopsis>
// This class makes it easier to handle arrays with ot without mask.
// The array is always present, but the mask is optional. The mask is
// contained in the non-templated base class MArrayBase and functions
// to operate on the mask are defined there.
// <br> The class is primarily developed for TaQL masked arrays, but
// could be used elsewhere as well.
//
// A mask value True means that the corresponding value is masked off, thus
// not taken into account in reduction functions like <src>sum</src>. This
// is the same as the numpy masked array.
//
// MArrayMath.h contains many functions to operate on MArray objects
// (addition, sin, etc.).
// </synopsis>
template <typename T>
class MArray: public MArrayBase
{
public:
// Default constructor creates a null array.
MArray()
: MArrayBase (True)
{}
// Construct from an array without a mask.
// It references the given array.
explicit MArray (const Array<T>& array)
: MArrayBase (False),
itsArray (array)
{
resizeBase (array, False);
}
// Construct from an array and a mask.
// It references the given arrays.
// <src>isNull=True</src> requires the arrays to be empty.
MArray (const Array<T>& array, const Array<Bool>& mask, Bool isNull=False)
: MArrayBase (array, mask, isNull),
itsArray (array)
{}
// Construct from an array with the mask and null from another MArray.
// It references the given arrays.
// The shapes of both arrays must match.
MArray (const Array<T>& array, const MArrayBase& marray)
: MArrayBase (array, marray),
itsArray (array)
{}
// Construct from two MArrays, one the array, the other the mask.
// If one of them is null, the constructed MArray is null.
MArray (const MArray<T>& array, const MArray<Bool>& mask)
: MArrayBase (array.isNull() || mask.isNull())
{
if (! isNull()) {
itsArray.reference (array.array());
setBase (itsArray, mask.array());
}
}
// Reference another array.
void reference (const MArray<T>& other)
{
itsArray.reference (other.itsArray);
referenceBase (other);
}
// Resize the array and optionally the mask.
// It always sets the MArray to non-null.
void resize (const IPosition& shape, Bool useMask)
{
itsArray.resize (shape);
resizeBase (itsArray, useMask);
}
// Copy the array data and possible mask from another one.
// The shapes do not need to match.
// The array data is copied, but the new mask references the possible
// mask in <src>from</src>.
template <typename U>
void fill (const MArray<U>& from)
{
itsArray.resize (from.shape());
convertArray (itsArray, from.array());
setBase (itsArray, from.mask());
}
// Copy the array from a normal Array. The possible mask is removed.
// The shapes do not need to match.
// The array data is always copied.
template <typename U>
void fill (const Array<U>& from)
{
itsArray.resize (from.shape());
convertArray (itsArray, from);
resizeBase (itsArray, False);
}
// Get access to the array.
// <group>
const Array<T>& array() const
{ return itsArray; }
Array<T>& array()
{ return itsArray; }
// </group>
// Flatten the unmasked elements of the array to a vector.
Vector<T> flatten() const;
// Copy the unmasked elements to the out. The argument <src>size</src>
// gives the size of the output buffer which should be at least the
// size of the array. It returns the nr of unmasked elements.
size_t flatten (T* out, size_t size) const;
// Get a subset of the array.
MArray<T> operator() (const IPosition& start, const IPosition& end,
const IPosition& stride)
{
if (hasMask()) {
return MArray<T> (itsArray(start, end, stride),
mask()(start, end, stride));
}
return MArray<T> (itsArray(start, end, stride));
}
private:
Array<T> itsArray;
};
//# Implement functions.
template<typename T>
Vector<T> MArray<T>::flatten() const
{
Vector<T> vec(nvalid());
// We lie about the size, because we know the buffer has the right size.
flatten (vec.data(), itsArray.size());
return vec;
}
template<typename T>
size_t MArray<T>::flatten (T* out, size_t size) const
{
if (size < itsArray.size()) {
throw ArrayError ("MArray::flatten - size " + std::to_string(size) +
" of output buffer is too small");
}
size_t nr = 0;
if (!hasMask()) {
// No mask, so copy all elements.
Array<T> arr(itsArray.shape(), out, SHARE);
arr = itsArray;
nr = arr.size();
} else {
// Copy only the valid elements.
if (itsArray.contiguousStorage() && mask().contiguousStorage()) {
typename Array<Bool>::const_contiter miter = mask().cbegin();
typename Array<T>::const_contiter iterEnd = itsArray.cend();
for (typename Array<T>::const_contiter iter=itsArray.cbegin();
iter!=iterEnd; ++iter, ++miter) {
if (!*miter) out[nr++] = *iter;
}
} else {
typename Array<Bool>::const_iterator miter = mask().begin();
typename Array<T>::const_iterator iterEnd = itsArray.end();
for (typename Array<T>::const_iterator iter=itsArray.begin();
iter!=iterEnd; ++iter, ++miter) {
if (!*miter) out[nr++] = *iter;
}
}
}
return nr;
}
} //# NAMESPACE CASACORE - END
#endif
casacore::ArrayBase::size
size_t size() const
Definition ArrayBase.h:103
casacore::ArrayBase::shape
const IPosition & shape() const
The length of each axis.
Definition ArrayBase.h:123
casacore::ArrayError
Definition ArrayError.h:58
casacore::Array
Definition Array.h:155
casacore::Array::data
T * data()
Get a pointer to the beginning of the array.
Definition Array.h:592
casacore::Array::const_contiter
const T * const_contiter
Definition Array.h:840
casacore::Array::const_iterator
ConstIteratorSTL const_iterator
Definition Array.h:838
casacore::IPosition
Definition IPosition.h:117
casacore::MArrayBase::MArrayBase
MArrayBase(Bool isNull)
The default constructor creates an empty mask.
Definition MArrayBase.h:86
casacore::MArrayBase::nvalid
Int64 nvalid() const
Return the number of valid array values, thus unflagged elements.
Definition MArrayBase.h:130
casacore::MArrayBase::setBase
void setBase(const ArrayBase &arr, const Array< Bool > &mask)
Reference the mask and set the shape.
casacore::MArrayBase::isNull
Bool isNull() const
Is the array null?
Definition MArrayBase.h:109
casacore::MArrayBase::mask
const Array< Bool > & mask() const
Get the mask.
Definition MArrayBase.h:124
casacore::MArrayBase::resizeBase
void resizeBase(const ArrayBase &arr, Bool useMask)
Set the array shape and resize the mask.
casacore::MArrayBase::size
size_t size() const
Get the size.
Definition MArrayBase.h:150
casacore::MArrayBase::referenceBase
void referenceBase(const MArrayBase &other)
Reference another MArray.
casacore::MArrayBase::hasMask
Bool hasMask() const
Is there a mask?
Definition MArrayBase.h:117
casacore::MArrayBase::shape
const IPosition & shape() const
Get the shape.
Definition MArrayBase.h:145
casacore::MArray::MArray
MArray(const MArray< T > &array, const MArray< Bool > &mask)
Construct from two MArrays, one the array, the other the mask.
Definition MArray.h:102
casacore::MArray::flatten
Vector< T > flatten() const
Flatten the unmasked elements of the array to a vector.
Definition MArray.h:182
casacore::MArray::MArray
MArray(const Array< T > &array, const MArrayBase &marray)
Construct from an array with the mask and null from another MArray.
Definition MArray.h:95
casacore::MArray::reference
void reference(const MArray< T > &other)
Reference another array.
Definition MArray.h:112
casacore::MArray::operator()
MArray< T > operator()(const IPosition &start, const IPosition &end, const IPosition &stride)
Get a subset of the array.
Definition MArray.h:165
casacore::MArray::array
const Array< T > & array() const
Get access to the array.
Definition MArray.h:151
casacore::MArray::fill
void fill(const Array< U > &from)
Copy the array from a normal Array.
Definition MArray.h:142
casacore::MArray::fill
void fill(const MArray< U > &from)
Copy the array data and possible mask from another one.
Definition MArray.h:131
casacore::MArray::itsArray
Array< T > itsArray
Definition MArray.h:176
casacore::MArray::MArray
MArray(const Array< T > &array)
Construct from an array without a mask.
Definition MArray.h:77
casacore::MArray::resize
void resize(const IPosition &shape, Bool useMask)
Resize the array and optionally the mask.
Definition MArray.h:120
casacore::MArray::MArray
MArray()
Default constructor creates a null array.
Definition MArray.h:71
casacore::MArray::array
Array< T > & array()
Definition MArray.h:153
casacore::MArray::MArray
MArray(const Array< T > &array, const Array< Bool > &mask, Bool isNull=False)
Construct from an array and a mask.
Definition MArray.h:87
casacore::Vector
Definition Vector.h:82
casacore::SHARE
@ SHARE
Share means that the Array will just use the pointer (no copy), however the Array will NOT delete it ...
Definition ArrayBase.h:60
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::False
const Bool False
Definition aipstype.h:42
casacore::mask
LatticeExprNode mask(const LatticeExprNode &expr)
This function returns the mask of the given expression.
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:40
casacore::marray
TableExprNode marray(const TableExprNode &array, const TableExprNode &mask)
Form a masked array.
Definition ExprNode.h:1939
casacore::True
const Bool True
Definition aipstype.h:41
casacore::end
iterator end()
Definition Block.h:594