casacore::ArrayMath_global_functions_Array_mathematical_operations Struct Reference

Mathematical operations for Arrays. More...

#include <ArrayMath.h>

Public Member Functions
template<typename _InputIterator1 , typename T , typename _OutputIterator , typename _BinaryOperation >
void	myltransform (_InputIterator1 __first1, _InputIterator1 __last1, _OutputIterator __result, T left, _BinaryOperation __binary_op)
	The myxtransform functions are defined to avoid a bug in g++-4.3.
template<typename _InputIterator1 , typename T , typename _OutputIterator , typename _BinaryOperation >
void	myrtransform (_InputIterator1 __first1, _InputIterator1 __last1, _OutputIterator __result, T right, _BinaryOperation __binary_op)
	sequence = sequence OP scalar
template<typename _InputIterator1 , typename T , typename _BinaryOperation >
void	myiptransform (_InputIterator1 __first1, _InputIterator1 __last1, T right, _BinaryOperation __binary_op)
	sequence OP= scalar
template<typename L , typename R , typename RES , typename BinaryOperator >
void	arrayContTransform (const Array< L > &left, const Array< R > &right, Array< RES > &result, BinaryOperator op)
	Functions to apply a binary or unary operator to arrays.
template<typename L , typename R , typename RES , typename BinaryOperator >
void	arrayContTransform (const Array< L > &left, R right, Array< RES > &result, BinaryOperator op)
	Transform left and right to a result using the binary operator.
template<typename L , typename R , typename RES , typename BinaryOperator >
void	arrayContTransform (L left, const Array< R > &right, Array< RES > &result, BinaryOperator op)
	Transform left and right to a result using the binary operator.
template<typename T , typename RES , typename UnaryOperator >
void	arrayContTransform (const Array< T > &arr, Array< RES > &result, UnaryOperator op)
	Transform array to a result using the unary operator.
template<typename L , typename R , typename RES , typename BinaryOperator >
void	arrayTransform (const Array< L > &left, const Array< R > &right, Array< RES > &result, BinaryOperator op)
	Transform left and right to a result using the binary operator.
template<typename L , typename R , typename RES , typename BinaryOperator >
void	arrayTransform (const Array< L > &left, R right, Array< RES > &result, BinaryOperator op)
	Transform left and right to a result using the binary operator.
template<typename L , typename R , typename RES , typename BinaryOperator >
void	arrayTransform (L left, const Array< R > &right, Array< RES > &result, BinaryOperator op)
	Transform left and right to a result using the binary operator.
template<typename T , typename RES , typename UnaryOperator >
void	arrayTransform (const Array< T > &arr, Array< RES > &result, UnaryOperator op)
	Transform array to a result using the unary operator.
template<typename T , typename BinaryOperator >
Array< T >	arrayTransformResult (const Array< T > &left, const Array< T > &right, BinaryOperator op)
	Transform left and right to a result using the binary operator.
template<typename T , typename BinaryOperator >
Array< T >	arrayTransformResult (const Array< T > &left, T right, BinaryOperator op)
	Transform left and right to a result using the binary operator.
template<typename T , typename BinaryOperator >
Array< T >	arrayTransformResult (T left, const Array< T > &right, BinaryOperator op)
	Transform left and right to a result using the binary operator.
template<typename T , typename UnaryOperator >
Array< T >	arrayTransformResult (const Array< T > &arr, UnaryOperator op)
	Transform array to a result using the unary operator.
template<typename L , typename R , typename BinaryOperator >
void	arrayTransformInPlace (Array< L > &left, const Array< R > &right, BinaryOperator op)
	Transform left and right in place using the binary operator.
template<typename L , typename R , typename BinaryOperator >
void	arrayTransformInPlace (Array< L > &left, R right, BinaryOperator op)
	Transform left and right in place using the binary operator.
template<typename T , typename UnaryOperator >
void	arrayTransformInPlace (Array< T > &arr, UnaryOperator op)
	Transform the array in place using the unary operator.
template<class T >
void	operator+= (Array< T > &left, const Array< T > &other)
	Element by element arithmetic modifying left in-place.
template<class T >
void	operator-= (Array< T > &left, const Array< T > &other)
template<class T >
void	operator*= (Array< T > &left, const Array< T > &other)
template<class T >
void	operator/= (Array< T > &left, const Array< T > &other)
template<class T >
void	operator%= (Array< T > &left, const Array< T > &other)
template<class T >
void	operator&= (Array< T > &left, const Array< T > &other)
template<class T >
void	operator\|= (Array< T > &left, const Array< T > &other)
template<class T >
void	operator^= (Array< T > &left, const Array< T > &other)
template<class T >
void	operator+= (Array< T > &left, const T &other)
	Element by element arithmetic modifying left in-place.
template<class T >
void	operator-= (Array< T > &left, const T &other)
template<class T >
void	operator*= (Array< T > &left, const T &other)
template<class T >
void	operator/= (Array< T > &left, const T &other)
template<class T >
void	operator%= (Array< T > &left, const T &other)
template<class T >
void	operator&= (Array< T > &left, const T &other)
template<class T >
void	operator\|= (Array< T > &left, const T &other)
template<class T >
void	operator^= (Array< T > &left, const T &other)
template<class T >
Array< T >	operator+ (const Array< T > &a)
	Unary arithmetic operation.
template<class T >
Array< T >	operator- (const Array< T > &a)
template<class T >
Array< T >	operator~ (const Array< T > &a)
template<class T >
Array< T >	operator+ (const Array< T > &left, const Array< T > &right)
	Element by element arithmetic on two arrays, returning an array.
template<class T >
Array< T >	operator- (const Array< T > &left, const Array< T > &right)
template<class T >
Array< T >	operator* (const Array< T > &left, const Array< T > &right)
template<class T >
Array< T >	operator/ (const Array< T > &left, const Array< T > &right)
template<class T >
Array< T >	operator% (const Array< T > &left, const Array< T > &right)
template<class T >
Array< T >	operator\| (const Array< T > &left, const Array< T > &right)
template<class T >
Array< T >	operator& (const Array< T > &left, const Array< T > &right)
template<class T >
Array< T >	operator^ (const Array< T > &left, const Array< T > &right)
template<class T >
Array< T >	operator+ (const Array< T > &left, const T &right)
	Element by element arithmetic between an array and a scalar, returning an array.
template<class T >
Array< T >	operator- (const Array< T > &left, const T &right)
template<class T >
Array< T >	operator* (const Array< T > &left, const T &right)
template<class T >
Array< T >	operator/ (const Array< T > &left, const T &right)
template<class T >
Array< T >	operator% (const Array< T > &left, const T &right)
template<class T >
Array< T >	operator\| (const Array< T > &left, const T &right)
template<class T >
Array< T >	operator& (const Array< T > &left, const T &right)
template<class T >
Array< T >	operator^ (const Array< T > &left, const T &right)
template<class T >
Array< T >	operator+ (const T &left, const Array< T > &right)
	Element by element arithmetic between a scalar and an array, returning an array.
