Loading...
Searching...
No Matches
ArraySampledFunctional.h
Go to the documentation of this file.
//# ArraySampledFunctional:
//# Copyright (C) 1996,1997,1999
//# 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 SCIMATH_ARRAYSAMPLEDFUNCTIONAL_H
#define SCIMATH_ARRAYSAMPLEDFUNCTIONAL_H
#include <casacore/casa/aips.h>
#include <casacore/scimath/Functionals/SampledFunctional.h>
#include <casacore/casa/Arrays/Array.h>
#include <casacore/casa/Arrays/IPosition.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
// <summary> Index into an array using the longest axis </summary>
// <use visibility=export>
// <reviewed reviewer="wyoung" date="1996/10/19" tests="tSampledFunctional.cc">
// </reviewed>
// <prerequisite>
// <li> SampledFunctional
// <li> Array
// </prerequisite>
// <etymology>
// A SampledFunctional is an interface that allows random access to a fixed
// size data set. An ArraySampledFunctional allows you to access slices of
// an an Array<T> object.
// </etymology>
// <synopsis>
//
// An ArraySampledFunctional allows an Array<T> object to be sliced up with
// each sample being one slice of the original Array. The slices are always
// the same size and the indexing is always done along the last
// non-degenerate dimension. For example a(4,3,20,1) is interpreted as a
// SampledFunctional with 20 elements, each one being a 4 by 3 matrix.
//
// The Array that is passed to the constructor is copied by this class but
// because Arrays themselves use reference symantics, the actual data is not
// copied but referenced. This means that modifying the data in the original
// array will correspondingly modify the data accessed by this class.
//
// Similarly the Array that is returned for each Slice is a reference to the
// actual data so that modifying this array really modifies the original
// data. This is not recommended as the operator() function is not supposed
// to be used to get a modifiable portion of the data.
// </synopsis>
// <example>
// Constructing and using ArraySampledFunctionals
// <srcblock>
// Array<Float> a(IPosition(4,4,3,20,1)); // Create an array
// ... Fill the array any way you like ...
// ArraySampledFunctional<Array<Float> >fa(a);
// for(uInt i = 0; i < 20; i++)
// cout << "f(" << i << ") = " << fa(i) << endl;
// // Each 'slice' is a 4 by 3 Matrix
// </srcblock>
// </example>
// <motivation>
// I needed a SampledFunctional which could return Arrays of arbitrary (but
// fixed) size for each index. This could be done using a <src>
// ScalarSampledFunctional<Array<T> > </src> but is ineffecient as each
// element is stored as a separate Array. This class is a more efficient way
// to solve this problem.
// </motivation>
// <templating arg=T>
// <li> The template type MUST be an Array of some arbitrary type. This is
// because this class will return a slice of this Array. The Array template
// type cannot be subsumed into the class definition because the definition
// of the inherited operator() function means that the return type must be
// the template type
// </templating>
// <thrown>
// <li> Exceptions are not thrown directly by this class.
// </thrown>
// <todo asof="1996/10/19">
// <li> Nothing I can think of.
// </todo>
template<class T> class ArraySampledFunctional
:public SampledFunctional<T>
{
public:
// These constructors copy the array that is passed to them. But because
// arrays use reference symantics the data is not copied. The default
// constructor is basically useless, as there is no way to add the data
// once the class has been constructed.
// <group>
ArraySampledFunctional();
ArraySampledFunctional(const T & data);
// </group>
// The standard copy constructor and assignment operator
// <group>
ArraySampledFunctional(ArraySampledFunctional<T> & other);
ArraySampledFunctional<T> & operator=(ArraySampledFunctional<T> &other);
// </group>
// Define the functions for the SampledFunction interface
// <group>
virtual T operator()(const uInt & index) const;
virtual uInt nelements() const;
virtual ~ArraySampledFunctional();
// </group>
// An alternate version of the sampling function which is more effecient
// because it does not need to create as many temporary objects or copy the
// Array data.
// <group>
const T operator()(const uInt & index);
// </group>
private:
T theRefData;
IPosition theEnd;
uInt theLastAxis;
uInt theNelements;
};
} //# NAMESPACE CASACORE - END
#ifndef CASACORE_NO_AUTO_TEMPLATES
#include <casacore/scimath/Functionals/ArraySampledFunctional.tcc>
#endif //# CASACORE_NO_AUTO_TEMPLATES
#endif
casacore::ArraySampledFunctional::theLastAxis
uInt theLastAxis
Definition ArraySampledFunctional.h:145
casacore::ArraySampledFunctional::~ArraySampledFunctional
virtual ~ArraySampledFunctional()
casacore::ArraySampledFunctional::theRefData
T theRefData
Definition ArraySampledFunctional.h:143
casacore::ArraySampledFunctional::ArraySampledFunctional
ArraySampledFunctional()
These constructors copy the array that is passed to them.
casacore::ArraySampledFunctional::ArraySampledFunctional
ArraySampledFunctional(ArraySampledFunctional< T > &other)
The standard copy constructor and assignment operator.
casacore::ArraySampledFunctional::theNelements
uInt theNelements
Definition ArraySampledFunctional.h:146
casacore::ArraySampledFunctional::ArraySampledFunctional
ArraySampledFunctional(const T &data)
casacore::ArraySampledFunctional::nelements
virtual uInt nelements() const
Return the total size of the data set.
casacore::ArraySampledFunctional::operator()
const T operator()(const uInt &index)
An alternate version of the sampling function which is more effecient because it does not need to cre...
casacore::ArraySampledFunctional::operator()
virtual T operator()(const uInt &index) const
Define the functions for the SampledFunction interface.
casacore::ArraySampledFunctional::theEnd
IPosition theEnd
Definition ArraySampledFunctional.h:144
casacore::ArraySampledFunctional::operator=
ArraySampledFunctional< T > & operator=(ArraySampledFunctional< T > &other)
casacore::IPosition
Definition IPosition.h:117
casacore::SampledFunctional
Definition SampledFunctional.h:101
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::uInt
unsigned int uInt
Definition aipstype.h:49