template<class T >
Array< T >	operator- (const T &left, const Array< T > &right)
template<class T >
Array< T >	operator* (const T &left, const Array< T > &right)
template<class T >
Array< T >	operator/ (const T &left, const Array< T > &right)
template<class T >
Array< T >	operator% (const T &left, const Array< T > &right)
template<class T >
Array< T >	operator\| (const T &left, const Array< T > &right)
template<class T >
Array< T >	operator& (const T &left, const Array< T > &right)
template<class T >
Array< T >	operator^ (const T &left, const Array< T > &right)
template<class T >
Array< T >	cos (const Array< T > &a)
	Transcendental function that can be applied to essentially all numeric types.
template<class T >
Array< T >	cosh (const Array< T > &a)
template<class T >
Array< T >	exp (const Array< T > &a)
template<class T >
Array< T >	log (const Array< T > &a)
template<class T >
Array< T >	log10 (const Array< T > &a)
template<class T >
Array< T >	pow (const Array< T > &a, const Array< T > &b)
template<class T >
Array< T >	pow (const T &a, const Array< T > &b)
template<class T >
Array< T >	sin (const Array< T > &a)
template<class T >
Array< T >	sinh (const Array< T > &a)
template<class T >
Array< T >	sqrt (const Array< T > &a)
template<class T >
Array< T >	acos (const Array< T > &a)
	Transcendental function applied to the array on an element-by-element basis.
template<class T >
Array< T >	asin (const Array< T > &a)
template<class T >
Array< T >	atan (const Array< T > &a)
template<class T >
Array< T >	atan2 (const Array< T > &y, const Array< T > &x)
template<class T >
Array< T >	atan2 (const T &y, const Array< T > &x)
template<class T >
Array< T >	atan2 (const Array< T > &y, const T &x)
template<class T >
Array< T >	ceil (const Array< T > &a)
template<class T >
Array< T >	fabs (const Array< T > &a)
template<class T >
Array< T >	abs (const Array< T > &a)
template<class T >
Array< T >	floor (const Array< T > &a)
template<class T >
Array< T >	round (const Array< T > &a)
template<class T >
Array< T >	sign (const Array< T > &a)
template<class T >
Array< T >	fmod (const Array< T > &a, const Array< T > &b)
template<class T >
Array< T >	fmod (const T &a, const Array< T > &b)
template<class T >
Array< T >	fmod (const Array< T > &a, const T &b)
template<class T >
Array< T >	floormod (const Array< T > &a, const Array< T > &b)
template<class T >
Array< T >	floormod (const T &a, const Array< T > &b)
template<class T >
Array< T >	floormod (const Array< T > &a, const T &b)
template<class T >
Array< T >	pow (const Array< T > &a, const Double &b)
template<class T >
Array< T >	tan (const Array< T > &a)
template<class T >
Array< T >	tanh (const Array< T > &a)
template<class T >
Array< T >	fabs (const Array< T > &a)
	N.B.
template<class ScalarType >
void	minMax (ScalarType &minVal, ScalarType &maxVal, IPosition &minPos, IPosition &maxPos, const Array< ScalarType > &array)
	Find the minimum and maximum values of an array, including their locations.
template<class ScalarType >
void	minMax (ScalarType &minVal, ScalarType &maxVal, IPosition &minPos, IPosition &maxPos, const Array< ScalarType > &array, const Array< Bool > &mask, Bool valid=True)
	The array is searched at locations where the mask equals `valid`.
template<class ScalarType >
void	minMaxMasked (ScalarType &minVal, ScalarType &maxVal, IPosition &minPos, IPosition &maxPos, const Array< ScalarType > &array, const Array< ScalarType > &weight)
	The array * weight is searched.
template<class T >
void	minMax (T &min, T &max, const Array< T > &a)
	The "min" and "max" functions require that the type "T" have comparison operators.
template<class T >
T	min (const Array< T > &a)
	The minimum element of the array.
template<class T >
T	max (const Array< T > &a)
	The maximum element of the array.
template<class T >
void	max (Array< T > &result, const Array< T > &a, const Array< T > &b)
	"result" contains the maximum of "a" and "b" at each position.
template<class T >
void	min (Array< T > &result, const Array< T > &a, const Array< T > &b)
	"result" contains the minimum of "a" and "b" at each position.
template<class T >
Array< T >	max (const Array< T > &a, const Array< T > &b)
	Return an array that contains the maximum of "a" and "b" at each position.
template<class T >
Array< T >	max (const T &a, const Array< T > &b)
template<class T >
Array< T >	min (const Array< T > &a, const Array< T > &b)
	Return an array that contains the minimum of "a" and "b" at each position.
template<class T >
void	max (Array< T > &result, const Array< T > &a, const T &b)
	"result" contains the maximum of "a" and "b" at each position.
template<class T >
void	max (Array< T > &result, const T &a, const Array< T > &b)
template<class T >
void	min (Array< T > &result, const Array< T > &a, const T &b)
	"result" contains the minimum of "a" and "b" at each position.
template<class T >
void	min (Array< T > &result, const T &a, const Array< T > &b)
template<class T >
Array< T >	max (const Array< T > &a, const T &b)
	Return an array that contains the maximum of "a" and "b" at each position.
template<class T >
Array< T >	max (const T &a, const Array< T > &b)
template<class T >
Array< T >	min (const Array< T > &a, const T &b)
	Return an array that contains the minimum of "a" and "b" at each position.
template<class T >
Array< T >	min (const T &a, const Array< T > &b)
template<class T >
void	indgen (Array< T > &a, T start, T inc)
	Fills all elements of "array" with a sequence starting with "start" and incrementing by "inc" for each element.
template<class T >
void	indgen (Array< T > &a)
	Fills all elements of "array" with a sequence starting with 0 and ending with nelements() - 1.
template<class T >
void	indgen (Array< T > &a, T start)
	Fills all elements of "array" with a sequence starting with start incremented by one for each position in the array.
template<class T >
Vector< T >	indgen (uInt length, T start, T inc)
	Create a Vector of the given length and fill it with the start value incremented with `inc` for each element.
template<class T >
T	sum (const Array< T > &a)
	Sum of every element of the array.
template<class T >
T	sumsqr (const Array< T > &a)
	Sum the square of every element of the array.
template<class T >
T	product (const Array< T > &a)
	Product of every element of the array.
template<class T >
T	mean (const Array< T > &a)
	The mean of "a" is the sum of all elements of "a" divided by the number of elements of "a".
template<class T >
T	variance (const Array< T > &a)
	The variance of "a" is the sum of (a(i) - mean(a))**2/(a.nelements() - 1).
template<class T >
T	variance (const Array< T > &a, T mean)
	The variance of "a" is the sum of (a(i) - mean(a))**2/(a.nelements() - 1).
template<class T >
T	stddev (const Array< T > &a)
	The standard deviation of "a" is the square root of its variance.
template<class T >
T	stddev (const Array< T > &a, T mean)
	The standard deviation of "a" is the square root of its variance.
template<class T >
T	avdev (const Array< T > &a)
	The average deviation of "a" is the sum of abs(a(i) - mean(a))/N.
template<class T >
T	avdev (const Array< T > &a, T mean)
	The average deviation of "a" is the sum of abs(a(i) - mean(a))/N.
template<class T >
T	rms (const Array< T > &a)
	The root-mean-square of "a" is the sqrt of sum(a*a)/N.
template<class T >
T	median (const Array< T > &a, Block< T > &tmp, Bool sorted, Bool takeEvenMean, Bool inPlace=False)
	The median of "a" is a(n/2).
template<class T >
T	median (const Array< T > &a, Bool sorted, Bool takeEvenMean, Bool inPlace=False)
template<class T >
T	median (const Array< T > &a, Bool sorted)
template<class T >
T	median (const Array< T > &a)
template<class T >
T	medianInPlace (const Array< T > &a, Bool sorted=False)
template<class T >
T	madfm (const Array< T > &a, Block< T > &tmp, Bool sorted, Bool takeEvenMean, Bool inPlace=False)
	The median absolute deviation from the median.
template<class T >
T	madfm (const Array< T > &a, Bool sorted, Bool takeEvenMean, Bool inPlace=False)
template<class T >
T	madfm (const Array< T > &a, Bool sorted)
template<class T >
T	madfm (const Array< T > &a)
template<class T >
T	madfmInPlace (const Array< T > &a, Bool sorted=False)
template<class T >
T	fractile (const Array< T > &a, Block< T > &tmp, Float fraction, Bool sorted=False, Bool inPlace=False)
	Return the fractile of an array.
template<class T >
T	fractile (const Array< T > &a, Float fraction, Bool sorted=False, Bool inPlace=False)
template<class T >
T	interFractileRange (const Array< T > &a, Block< T > &tmp, Float fraction, Bool sorted=False, Bool inPlace=False)
	Return the inter-fractile range of an array.
template<class T >
T	interFractileRange (const Array< T > &a, Float fraction, Bool sorted=False, Bool inPlace=False)
template<class T >
T	interHexileRange (const Array< T > &a, Block< T > &tmp, Bool sorted=False, Bool inPlace=False)
	Return the inter-hexile range of an array.
template<class T >
T	interHexileRange (const Array< T > &a, Bool sorted=False, Bool inPlace=False)
template<class T >
T	interQuartileRange (const Array< T > &a, Block< T > &tmp, Bool sorted=False, Bool inPlace=False)
	Return the inter-quartile range of an array.
template<class T >
T	interQuartileRange (const Array< T > &a, Bool sorted=False, Bool inPlace=False)
template<typename T >
void	operator*= (Array< std::complex< T > > &left, const Array< T > &other)
	Methods for element-by-element scaling of complex and real.
template<typename T >
void	operator*= (Array< std::complex< T > > &left, const T &other)
template<typename T >
void	operator/= (Array< std::complex< T > > &left, const Array< T > &other)
template<typename T >
void	operator/= (Array< std::complex< T > > &left, const T &other)
template<typename T >
Array< std::complex< T > >	operator* (const Array< std::complex< T > > &left, const Array< T > &right)
template<typename T >
Array< std::complex< T > >	operator* (const Array< std::complex< T > > &left, const T &right)
template<typename T >
Array< std::complex< T > >	operator* (const std::complex< T > &left, const Array< T > &right)
template<typename T >
Array< std::complex< T > >	operator/ (const Array< std::complex< T > > &left, const Array< T > &right)
template<typename T >
Array< std::complex< T > >	operator/ (const Array< std::complex< T > > &left, const T &right)
template<typename T >
Array< std::complex< T > >	operator/ (const std::complex< T > &left, const Array< T > &right)
Array< Complex >	conj (const Array< Complex > &carray)
	Returns the complex conjugate of a complex array.
Array< DComplex >	conj (const Array< DComplex > &carray)
void	conj (Array< Complex > &rarray, const Array< Complex > &carray)
	Modifies rarray in place.
void	conj (Array< DComplex > &rarray, const Array< DComplex > &carray)
Matrix< Complex >	conj (const Matrix< Complex > &carray)
Matrix< DComplex >	conj (const Matrix< DComplex > &carray)
template<typename T >
Array< std::complex< T > >	makeComplex (const Array< T > &real, const Array< T > &imag)
	Form an array of complex numbers from the given real arrays.
template<typename T >
Array< std::complex< T > >	makeComplex (const T &real, const Array< T > &imag)
template<typename T >
Array< std::complex< T > >	makeComplex (const Array< T > &real, const T &imag)
template<typename L , typename R >
void	setReal (Array< L > &carray, const Array< R > &rarray)
	Set the real part of the left complex array to the right real array.
template<typename R , typename L >
void	setImag (Array< R > &carray, const Array< L > &rarray)
	Set the imaginary part of the left complex array to right real array.
Array< Float >	real (const Array< Complex > &carray)
	Extracts the real part of a complex array into an array of floats.
Array< Double >	real (const Array< DComplex > &carray)
void	real (Array< Float > &rarray, const Array< Complex > &carray)
	Modifies rarray in place.
void	real (Array< Double > &rarray, const Array< DComplex > &carray)
Array< Float >	imag (const Array< Complex > &carray)
	Extracts the imaginary part of a complex array into an array of floats.
Array< Double >	imag (const Array< DComplex > &carray)
void	imag (Array< Float > &rarray, const Array< Complex > &carray)
	Modifies rarray in place.
void	imag (Array< Double > &rarray, const Array< DComplex > &carray)
Array< Float >	amplitude (const Array< Complex > &carray)
	Extracts the amplitude (i.e.
Array< Double >	amplitude (const Array< DComplex > &carray)
void	amplitude (Array< Float > &rarray, const Array< Complex > &carray)
	Modifies rarray in place.
void	amplitude (Array< Double > &rarray, const Array< DComplex > &carray)
Array< Float >	phase (const Array< Complex > &carray)
	Extracts the phase (i.e.
Array< Double >	phase (const Array< DComplex > &carray)
void	phase (Array< Float > &rarray, const Array< Complex > &carray)
	Modifies rarray in place.
void	phase (Array< Double > &rarray, const Array< DComplex > &carray)
Array< Float >	ComplexToReal (const Array< Complex > &carray)
	Copy an array of complex into an array of real,imaginary pairs.
Array< Double >	ComplexToReal (const Array< DComplex > &carray)
void	ComplexToReal (Array< Float > &rarray, const Array< Complex > &carray)
	Modify the array "rarray" in place.
void	ComplexToReal (Array< Double > &rarray, const Array< DComplex > &carray)
Array< Complex >	RealToComplex (const Array< Float > &rarray)
	Copy an array of real,imaginary pairs into a complex array.
Array< DComplex >	RealToComplex (const Array< Double > &rarray)
void	RealToComplex (Array< Complex > &carray, const Array< Float > &rarray)
	Modify the array "carray" in place.
void	RealToComplex (Array< DComplex > &carray, const Array< Double > &rarray)
template<class T , class U >
void	convertArray (Array< T > &to, const Array< U > &from)
	Make a copy of an array of a different type; for example make an array of doubles from an array of floats.
template<class T >
Array< T >	square (const Array< T > &val)
	Returns an array where every element is squared.
template<class T >
Array< T >	cube (const Array< T > &val)
	Returns an array where every element is cubed.
template<class T >
void	expandArray (Array< T > &out, const Array< T > &in, const IPosition &alternate=IPosition())
	Expand the values of an array.
template<class T >
T *	expandRecursive (int axis, const IPosition &shp, const IPosition &mult, const IPosition &inSteps, const T in, T out, const IPosition &alternate)
	Helper function for expandArray using recursion for each axis.
IPosition	checkExpandArray (IPosition &mult, const IPosition &inShape, const IPosition &outShape, const IPosition &alternate)
	Check array shapes for expandArray.

Detailed Description

Mathematical operations for Arrays.

Review Status

Reviewed By:: UNKNOWN
Date Reviewed:: before2004/08/25
Test programs:: tArray

Prerequisite

Array

Etymology

This file contains global functions which perform element by element mathematical operations on arrays.

Synopsis

These functions perform element by element mathematical operations on arrays. The two arrays must conform.

Furthermore it defines functions a la std::transform to transform one or two arrays by means of a unary or binary operator. All math and logical operations on arrays can be expressed by means of these transform functions.
It also defines an in-place transform function because for non-trivial iterators it works faster than a transform where the result is an iterator on the same data object as the left operand.
The transform functions distinguish between contiguous and non-contiguous arrays because iterating through a contiguous array can be done in a faster way.
Similar to the standard transform function these functions do not check if the shapes match. The user is responsible for that.

Example

 Vector<Int> a(10);
 Vector<Int> b(10);
 Vector<Int> c(10);
 . . .
 c = a + b;

This example sets the elements of c to (a+b). It checks if a and b have the same shape. The result of this operation is an Array.

Example

 c = arrayTransformResult (a, b, std::plus<Double>());

This example does the same as the previous example, but expressed using the transform function (which, in fact, is used by the + operator above). However, it is not checked if the shapes match.

Example

 arrayContTransform (a, b, c, std::plus<Double>());

This example does the same as the previous example, but is faster because the result array already exists and does not need to be allocated. Note that the caller must be sure that c is contiguous.

Example

 Vector<Double> a(10);
 Vector<Double> b(10);
 Vector<Double> c(10);
 . . .
 c = atan2 (a, b);

This example sets the elements of c to atan2 (a,b). The result of this operation is an Array.

Example

 Vector<Int> a(10);
 Int result;
 . . .
 result = sum (a);

This example sums a.

Motivation

One wants to be able to perform mathematical operations on arrays.

Definition at line 140 of file ArrayMath.h.

Member Function Documentation

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::abs ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::acos ( const Array< T > & a ) [inline]

Transcendental function applied to the array on an element-by-element basis.

Although a template function, this does not make sense for all numeric types.

void casacore::ArrayMath_global_functions_Array_mathematical_operations::amplitude	(	Array< Double > &	rarray,
		const Array< DComplex > &	carray
	)

void casacore::ArrayMath_global_functions_Array_mathematical_operations::amplitude	(	Array< Float > &	rarray,
		const Array< Complex > &	carray
	)

Modifies rarray in place.

rarray must be conformant.

Array<Double> casacore::ArrayMath_global_functions_Array_mathematical_operations::amplitude ( const Array< DComplex > & carray )

Array<Float> casacore::ArrayMath_global_functions_Array_mathematical_operations::amplitude ( const Array< Complex > & carray )

Extracts the amplitude (i.e.

sqrt(re*re + im*im)) from an array of complex numbers. N.B. this is presently called "fabs" for a single complex number.

template<typename T , typename RES , typename UnaryOperator >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayContTransform	(	const Array< T > &	arr,
		Array< RES > &	result,
		UnaryOperator	op
	)			`[inline]`

Transform array to a result using the unary operator.

Result MUST be a contiguous array.

Definition at line 248 of file ArrayMath.h.

References casacore::Array< T >::begin(), casacore::Array< T >::cbegin(), casacore::Array< T >::cend(), casacore::ArrayBase::contiguousStorage(), DebugAssert, casacore::Array< T >::end(), and casa::utilj::transform().

template<typename L , typename R , typename RES , typename BinaryOperator >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayContTransform	(	L	left,
		const Array< R > &	right,
		Array< RES > &	result,
		BinaryOperator	op
	)			`[inline]`

Transform left and right to a result using the binary operator.

Result MUST be a contiguous array.

Definition at line 228 of file ArrayMath.h.

References casacore::Array< T >::begin(), casacore::Array< T >::cbegin(), casacore::Array< T >::cend(), casacore::ArrayBase::contiguousStorage(), DebugAssert, and casacore::Array< T >::end().

template<typename L , typename R , typename RES , typename BinaryOperator >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayContTransform	(	const Array< L > &	left,
		R	right,
		Array< RES > &	result,
		BinaryOperator	op
	)			`[inline]`

Transform left and right to a result using the binary operator.

Result MUST be a contiguous array.

Definition at line 208 of file ArrayMath.h.

References casacore::Array< T >::begin(), casacore::Array< T >::cbegin(), casacore::Array< T >::cend(), casacore::ArrayBase::contiguousStorage(), DebugAssert, and casacore::Array< T >::end().

template<typename L , typename R , typename RES , typename BinaryOperator >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayContTransform	(	const Array< L > &	left,
		const Array< R > &	right,
		Array< RES > &	result,
		BinaryOperator	op
	)			`[inline]`

Functions to apply a binary or unary operator to arrays.

They are modeled after std::transform. They do not check if the shapes conform; as in std::transform the user must take care that the operands conform.

Transform left and right to a result using the binary operator. Result MUST be a contiguous array.

Definition at line 192 of file ArrayMath.h.

References casacore::Array< T >::begin(), casacore::Array< T >::cbegin(), casacore::Array< T >::cend(), casacore::ArrayBase::contiguousStorage(), DebugAssert, casacore::Array< T >::end(), and casa::utilj::transform().

template<typename T , typename RES , typename UnaryOperator >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransform	(	const Array< T > &	arr,
		Array< RES > &	result,
		UnaryOperator	op
	)			`[inline]`

Transform array to a result using the unary operator.

Result need not be a contiguous array.

template<typename L , typename R , typename RES , typename BinaryOperator >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransform	(	L	left,
		const Array< R > &	right,
		Array< RES > &	result,
		BinaryOperator	op
	)			`[inline]`

Transform left and right to a result using the binary operator.

Result need not be a contiguous array.

template<typename L , typename R , typename RES , typename BinaryOperator >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransform	(	const Array< L > &	left,
		R	right,
		Array< RES > &	result,
		BinaryOperator	op
	)			`[inline]`

Transform left and right to a result using the binary operator.

Result need not be a contiguous array.

template<typename L , typename R , typename RES , typename BinaryOperator >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransform	(	const Array< L > &	left,
		const Array< R > &	right,
		Array< RES > &	result,
		BinaryOperator	op
	)			`[inline]`

Transform left and right to a result using the binary operator.

Result need not be a contiguous array.

template<typename T , typename UnaryOperator >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransformInPlace	(	Array< T > &	arr,
		UnaryOperator	op
	)			`[inline]`

Transform the array in place using the unary operator.

E.g. doing arrayTransformInPlace(array, Sin<T>()) is faster than array=sin(array) as it does not need to create a temporary array.

Definition at line 335 of file ArrayMath.h.

References casacore::Array< T >::begin(), casacore::Array< T >::cbegin(), casacore::Array< T >::cend(), casacore::ArrayBase::contiguousStorage(), casacore::Array< T >::end(), and casacore::transformInPlace().

template<typename L , typename R , typename BinaryOperator >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransformInPlace	(	Array< L > &	left,
		R	right,
		BinaryOperator	op
	)			`[inline]`

Transform left and right in place using the binary operator.

The result is stored in the left array (useful for e.g. the += operation).

Definition at line 320 of file ArrayMath.h.

References casacore::Array< T >::begin(), casacore::Array< T >::cbegin(), casacore::Array< T >::cend(), casacore::ArrayBase::contiguousStorage(), and casacore::Array< T >::end().

template<typename L , typename R , typename BinaryOperator >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransformInPlace	(	Array< L > &	left,
		const Array< R > &	right,
		BinaryOperator	op
	)			`[inline]`

Transform left and right in place using the binary operator.

The result is stored in the left array (useful for e.g. the += operation).

Definition at line 307 of file ArrayMath.h.

References casacore::Array< T >::begin(), casacore::Array< T >::cbegin(), casacore::Array< T >::cend(), casacore::ArrayBase::contiguousStorage(), casacore::Array< T >::end(), and casacore::transformInPlace().

template<typename T , typename UnaryOperator >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransformResult	(	const Array< T > &	arr,
		UnaryOperator	op
	)			`[inline]`

Transform array to a result using the unary operator.

The created and returned result array is contiguous.

template<typename T , typename BinaryOperator >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransformResult	(	T	left,
		const Array< T > &	right,
		BinaryOperator	op
	)			`[inline]`

Transform left and right to a result using the binary operator.

The created and returned result array is contiguous.

template<typename T , typename BinaryOperator >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransformResult	(	const Array< T > &	left,
		T	right,
		BinaryOperator	op
	)			`[inline]`

Transform left and right to a result using the binary operator.

The created and returned result array is contiguous.

template<typename T , typename BinaryOperator >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransformResult	(	const Array< T > &	left,
		const Array< T > &	right,
		BinaryOperator	op
	)			`[inline]`

Transform left and right to a result using the binary operator.

The created and returned result array is contiguous.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::asin ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::atan ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::atan2	(	const Array< T > &	y,
		const T &	x
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::atan2	(	const T &	y,
		const Array< T > &	x
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::atan2	(	const Array< T > &	y,
		const Array< T > &	x
	)			`[inline]`

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::avdev	(	const Array< T > &	a,
		T	mean
	)			`[inline]`

The average deviation of "a" is the sum of abs(a(i) - mean(a))/N.

(N.B. N, not N-1 in the denominator). Rather than using a computed mean, use the supplied value.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::avdev ( const Array< T > & a ) [inline]

The average deviation of "a" is the sum of abs(a(i) - mean(a))/N.

(N.B. N, not N-1 in the denominator).

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::ceil ( const Array< T > & a ) [inline]

IPosition casacore::ArrayMath_global_functions_Array_mathematical_operations::checkExpandArray	(	IPosition &	mult,
		const IPosition &	inShape,
		const IPosition &	outShape,
		const IPosition &	alternate
	)

Check array shapes for expandArray.

It returns the alternate argument, where possibly missing values are appended (as 0).

void casacore::ArrayMath_global_functions_Array_mathematical_operations::ComplexToReal	(	Array< Double > &	rarray,
		const Array< DComplex > &	carray
	)

void casacore::ArrayMath_global_functions_Array_mathematical_operations::ComplexToReal	(	Array< Float > &	rarray,
		const Array< Complex > &	carray
	)

Modify the array "rarray" in place.

"rarray" must be the correct shape.

Array<Double> casacore::ArrayMath_global_functions_Array_mathematical_operations::ComplexToReal ( const Array< DComplex > & carray )

Array<Float> casacore::ArrayMath_global_functions_Array_mathematical_operations::ComplexToReal ( const Array< Complex > & carray )

Copy an array of complex into an array of real,imaginary pairs.

The first axis of the real array becomes twice as long as the complex array. In the future versions which work by reference will be available; presently a copy is made.

Matrix<DComplex> casacore::ArrayMath_global_functions_Array_mathematical_operations::conj ( const Matrix< DComplex > & carray )

Matrix<Complex> casacore::ArrayMath_global_functions_Array_mathematical_operations::conj ( const Matrix< Complex > & carray )

void casacore::ArrayMath_global_functions_Array_mathematical_operations::conj	(	Array< DComplex > &	rarray,
		const Array< DComplex > &	carray
	)

void casacore::ArrayMath_global_functions_Array_mathematical_operations::conj	(	Array< Complex > &	rarray,
		const Array< Complex > &	carray
	)

Modifies rarray in place.

rarray must be conformant.

Array<DComplex> casacore::ArrayMath_global_functions_Array_mathematical_operations::conj ( const Array< DComplex > & carray )

Array<Complex> casacore::ArrayMath_global_functions_Array_mathematical_operations::conj ( const Array< Complex > & carray )

Returns the complex conjugate of a complex array.

template<class T , class U >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::convertArray	(	Array< T > &	to,
		const Array< U > &	from
	)			`[inline]`

Make a copy of an array of a different type; for example make an array of doubles from an array of floats.

Arrays to and from must be conformant (same shape). Also, it must be possible to convert a scalar of type U to type T.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::cos ( const Array< T > & a ) [inline]

Transcendental function that can be applied to essentially all numeric types.

Works on an element-by-element basis.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::cosh ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::cube ( const Array< T > & val ) [inline]

Returns an array where every element is cubed.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::exp ( const Array< T > & a ) [inline]

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::expandArray	(	Array< T > &	out,
		const Array< T > &	in,
		const IPosition &	alternate = `IPosition()`
	)			`[inline]`

Expand the values of an array.

The arrays must have the same dimensionality. The length of each axis in the input array must be <= the length of the corresponding axis in the output array and divide evenly. For each axis mult is set to output/input.
The alternate argument determines how the values are expanded. If a row contains values '1 2 3', they can be expanded "linearly" as '1 1 2 2 3 3' or alternately as '1 2 3 1 2 3' This choice can be made for each axis; a value 0 means linearly, another value means alternately. If the length of alternate is less than the dimensionality of the arrays, the missing ones default to 0.

template<class T >

T* casacore::ArrayMath_global_functions_Array_mathematical_operations::expandRecursive	(	int	axis,
		const IPosition &	shp,
		const IPosition &	mult,
		const IPosition &	inSteps,
		const T *	in,
		T *	out,
		const IPosition &	alternate
	)			`[inline]`

Helper function for expandArray using recursion for each axis.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::fabs ( const Array< T > & a ) [inline]

N.B.

fabs is deprecated. Use abs.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::fabs ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::floor ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::floormod	(	const Array< T > &	a,
		const T &	b
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::floormod	(	const T &	a,
		const Array< T > &	b
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::floormod	(	const Array< T > &	a,
		const Array< T > &	b
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::fmod	(	const Array< T > &	a,
		const T &	b
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::fmod	(	const T &	a,
		const Array< T > &	b
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::fmod	(	const Array< T > &	a,
		const Array< T > &	b
	)			`[inline]`

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::fractile	(	const Array< T > &	a,
		Float	fraction,
		Bool	sorted = `False`,
		Bool	inPlace = `False`
	)			`[inline]`

Definition at line 700 of file ArrayMath.h.

References fractile().

Referenced by fractile().

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::fractile	(	const Array< T > &	a,
		Block< T > &	tmp,
		Float	fraction,
		Bool	sorted = `False`,
		Bool	inPlace = `False`
	)			`[inline]`

Return the fractile of an array.

It returns the value at the given fraction of the array. A fraction of 0.5 is the same as the median, be it that no mean of the two middle elements is taken if the array has an even nr of elements. It uses kthLargest if the array is not sorted yet.
Note: The function kthLargest in class GenSortIndirect can be used to obtain the index of the fractile in an array;

void casacore::ArrayMath_global_functions_Array_mathematical_operations::imag	(	Array< Double > &	rarray,
		const Array< DComplex > &	carray
	)

void casacore::ArrayMath_global_functions_Array_mathematical_operations::imag	(	Array< Float > &	rarray,
		const Array< Complex > &	carray
	)

Modifies rarray in place.

rarray must be conformant.

Array<Double> casacore::ArrayMath_global_functions_Array_mathematical_operations::imag ( const Array< DComplex > & carray )

Array<Float> casacore::ArrayMath_global_functions_Array_mathematical_operations::imag ( const Array< Complex > & carray )

Extracts the imaginary part of a complex array into an array of floats.

template<class T >

Vector<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::indgen	(	uInt	length,
		T	start,
		T	inc
	)			`[inline]`

Create a Vector of the given length and fill it with the start value incremented with inc for each element.

Definition at line 588 of file ArrayMath.h.

References casacore::indgen().

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::indgen	(	Array< T > &	a,
		T	start
	)			`[inline]`

Fills all elements of "array" with a sequence starting with start incremented by one for each position in the array.

The first axis varies most rapidly.

Definition at line 583 of file ArrayMath.h.

References indgen().

Referenced by indgen().

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::indgen ( Array< T > & a ) [inline]

Fills all elements of "array" with a sequence starting with 0 and ending with nelements() - 1.

The first axis varies most rapidly.

Definition at line 577 of file ArrayMath.h.

References indgen().

Referenced by indgen().

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::indgen	(	Array< T > &	a,
		T	start,
		T	inc
	)			`[inline]`

Fills all elements of "array" with a sequence starting with "start" and incrementing by "inc" for each element.

The first axis varies most rapidly.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interFractileRange	(	const Array< T > &	a,
		Float	fraction,
		Bool	sorted = `False`,
		Bool	inPlace = `False`
	)			`[inline]`

Definition at line 710 of file ArrayMath.h.

References interFractileRange().

Referenced by interFractileRange().

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interFractileRange	(	const Array< T > &	a,
		Block< T > &	tmp,
		Float	fraction,
		Bool	sorted = `False`,
		Bool	inPlace = `False`
	)			`[inline]`

Return the inter-fractile range of an array.

This is the full range between the bottom and the top fraction.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interHexileRange	(	const Array< T > &	a,
		Bool	sorted = `False`,
		Bool	inPlace = `False`
	)			`[inline]`

Definition at line 725 of file ArrayMath.h.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interHexileRange	(	const Array< T > &	a,
		Block< T > &	tmp,
		Bool	sorted = `False`,
		Bool	inPlace = `False`
	)			`[inline]`

Return the inter-hexile range of an array.

This is the full range between the bottom sixth and the top sixth of ordered array values. The semi-interhexile range is very nearly equal to the rms for a Gaussian distribution, but it is much less sensitive to the tails of extended distributions. (Condon et al 1998)

Definition at line 722 of file ArrayMath.h.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interQuartileRange	(	const Array< T > &	a,
		Bool	sorted = `False`,
		Bool	inPlace = `False`
	)			`[inline]`

Definition at line 737 of file ArrayMath.h.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interQuartileRange	(	const Array< T > &	a,
		Block< T > &	tmp,
		Bool	sorted = `False`,
		Bool	inPlace = `False`
	)			`[inline]`

Return the inter-quartile range of an array.

This is the full range between the bottom quarter and the top quarter of ordered array values.

Definition at line 734 of file ArrayMath.h.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::log ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::log10 ( const Array< T > & a ) [inline]

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::madfm ( const Array< T > & a ) [inline]

Definition at line 685 of file ArrayMath.h.

References casacore::False, madfm(), and casacore::ArrayBase::nelements().

Referenced by madfm().

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::madfm	(	const Array< T > &	a,
		Bool	sorted
	)			`[inline]`

Definition at line 683 of file ArrayMath.h.

References casacore::False, madfm(), and casacore::ArrayBase::nelements().

Referenced by madfm().

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::madfm	(	const Array< T > &	a,
		Bool	sorted,
		Bool	takeEvenMean,
		Bool	inPlace = `False`
	)			`[inline]`

Definition at line 680 of file ArrayMath.h.

References madfm().

Referenced by madfm().

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::madfm	(	const Array< T > &	a,
		Block< T > &	tmp,
		Bool	sorted,
		Bool	takeEvenMean,
		Bool	inPlace = `False`
	)			`[inline]`

The median absolute deviation from the median.

Interface is as for the median functions

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::madfmInPlace	(	const Array< T > &	a,
		Bool	sorted = `False`
	)			`[inline]`

Definition at line 687 of file ArrayMath.h.

References casacore::ArrayBase::nelements(), and casacore::True.

template<typename T >

Array<std::complex<T> > casacore::ArrayMath_global_functions_Array_mathematical_operations::makeComplex	(	const Array< T > &	real,
		const T &	imag
	)			`[inline]`

template<typename T >

Array<std::complex<T> > casacore::ArrayMath_global_functions_Array_mathematical_operations::makeComplex	(	const T &	real,
		const Array< T > &	imag
	)			`[inline]`

template<typename T >

Array<std::complex<T> > casacore::ArrayMath_global_functions_Array_mathematical_operations::makeComplex	(	const Array< T > &	real,
		const Array< T > &	imag
	)			`[inline]`

Form an array of complex numbers from the given real arrays.

Note that Complex and DComplex are simply typedefs for std::complex<float> and std::complex<double>, so the result is in fact one of these types.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::max	(	const T &	a,
		const Array< T > &	b
	)			`[inline]`

Definition at line 560 of file ArrayMath.h.

References max().

Referenced by max().

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::max	(	const Array< T > &	a,
		const T &	b
	)			`[inline]`

Return an array that contains the maximum of "a" and "b" at each position.

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::max	(	Array< T > &	result,
		const T &	a,
		const Array< T > &	b
	)			`[inline]`

Definition at line 548 of file ArrayMath.h.

References max().

Referenced by max().

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::max	(	Array< T > &	result,
		const Array< T > &	a,
		const T &	b
	)			`[inline]`

"result" contains the maximum of "a" and "b" at each position.

"result", and "a" must be conformant.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::max	(	const T &	a,
		const Array< T > &	b
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::max	(	const Array< T > &	a,
		const Array< T > &	b
	)			`[inline]`

Return an array that contains the maximum of "a" and "b" at each position.

"a" and "b" must be conformant.

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::max	(	Array< T > &	result,
		const Array< T > &	a,
		const Array< T > &	b
	)			`[inline]`

"result" contains the maximum of "a" and "b" at each position.

"result", "a", and "b" must be conformant.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::max ( const Array< T > & a ) [inline]

The maximum element of the array.

Requires that the type "T" has comparison operators.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::mean ( const Array< T > & a ) [inline]

The mean of "a" is the sum of all elements of "a" divided by the number of elements of "a".

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::median ( const Array< T > & a ) [inline]

Definition at line 669 of file ArrayMath.h.

References casacore::False, median(), and casacore::ArrayBase::nelements().

Referenced by median().

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::median	(	const Array< T > &	a,
		Bool	sorted
	)			`[inline]`

Definition at line 667 of file ArrayMath.h.

References casacore::False, median(), and casacore::ArrayBase::nelements().

Referenced by median().

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::median	(	const Array< T > &	a,
		Bool	sorted,
		Bool	takeEvenMean,
		Bool	inPlace = `False`
	)			`[inline]`

Definition at line 664 of file ArrayMath.h.

References median().

Referenced by median().

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::median	(	const Array< T > &	a,
		Block< T > &	tmp,
		Bool	sorted,
		Bool	takeEvenMean,
		Bool	inPlace = `False`
	)			`[inline]`

The median of "a" is a(n/2).

If a has an even number of elements and the switch takeEvenMean is set, the median is 0.5*(a(n/2) + a((n+1)/2)). According to Numerical Recipes (2nd edition) it makes little sense to take the mean if the array is large enough (> 100 elements). Therefore the default for takeEvenMean is False if the array has > 100 elements, otherwise it is True.
If "sorted"==True we assume the data is already sorted and we compute the median directly. Otherwise the function GenSort::kthLargest is used to find the median (kthLargest is about 6 times faster than a full quicksort).
Finding the median means that the array has to be (partially) sorted. By default a copy will be made, but if "inPlace" is in effect, the data themselves will be sorted. That should only be used if the data are used not thereafter.
Note: The function kthLargest in class GenSortIndirect can be used to obtain the index of the median in an array;

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::medianInPlace	(	const Array< T > &	a,
		Bool	sorted = `False`
	)			`[inline]`

Definition at line 671 of file ArrayMath.h.

References casacore::median(), casacore::ArrayBase::nelements(), and casacore::True.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::min	(	const T &	a,
		const Array< T > &	b
	)			`[inline]`

Definition at line 564 of file ArrayMath.h.

References min().

Referenced by min().

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::min	(	const Array< T > &	a,
		const T &	b
	)			`[inline]`

Return an array that contains the minimum of "a" and "b" at each position.

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::min	(	Array< T > &	result,
		const T &	a,
		const Array< T > &	b
	)			`[inline]`

Definition at line 555 of file ArrayMath.h.

References min().

Referenced by min().

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::min	(	Array< T > &	result,
		const Array< T > &	a,
		const T &	b
	)			`[inline]`

"result" contains the minimum of "a" and "b" at each position.

"result", and "a" must be conformant.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::min	(	const Array< T > &	a,
		const Array< T > &	b
	)			`[inline]`

Return an array that contains the minimum of "a" and "b" at each position.

"a" and "b" must be conformant.

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::min	(	Array< T > &	result,
		const Array< T > &	a,
		const Array< T > &	b
	)			`[inline]`

"result" contains the minimum of "a" and "b" at each position.

"result", "a", and "b" must be conformant.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::min ( const Array< T > & a ) [inline]

The minimum element of the array.

Requires that the type "T" has comparison operators.

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::minMax	(	T &	min,
		T &	max,
		const Array< T > &	a
	)			`[inline]`

The "min" and "max" functions require that the type "T" have comparison operators.

This sets min and max to the minimum and maximum of the array to avoid having to do two passes with max() and min() separately.

template<class ScalarType >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::minMax	(	ScalarType &	minVal,
		ScalarType &	maxVal,
		IPosition &	minPos,
		IPosition &	maxPos,
		const Array< ScalarType > &	array,
		const Array< Bool > &	mask,
		Bool	valid = `True`
	)			`[inline]`

The array is searched at locations where the mask equals valid.

(at least one such position must exist or an exception will be thrown). MaskType should be an Array of Bool.

template<class ScalarType >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::minMax	(	ScalarType &	minVal,
		ScalarType &	maxVal,
		IPosition &	minPos,
		IPosition &	maxPos,
		const Array< ScalarType > &	array
	)			`[inline]`

Find the minimum and maximum values of an array, including their locations.

template<class ScalarType >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::minMaxMasked	(	ScalarType &	minVal,
		ScalarType &	maxVal,
		IPosition &	minPos,
		IPosition &	maxPos,
		const Array< ScalarType > &	array,
		const Array< ScalarType > &	weight
	)			`[inline]`

The array * weight is searched.

template<typename _InputIterator1 , typename T , typename _BinaryOperation >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::myiptransform	(	_InputIterator1	__first1,
		_InputIterator1	__last1,
		T	right,
		_BinaryOperation	__binary_op
	)			`[inline]`

sequence OP= scalar

Definition at line 174 of file ArrayMath.h.

template<typename _InputIterator1 , typename T , typename _OutputIterator , typename _BinaryOperation >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::myltransform	(	_InputIterator1	__first1,
		_InputIterator1	__last1,
		_OutputIterator	__result,
		T	left,
		_BinaryOperation	__binary_op
	)			`[inline]`

The myxtransform functions are defined to avoid a bug in g++-4.3.

That compiler generates incorrect code when only -g is used for a std::transform with a bind1st or bind2nd for a complex<float>. So, for example, the multiplication of a Complex array and Complex scalar would fail (see g++ bug 39678).

sequence = scalar OP sequence

Definition at line 152 of file ArrayMath.h.

template<typename _InputIterator1 , typename T , typename _OutputIterator , typename _BinaryOperation >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::myrtransform	(	_InputIterator1	__first1,
		_InputIterator1	__last1,
		_OutputIterator	__result,
		T	right,
		_BinaryOperation	__binary_op
	)			`[inline]`

sequence = sequence OP scalar

Definition at line 163 of file ArrayMath.h.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator%	(	const T &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator%	(	const Array< T > &	left,
		const T &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator%	(	const Array< T > &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator%=	(	Array< T > &	left,
		const T &	other
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator%=	(	Array< T > &	left,
		const Array< T > &	other
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator&	(	const T &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator&	(	const Array< T > &	left,
		const T &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator&	(	const Array< T > &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator&=	(	Array< T > &	left,
		const T &	other
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator&=	(	Array< T > &	left,
		const Array< T > &	other
	)			`[inline]`

template<typename T >

Array<std::complex<T> > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*	(	const std::complex< T > &	left,
		const Array< T > &	right
	)			`[inline]`

template<typename T >

Array<std::complex<T> > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*	(	const Array< std::complex< T > > &	left,
		const T &	right
	)			`[inline]`

template<typename T >

Array<std::complex<T> > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*	(	const Array< std::complex< T > > &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*	(	const T &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*	(	const Array< T > &	left,
		const T &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*	(	const Array< T > &	left,
		const Array< T > &	right
	)			`[inline]`

template<typename T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*=	(	Array< std::complex< T > > &	left,
		const T &	other
	)			`[inline]`

template<typename T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*=	(	Array< std::complex< T > > &	left,
		const Array< T > &	other
	)			`[inline]`

Methods for element-by-element scaling of complex and real.

Note that Complex and DComplex are typedefs for std::complex.

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*=	(	Array< T > &	left,
		const T &	other
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*=	(	Array< T > &	left,
		const Array< T > &	other
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+	(	const T &	left,
		const Array< T > &	right
	)			`[inline]`

Element by element arithmetic between a scalar and an array, returning an array.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+	(	const Array< T > &	left,
		const T &	right
	)			`[inline]`

Element by element arithmetic between an array and a scalar, returning an array.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+	(	const Array< T > &	left,
		const Array< T > &	right
	)			`[inline]`

Element by element arithmetic on two arrays, returning an array.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+ ( const Array< T > & a ) [inline]

Unary arithmetic operation.

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+=	(	Array< T > &	left,
		const T &	other
	)			`[inline]`

Element by element arithmetic modifying left in-place.

The scalar "other" behaves as if it were a conformant Array to left filled with constant values.

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+=	(	Array< T > &	left,
		const Array< T > &	other
	)			`[inline]`

Element by element arithmetic modifying left in-place.

left and other must be conformant.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator-	(	const T &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator-	(	const Array< T > &	left,
		const T &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator-	(	const Array< T > &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator- ( const Array< T > & a ) [inline]

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator-=	(	Array< T > &	left,
		const T &	other
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator-=	(	Array< T > &	left,
		const Array< T > &	other
	)			`[inline]`

template<typename T >

Array<std::complex<T> > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/	(	const std::complex< T > &	left,
		const Array< T > &	right
	)			`[inline]`

template<typename T >

Array<std::complex<T> > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/	(	const Array< std::complex< T > > &	left,
		const T &	right
	)			`[inline]`

template<typename T >

Array<std::complex<T> > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/	(	const Array< std::complex< T > > &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/	(	const T &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/	(	const Array< T > &	left,
		const T &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/	(	const Array< T > &	left,
		const Array< T > &	right
	)			`[inline]`

template<typename T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/=	(	Array< std::complex< T > > &	left,
		const T &	other
	)			`[inline]`

template<typename T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/=	(	Array< std::complex< T > > &	left,
		const Array< T > &	other
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/=	(	Array< T > &	left,
		const T &	other
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/=	(	Array< T > &	left,
		const Array< T > &	other
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator^	(	const T &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator^	(	const Array< T > &	left,
		const T &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator^	(	const Array< T > &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator^=	(	Array< T > &	left,
		const T &	other
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator^=	(	Array< T > &	left,
		const Array< T > &	other
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator\|	(	const T &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator\|	(	const Array< T > &	left,
		const T &	right
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator\|	(	const Array< T > &	left,
		const Array< T > &	right
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator\|=	(	Array< T > &	left,
		const T &	other
	)			`[inline]`

template<class T >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator\|=	(	Array< T > &	left,
		const Array< T > &	other
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::operator~ ( const Array< T > & a ) [inline]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::phase	(	Array< Double > &	rarray,
		const Array< DComplex > &	carray
	)

void casacore::ArrayMath_global_functions_Array_mathematical_operations::phase	(	Array< Float > &	rarray,
		const Array< Complex > &	carray
	)

Modifies rarray in place.

rarray must be conformant.

Array<Double> casacore::ArrayMath_global_functions_Array_mathematical_operations::phase ( const Array< DComplex > & carray )

Array<Float> casacore::ArrayMath_global_functions_Array_mathematical_operations::phase ( const Array< Complex > & carray )

Extracts the phase (i.e.

atan2(im, re)) from an array of complex numbers. N.B. this is presently called "arg" for a single complex number.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::pow	(	const Array< T > &	a,
		const Double &	b
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::pow	(	const T &	a,
		const Array< T > &	b
	)			`[inline]`

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::pow	(	const Array< T > &	a,
		const Array< T > &	b
	)			`[inline]`

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::product ( const Array< T > & a ) [inline]

Product of every element of the array.

This could of course easily overflow.

void casacore::ArrayMath_global_functions_Array_mathematical_operations::real	(	Array< Double > &	rarray,
		const Array< DComplex > &	carray
	)

void casacore::ArrayMath_global_functions_Array_mathematical_operations::real	(	Array< Float > &	rarray,
		const Array< Complex > &	carray
	)

Modifies rarray in place.

rarray must be conformant.

Array<Double> casacore::ArrayMath_global_functions_Array_mathematical_operations::real ( const Array< DComplex > & carray )

Array<Float> casacore::ArrayMath_global_functions_Array_mathematical_operations::real ( const Array< Complex > & carray )

Extracts the real part of a complex array into an array of floats.

void casacore::ArrayMath_global_functions_Array_mathematical_operations::RealToComplex	(	Array< DComplex > &	carray,
		const Array< Double > &	rarray
	)

void casacore::ArrayMath_global_functions_Array_mathematical_operations::RealToComplex	(	Array< Complex > &	carray,
		const Array< Float > &	rarray
	)

Modify the array "carray" in place.

"carray" must be the correct shape.

Array<DComplex> casacore::ArrayMath_global_functions_Array_mathematical_operations::RealToComplex ( const Array< Double > & rarray )

Array<Complex> casacore::ArrayMath_global_functions_Array_mathematical_operations::RealToComplex ( const Array< Float > & rarray )

Copy an array of real,imaginary pairs into a complex array.

The first axis must have an even length. In the future versions which work by reference will be available; presently a copy is made.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::rms ( const Array< T > & a ) [inline]

The root-mean-square of "a" is the sqrt of sum(a*a)/N.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::round ( const Array< T > & a ) [inline]

template<typename R , typename L >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::setImag	(	Array< R > &	carray,
		const Array< L > &	rarray
	)			`[inline]`

Set the imaginary part of the left complex array to right real array.

template<typename L , typename R >

void casacore::ArrayMath_global_functions_Array_mathematical_operations::setReal	(	Array< L > &	carray,
		const Array< R > &	rarray
	)			`[inline]`

Set the real part of the left complex array to the right real array.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::sign ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::sin ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::sinh ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::sqrt ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::square ( const Array< T > & val ) [inline]

Returns an array where every element is squared.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::stddev	(	const Array< T > &	a,
		T	mean
	)			`[inline]`

The standard deviation of "a" is the square root of its variance.

Rather than using a computed mean, use the supplied value.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::stddev ( const Array< T > & a ) [inline]

The standard deviation of "a" is the square root of its variance.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::sum ( const Array< T > & a ) [inline]

Sum of every element of the array.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::sumsqr ( const Array< T > & a ) [inline]

Sum the square of every element of the array.

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::tan ( const Array< T > & a ) [inline]

template<class T >

Array<T> casacore::ArrayMath_global_functions_Array_mathematical_operations::tanh ( const Array< T > & a ) [inline]

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::variance	(	const Array< T > &	a,
		T	mean
	)			`[inline]`

The variance of "a" is the sum of (a(i) - mean(a))**2/(a.nelements() - 1).

N.B. N-1, not N in the denominator). Rather than using a computed mean, use the supplied value.

template<class T >

T casacore::ArrayMath_global_functions_Array_mathematical_operations::variance ( const Array< T > & a ) [inline]

The variance of "a" is the sum of (a(i) - mean(a))**2/(a.nelements() - 1).

N.B. N-1, not N in the denominator).

The documentation for this struct was generated from the following file:

casacore/casa/Arrays/ArrayMath.h

casacore::ArrayMath_global_functions_Array_mathematical_operations Struct Reference

Public Member Functions

Detailed Description

Review Status

Prerequisite

Etymology

Synopsis

Example

Example

Example

Example

Example

Motivation

Member Function Documentation