Loading...
Searching...
No Matches
casacore::ArrayMath_global_functions_Array_mathematical_operations Struct Reference
casa package (libcasa_casa) » Arrays_module

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<typename T>
void | operator+= (Array< T > &left, const Array< T > &other)
| Element by element arithmetic modifying left in-place.
template<typename T>
void | operator-= (Array< T > &left, const Array< T > &other)
template<typename T>
void | operator*= (Array< T > &left, const Array< T > &other)
template<typename T>
void | operator/= (Array< T > &left, const Array< T > &other)
template<typename T>
void | operator%= (Array< T > &left, const Array< T > &other)
template<typename T>
void | operator&= (Array< T > &left, const Array< T > &other)
template<typename T>
void | operator|= (Array< T > &left, const Array< T > &other)
template<typename T>
void | operator^= (Array< T > &left, const Array< T > &other)
template<typename T>
void | operator+= (Array< T > &left, const T &other)
| Element by element arithmetic modifying left in-place.
template<typename T>
void | operator-= (Array< T > &left, const T &other)
template<typename T>
void | operator*= (Array< T > &left, const T &other)
template<typename T>
void | operator/= (Array< T > &left, const T &other)
template<typename T>
void | operator%= (Array< T > &left, const T &other)
template<typename T>
void | operator&= (Array< T > &left, const T &other)
template<typename T>
void | operator|= (Array< T > &left, const T &other)
template<typename T>
void | operator^= (Array< T > &left, const T &other)
template<typename T>
Array< T > | operator+ (const Array< T > &a)
| Unary arithmetic operation.
template<typename T>
Array< T > | operator- (const Array< T > &a)
template<typename T>
Array< T > | operator~ (const Array< T > &a)
template<typename T>
Array< T > | operator+ (const Array< T > &left, const Array< T > &right)
| Element by element arithmetic on two arrays, returning an array.
template<typename T>
Array< T > | operator- (const Array< T > &left, const Array< T > &right)
template<typename T>
Array< T > | operator* (const Array< T > &left, const Array< T > &right)
template<typename T>
Array< T > | operator/ (const Array< T > &left, const Array< T > &right)
template<typename T>
Array< T > | operator% (const Array< T > &left, const Array< T > &right)
template<typename T>
Array< T > | operator| (const Array< T > &left, const Array< T > &right)
template<typename T>
Array< T > | operator& (const Array< T > &left, const Array< T > &right)
template<typename T>
Array< T > | operator^ (const Array< T > &left, const Array< T > &right)
template<typename 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<typename 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<typename T>
Array< T > | operator/ (const Array< T > &left, const T &right)
template<typename T>
Array< T > | operator% (const Array< T > &left, const T &right)
template<typename T>
Array< T > | operator| (const Array< T > &left, const T &right)
template<typename T>
Array< T > | operator& (const Array< T > &left, const T &right)
template<typename T>
Array< T > | operator^ (const Array< T > &left, const T &right)
template<typename 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<typename 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<typename T>
Array< T > | operator/ (const T &left, const Array< T > &right)
template<typename T>
Array< T > | operator% (const T &left, const Array< T > &right)
template<typename T>
Array< T > | operator| (const T &left, const Array< T > &right)
template<typename T>
Array< T > | operator& (const T &left, const Array< T > &right)
template<typename T>
Array< T > | operator^ (const T &left, const Array< T > &right)
template<typename T>
Array< T > | cos (const Array< T > &a)
| Transcendental function that can be applied to essentially all numeric types.
template<typename T>
Array< T > | cosh (const Array< T > &a)
template<typename T>
Array< T > | exp (const Array< T > &a)
template<typename T>
Array< T > | log (const Array< T > &a)
template<typename T>
Array< T > | log10 (const Array< T > &a)
template<typename T>
Array< T > | pow (const Array< T > &a, const Array< T > &b)
template<typename T>
Array< T > | pow (const T &a, const Array< T > &b)
template<typename T>
Array< T > | sin (const Array< T > &a)
template<typename T>
Array< T > | sinh (const Array< T > &a)
template<typename T>
Array< T > | sqrt (const Array< T > &a)
template<typename T>
Array< T > | acos (const Array< T > &a)
| Transcendental function applied to the array on an element-by-element basis.
template<typename T>
Array< T > | asin (const Array< T > &a)
template<typename T>
Array< T > | atan (const Array< T > &a)
template<typename T>
Array< T > | atan2 (const Array< T > &y, const Array< T > &x)
template<typename T>
Array< T > | atan2 (const T &y, const Array< T > &x)
template<typename T>
Array< T > | atan2 (const Array< T > &y, const T &x)
template<typename T>
Array< T > | ceil (const Array< T > &a)
template<typename T>
Array< T > | fabs (const Array< T > &a)
template<typename T>
Array< T > | abs (const Array< T > &a)
template<typename T>
Array< T > | floor (const Array< T > &a)
template<typename T>
Array< T > | round (const Array< T > &a)
template<typename T>
Array< T > | sign (const Array< T > &a)
template<typename T>
Array< T > | fmod (const Array< T > &a, const Array< T > &b)
template<typename T>
Array< T > | fmod (const T &a, const Array< T > &b)
template<typename T>
Array< T > | fmod (const Array< T > &a, const T &b)
template<typename T>
Array< T > | floormod (const Array< T > &a, const Array< T > &b)
template<typename T>
Array< T > | floormod (const T &a, const Array< T > &b)
template<typename T>
Array< T > | floormod (const Array< T > &a, const T &b)
template<typename T>
Array< T > | pow (const Array< T > &a, const T &b)
template<typename T>
Array< std::complex< T > > | pow (const Array< std::complex< T > > &a, const T &b)
template<typename T>
Array< T > | tan (const Array< T > &a)
template<typename T>
Array< T > | tanh (const Array< T > &a)
template<typename T>
Array< T > | fabs (const Array< T > &a)
| N.B.
template<typename 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<typename 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<typename 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<typename 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<typename T>
T | min (const Array< T > &a)
| The minimum element of the array.
template<typename T>
T | max (const Array< T > &a)
| The maximum element of the array.
template<typename 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<typename 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<typename 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<typename T>
Array< T > | max (const T &a, const Array< T > &b)
template<typename 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<typename 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<typename T>
void | max (Array< T > &result, const T &a, const Array< T > &b)
template<typename 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<typename T>
void | min (Array< T > &result, const T &a, const Array< T > &b)
template<typename 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<typename T>
Array< T > | max (const T &a, const Array< T > &b)
template<typename 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<typename T>
Array< T > | min (const T &a, const Array< T > &b)
template<typename 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<typename T>
void | indgen (Array< T > &a)
| Fills all elements of "array" with a sequence starting with 0 and ending with nelements() - 1.
template<typename 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<typename T>
Vector< T > | indgen (size_t 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<typename T>
T | sum (const Array< T > &a)
| Sum of every element of the array.
template<typename T>
T | sumsqr (const Array< T > &a)
| Sum the square of every element of the array.
template<typename T>
T | product (const Array< T > &a)
| Product of every element of the array.
template<typename 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<typename T>
T | variance (const Array< T > &a)
| The variance of "a" is the sum of (a(i) - mean(a))**2/(a.nelements() - ddof).
template<typename T>
T | pvariance (const Array< T > &a, size_t ddof=0)
template<typename T>
T | variance (const Array< T > &a, T mean)
| Rather than using a computed mean, use the supplied value.
template<typename T>
T | pvariance (const Array< T > &a, T mean, size_t ddof=0)
template<typename T>
T | stddev (const Array< T > &a)
| The standard deviation of "a" is the square root of its variance.
template<typename T>
T | pstddev (const Array< T > &a, size_t ddof=0)
template<typename T>
T | stddev (const Array< T > &a, T mean)
template<typename T>
T | pstddev (const Array< T > &a, T mean, size_t ddof=0)
template<typename T>
T | avdev (const Array< T > &a)
| The average deviation of "a" is the sum of abs(a(i) - mean(a))/N.
template<typename 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<typename T>
T | rms (const Array< T > &a)
| The root-mean-square of "a" is the sqrt of sum(a*a)/N.
template<typename T>
T | median (const Array< T > &a, std::vector< T > &scratch, bool sorted, bool takeEvenMean, bool inPlace=false)
| The median of "a" is a(n/2).
template<typename T>
T | median (const Array< T > &a, bool sorted, bool takeEvenMean, bool inPlace=false)
| TODO shouldn't take a const Array for in place sorting.
template<typename T>
T | median (const Array< T > &a, bool sorted)
template<typename T>
T | median (const Array< T > &a)
template<typename T>
T | medianInPlace (const Array< T > &a, bool sorted=false)
| TODO shouldn't take a const Array for in place sorting.
template<typename T>
T | madfm (const Array< T > &a, std::vector< T > &tmp, bool sorted, bool takeEvenMean, bool inPlace=false)
| The median absolute deviation from the median.
template<typename T>
T | madfm (const Array< T > &a, bool sorted, bool takeEvenMean, bool inPlace=false)
| TODO shouldn't take a const Array for in place sorting.
template<typename T>
T | madfm (const Array< T > &a, bool sorted)
template<typename T>
T | madfm (const Array< T > &a)
template<typename T>
T | madfmInPlace (const Array< T > &a, bool sorted=false)
| TODO shouldn't take a const Array for in place sorting.
template<typename T>
T | fractile (const Array< T > &a, std::vector< T > &tmp, float fraction, bool sorted=false, bool inPlace=false)
| Return the fractile of an array.
template<typename T>
T | fractile (const Array< T > &a, float fraction, bool sorted=false, bool inPlace=false)
| TODO shouldn't take a const Array for in place sorting.
template<typename T>
T | interFractileRange (const Array< T > &a, std::vector< T > &tmp, float fraction, bool sorted=false, bool inPlace=false)
| Return the inter-fractile range of an array.
template<typename T>
T | interFractileRange (const Array< T > &a, float fraction, bool sorted=false, bool inPlace=false)
| TODO shouldn't take a const Array for in place sorting.
template<typename T>
T | interHexileRange (const Array< T > &a, std::vector< T > &tmp, bool sorted=false, bool inPlace=false)
| Return the inter-hexile range of an array.
template<typename T>
T | interHexileRange (const Array< T > &a, bool sorted=false, bool inPlace=false)
| TODO shouldn't take a const Array for in place sorting.
template<typename T>
T | interQuartileRange (const Array< T > &a, std::vector< T > &tmp, bool sorted=false, bool inPlace=false)
| Return the inter-quartile range of an array.
template<typename T>
T | interQuartileRange (const Array< T > &a, bool sorted=false, bool inPlace=false)
| TODO shouldn't take a const Array for in place sorting.
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 &other)
template<typename T>
Array< std::complex< T > > | operator* (const std::complex< T > &left, const Array< 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 &other)
template<typename T>
Array< std::complex< T > > | operator/ (const std::complex< T > &left, const Array< T > &other)
Array< std::complex< float > > | conj (const Array< std::complex< float > > &carray)
| Returns the complex conjugate of a complex array.
Array< std::complex< double > > | conj (const Array< std::complex< double > > &carray)
void | conj (Array< std::complex< float > > &rarray, const Array< std::complex< float > > &carray)
| Modifies rarray in place.
void | conj (Array< std::complex< double > > &rarray, const Array< std::complex< double > > &carray)
Matrix< std::complex< float > > | conj (const Matrix< std::complex< float > > &carray)
Matrix< std::complex< double > > | conj (const Matrix< std::complex< double > > &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 C, typename R>
void | setReal (Array< C > &carray, const Array< R > &rarray)
| Set the real part of the left complex array to the right real array.
template<typename C, typename R>
void | setImag (Array< C > &carray, const Array< R > &rarray)
| Set the imaginary part of the left complex array to right real array.
Array< float > | real (const Array< std::complex< float > > &carray)
| Extracts the real part of a complex array into an array of floats.
Array< double > | real (const Array< std::complex< double > > &carray)
void | real (Array< float > &rarray, const Array< std::complex< float > > &carray)
| Modifies rarray in place.
void | real (Array< double > &rarray, const Array< std::complex< double > > &carray)
Array< float > | imag (const Array< std::complex< float > > &carray)
| Extracts the imaginary part of a complex array into an array of floats.
Array< double > | imag (const Array< std::complex< double > > &carray)
void | imag (Array< float > &rarray, const Array< std::complex< float > > &carray)
| Modifies rarray in place.
void | imag (Array< double > &rarray, const Array< std::complex< double > > &carray)
Array< float > | amplitude (const Array< std::complex< float > > &carray)
| Extracts the amplitude (i.e.
Array< double > | amplitude (const Array< std::complex< double > > &carray)
void | amplitude (Array< float > &rarray, const Array< std::complex< float > > &carray)
| Modifies rarray in place.
void | amplitude (Array< double > &rarray, const Array< std::complex< double > > &carray)
Array< float > | phase (const Array< std::complex< float > > &carray)
| Extracts the phase (i.e.
Array< double > | phase (const Array< std::complex< double > > &carray)
void | phase (Array< float > &rarray, const Array< std::complex< float > > &carray)
| Modifies rarray in place.
void | phase (Array< double > &rarray, const Array< std::complex< double > > &carray)
Array< float > | ComplexToReal (const Array< std::complex< float > > &carray)
| Copy an array of complex into an array of real,imaginary pairs.
Array< double > | ComplexToReal (const Array< std::complex< double > > &carray)
void | ComplexToReal (Array< float > &rarray, const Array< std::complex< float > > &carray)
| Modify the array "rarray" in place.
void | ComplexToReal (Array< double > &rarray, const Array< std::complex< double > > &carray)
Array< std::complex< float > > | RealToComplex (const Array< float > &rarray)
| Copy an array of real,imaginary pairs into a complex array.
Array< std::complex< double > > | RealToComplex (const Array< double > &rarray)
void | RealToComplex (Array< std::complex< float > > &carray, const Array< float > &rarray)
| Modify the array "carray" in place.
void | RealToComplex (Array< std::complex< double > > &carray, const Array< double > &rarray)
template<typename T, typename 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<typename T>
Array< T > | square (const Array< T > &val)
| Returns an array where every element is squared.
template<typename T>
Array< T > | cube (const Array< T > &val)
| Returns an array where every element is cubed.
template<typename 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.
template<typename T>
void | expandArray (Array< T > &out, const Array< T > &in, const IPosition &alternate=IPosition())
| Expand the values of an array.
IPosition | checkExpandArray (IPosition &mult, IPosition &newInShape, 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;
casacore::Vector
Definition Vector.h:82

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>());
casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransformResult
Array< T > arrayTransformResult(const Array< T > &left, const Array< T > &right, BinaryOperator op)
Transform left and right to a result using the binary operator.

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>());
casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayContTransform
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.
Definition ArrayMath.h:184

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);
casacore::ArrayMath_global_functions_Array_mathematical_operations::atan2
Array< T > atan2(const Array< T > &y, const Array< T > &x)

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);
casacore::ArrayMath_global_functions_Array_mathematical_operations::sum
T sum(const Array< T > &a)
Sum of every element of the array.

This example sums a.

### Motivation

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

Definition at line 132 of file ArrayMath.h.

## Member Function Documentation

## abs()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::abs | ( | const Array< T > & | a | ) |

## acos()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::acos | ( | const Array< T > & | a | ) |

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.

## amplitude() [1/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::amplitude | ( | Array< double > & | rarray,
|  | const Array< std::complex< double > > & | carray )

## amplitude() [2/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::amplitude | ( | Array< float > & | rarray,
|  | const Array< std::complex< float > > & | carray )

Modifies rarray in place.

rarray must be conformant.

## amplitude() [3/4]

Array< double > casacore::ArrayMath_global_functions_Array_mathematical_operations::amplitude | ( | const Array< std::complex< double > > & | carray | ) |

## amplitude() [4/4]

Array< float > casacore::ArrayMath_global_functions_Array_mathematical_operations::amplitude | ( | const Array< std::complex< float > > & | 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.

## arrayContTransform() [1/4]

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 184 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().

Referenced by operator*(), operator*(), operator*(), operator/(), operator/(), and operator/().

## arrayContTransform() [2/4]

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 200 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 myrtransform().

## arrayContTransform() [3/4]

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 240 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().

## arrayContTransform() [4/4]

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 220 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 myltransform().

## arrayTransform() [1/4]

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 )

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

Result need not be a contiguous array.

## arrayTransform() [2/4]

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 )

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

Result need not be a contiguous array.

## arrayTransform() [3/4]

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 )

Transform array to a result using the unary operator.

Result need not be a contiguous array.

## arrayTransform() [4/4]

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 )

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

Result need not be a contiguous array.

## arrayTransformInPlace() [1/3]

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 299 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().

Referenced by operator*=(), operator*=(), operator*=(), operator*=(), operator/=(), operator/=(), operator/=(), and operator/=().

## arrayTransformInPlace() [2/3]

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 312 of file ArrayMath.h.

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

## arrayTransformInPlace() [3/3]

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 327 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().

## arrayTransformResult() [1/4]

template<typename T, typename UnaryOperator>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransformResult | ( | const Array< T > & | arr,
|  | UnaryOperator | op )

Transform array to a result using the unary operator.

The created and returned result array is contiguous.

## arrayTransformResult() [2/4]

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 )

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

The created and returned result array is contiguous.

Referenced by operator*(), operator*(), and operator*().

## arrayTransformResult() [3/4]

template<typename T, typename BinaryOperator>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransformResult | ( | const Array< T > & | left,
|  | T | right,
|  | BinaryOperator | op )

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

The created and returned result array is contiguous.

## arrayTransformResult() [4/4]

template<typename T, typename BinaryOperator>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::arrayTransformResult | ( | T | left,
|  | const Array< T > & | right,
|  | BinaryOperator | op )

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

The created and returned result array is contiguous.

## asin()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::asin | ( | const Array< T > & | a | ) |

## atan()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::atan | ( | const Array< T > & | a | ) |

## atan2() [1/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::atan2 | ( | const Array< T > & | y,
|  | const Array< T > & | x )

## atan2() [2/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::atan2 | ( | const Array< T > & | y,
|  | const T & | x )

## atan2() [3/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::atan2 | ( | const T & | y,
|  | const Array< T > & | x )

## avdev() [1/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::avdev | ( | const Array< T > & | a | ) |

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

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

## avdev() [2/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::avdev | ( | const Array< T > & | a,
|  | T | mean )

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.

References mean().

## ceil()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::ceil | ( | const Array< T > & | a | ) |

## checkExpandArray()

IPosition casacore::ArrayMath_global_functions_Array_mathematical_operations::checkExpandArray | ( | IPosition & | mult,
|  | IPosition & | newInShape,
|  | 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). It fills in mult and inshp (with possibly missing axes of length 1).
`inShape` defines the shape of the input array.
`outShape` defines the shape of the output array.
`alternate` tells per axis if value expansion uses alternation.
`newInShape` is the input shape with new axes (of length 1) added as needed
`mult` is the multiplication (expansion) factor per output axis Returned is the alternation per output axis; new axes have value 0 (linear expansion)

Referenced by expandArray().

## ComplexToReal() [1/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::ComplexToReal | ( | Array< double > & | rarray,
|  | const Array< std::complex< double > > & | carray )

## ComplexToReal() [2/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::ComplexToReal | ( | Array< float > & | rarray,
|  | const Array< std::complex< float > > & | carray )

Modify the array "rarray" in place.

"rarray" must be the correct shape.

## ComplexToReal() [3/4]

Array< double > casacore::ArrayMath_global_functions_Array_mathematical_operations::ComplexToReal | ( | const Array< std::complex< double > > & | carray | ) |

## ComplexToReal() [4/4]

Array< float > casacore::ArrayMath_global_functions_Array_mathematical_operations::ComplexToReal | ( | const Array< std::complex< float > > & | 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.

## conj() [1/6]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::conj | ( | Array< std::complex< double > > & | rarray,
|  | const Array< std::complex< double > > & | carray )

## conj() [2/6]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::conj | ( | Array< std::complex< float > > & | rarray,
|  | const Array< std::complex< float > > & | carray )

Modifies rarray in place.

rarray must be conformant.

## conj() [3/6]

Array< std::complex< double > > casacore::ArrayMath_global_functions_Array_mathematical_operations::conj | ( | const Array< std::complex< double > > & | carray | ) |

## conj() [4/6]

Array< std::complex< float > > casacore::ArrayMath_global_functions_Array_mathematical_operations::conj | ( | const Array< std::complex< float > > & | carray | ) |

Returns the complex conjugate of a complex array.

## conj() [5/6]

Matrix< std::complex< double > > casacore::ArrayMath_global_functions_Array_mathematical_operations::conj | ( | const Matrix< std::complex< double > > & | carray | ) |

## conj() [6/6]

Matrix< std::complex< float > > casacore::ArrayMath_global_functions_Array_mathematical_operations::conj | ( | const Matrix< std::complex< float > > & | carray | ) |

## convertArray()

template<typename T, typename U>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::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.

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

## cos()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::cos | ( | const Array< T > & | a | ) |

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

Works on an element-by-element basis.

## cosh()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::cosh | ( | const Array< T > & | a | ) |

## cube()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::cube | ( | const Array< T > & | val | ) |

Returns an array where every element is cubed.

## exp()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::exp | ( | const Array< T > & | a | ) |

## expandArray()

template<typename 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 can have different dimensionalities. Missing input axes have length 1; missing output axes are discarded. 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 output array, the missing ones default to 0.

Make sure output is contiguous.

Definition at line 1042 of file ArrayMath.h.

References checkExpandArray(), casacore::Array< T >::data(), expandRecursive(), casacore::Array< T >::getStorage(), casacore::ArrayBase::ndim(), casacore::Array< T >::putStorage(), casacore::Array< T >::reference(), casacore::Array< T >::reform(), casacore::ArrayBase::shape(), casacore::IPosition::size(), and casacore::ArrayBase::steps().

## expandRecursive()

template<typename 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.

Copy as 1,2,3 1,2,3, etc.

Copy as 1,1,1 2,2,2 etc.

Definition at line 984 of file ArrayMath.h.

References expandRecursive().

Referenced by expandArray(), and expandRecursive().

## fabs() [1/2]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::fabs | ( | const Array< T > & | a | ) |

N.B.

fabs is deprecated. Use abs.

## fabs() [2/2]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::fabs | ( | const Array< T > & | a | ) |

## floor()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::floor | ( | const Array< T > & | a | ) |

## floormod() [1/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::floormod | ( | const Array< T > & | a,
|  | const Array< T > & | b )

## floormod() [2/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::floormod | ( | const Array< T > & | a,
|  | const T & | b )

## floormod() [3/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::floormod | ( | const T & | a,
|  | const Array< T > & | b )

## fmod() [1/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::fmod | ( | const Array< T > & | a,
|  | const Array< T > & | b )

## fmod() [2/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::fmod | ( | const Array< T > & | a,
|  | const T & | b )

## fmod() [3/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::fmod | ( | const T & | a,
|  | const Array< T > & | b )

## fractile() [1/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::fractile | ( | const Array< T > & | a,
|  | float | fraction,
|  | bool | sorted = false,
|  | bool | inPlace = false )

inline

TODO shouldn't take a const Array for in place sorting.

Definition at line 728 of file ArrayMath.h.

References fractile().

## fractile() [2/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::fractile | ( | const Array< T > & | a,
|  | std::vector< T > & | tmp,
|  | float | fraction,
|  | bool | sorted = false,
|  | bool | inPlace = false )

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;
TODO shouldn't take a const Array for in place sorting

Referenced by fractile().

## imag() [1/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::imag | ( | Array< double > & | rarray,
|  | const Array< std::complex< double > > & | carray )

## imag() [2/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::imag | ( | Array< float > & | rarray,
|  | const Array< std::complex< float > > & | carray )

Modifies rarray in place.

rarray must be conformant.

## imag() [3/4]

Array< double > casacore::ArrayMath_global_functions_Array_mathematical_operations::imag | ( | const Array< std::complex< double > > & | carray | ) |

## imag() [4/4]

Array< float > casacore::ArrayMath_global_functions_Array_mathematical_operations::imag | ( | const Array< std::complex< float > > & | carray | ) |

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

Referenced by makeComplex(), makeComplex(), and makeComplex().

## indgen() [1/4]

template<typename 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 596 of file ArrayMath.h.

References indgen().

## indgen() [2/4]

template<typename 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 602 of file ArrayMath.h.

References indgen().

## indgen() [3/4]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::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.

The first axis varies most rapidly.

Referenced by indgen(), indgen(), and indgen().

## indgen() [4/4]

template<typename T>

Vector< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::indgen | ( | size_t | 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 607 of file ArrayMath.h.

References indgen(), and casacore::length().

## interFractileRange() [1/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interFractileRange | ( | const Array< T > & | a,
|  | float | fraction,
|  | bool | sorted = false,
|  | bool | inPlace = false )

inline

TODO shouldn't take a const Array for in place sorting.

Definition at line 740 of file ArrayMath.h.

References interFractileRange().

## interFractileRange() [2/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interFractileRange | ( | const Array< T > & | a,
|  | std::vector< T > & | tmp,
|  | float | fraction,
|  | bool | sorted = false,
|  | bool | inPlace = false )

Return the inter-fractile range of an array.

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

TODO shouldn't take a const Array for in place sorting

Referenced by interFractileRange(), interHexileRange(), interHexileRange(), interQuartileRange(), and interQuartileRange().

## interHexileRange() [1/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interHexileRange | ( | const Array< T > & | a,
|  | bool | sorted = false,
|  | bool | inPlace = false )

inline

TODO shouldn't take a const Array for in place sorting.

Definition at line 757 of file ArrayMath.h.

References interFractileRange().

## interHexileRange() [2/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interHexileRange | ( | const Array< T > & | a,
|  | std::vector< 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)

TODO shouldn't take a const Array for in place sorting

Definition at line 753 of file ArrayMath.h.

References interFractileRange().

## interQuartileRange() [1/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interQuartileRange | ( | const Array< T > & | a,
|  | bool | sorted = false,
|  | bool | inPlace = false )

inline

TODO shouldn't take a const Array for in place sorting.

Definition at line 771 of file ArrayMath.h.

References interFractileRange().

## interQuartileRange() [2/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::interQuartileRange | ( | const Array< T > & | a,
|  | std::vector< 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.

TODO shouldn't take a const Array for in place sorting

Definition at line 767 of file ArrayMath.h.

References interFractileRange().

## log()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::log | ( | const Array< T > & | a | ) |

## log10()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::log10 | ( | const Array< T > & | a | ) |

## madfm() [1/4]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::madfm | ( | const Array< T > & | a | ) |

inline

Definition at line 710 of file ArrayMath.h.

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

## madfm() [2/4]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::madfm | ( | const Array< T > & | a,
|  | bool | sorted )

inline

Definition at line 708 of file ArrayMath.h.

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

## madfm() [3/4]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::madfm | ( | const Array< T > & | a,
|  | bool | sorted,
|  | bool | takeEvenMean,
|  | bool | inPlace = false )

inline

TODO shouldn't take a const Array for in place sorting.

Definition at line 705 of file ArrayMath.h.

References madfm().

## madfm() [4/4]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::madfm | ( | const Array< T > & | a,
|  | std::vector< T > & | tmp,
|  | bool | sorted,
|  | bool | takeEvenMean,
|  | bool | inPlace = false )

The median absolute deviation from the median.

Interface is as for the median functions

TODO shouldn't take a const Array for in place sorting

Referenced by madfm(), madfm(), madfm(), and madfmInPlace().

## madfmInPlace()

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::madfmInPlace | ( | const Array< T > & | a,
|  | bool | sorted = false )

inline

TODO shouldn't take a const Array for in place sorting.

Definition at line 713 of file ArrayMath.h.

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

## makeComplex() [1/3]

template<typename T>

Array< std::complex< T > > casacore::ArrayMath_global_functions_Array_mathematical_operations::makeComplex | ( | const Array< T > & | real,
|  | const Array< T > & | imag )

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

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

References imag(), and real().

## makeComplex() [2/3]

template<typename T>

Array< std::complex< T > > casacore::ArrayMath_global_functions_Array_mathematical_operations::makeComplex | ( | const Array< T > & | real,
|  | const T & | imag )

References imag(), and real().

## makeComplex() [3/3]

template<typename T>

Array< std::complex< T > > casacore::ArrayMath_global_functions_Array_mathematical_operations::makeComplex | ( | const T & | real,
|  | const Array< T > & | imag )

References imag(), and real().

## max() [1/8]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::max | ( | Array< T > & | result,
|  | const Array< T > & | a,
|  | const Array< T > & | b )

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

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

## max() [2/8]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::max | ( | Array< T > & | result,
|  | const Array< T > & | a,
|  | const T & | b )

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

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

## max() [3/8]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::max | ( | Array< T > & | result,
|  | const T & | a,
|  | const Array< T > & | b )

inline

Definition at line 567 of file ArrayMath.h.

References max().

## max() [4/8]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::max | ( | const Array< T > & | a | ) |

The maximum element of the array.

Requires that the type "T" has comparison operators.

Referenced by max(), max(), and minMax().

## max() [5/8]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::max | ( | const Array< T > & | a,
|  | const Array< T > & | b )

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

"a" and "b" must be conformant.

## max() [6/8]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::max | ( | const Array< T > & | a,
|  | const T & | b )

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

## max() [7/8]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::max | ( | const T & | a,
|  | const Array< T > & | b )

inline

Definition at line 579 of file ArrayMath.h.

References max().

## max() [8/8]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::max | ( | const T & | a,
|  | const Array< T > & | b )

## mean()

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::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".

Referenced by avdev(), pstddev(), pvariance(), stddev(), and variance().

## median() [1/4]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::median | ( | const Array< T > & | a | ) |

inline

Definition at line 691 of file ArrayMath.h.

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

## median() [2/4]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::median | ( | const Array< T > & | a,
|  | bool | sorted )

inline

Definition at line 689 of file ArrayMath.h.

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

## median() [3/4]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::median | ( | const Array< T > & | a,
|  | bool | sorted,
|  | bool | takeEvenMean,
|  | bool | inPlace = false )

inline

TODO shouldn't take a const Array for in place sorting.

Definition at line 686 of file ArrayMath.h.

References median().

## median() [4/4]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::median | ( | const Array< T > & | a,
|  | std::vector< T > & | scratch,
|  | bool | sorted,
|  | bool | takeEvenMean,
|  | bool | inPlace = false )

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;

TODO shouldn't take a const Array for in place sorting

Referenced by median(), median(), median(), and medianInPlace().

## medianInPlace()

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::medianInPlace | ( | const Array< T > & | a,
|  | bool | sorted = false )

inline

TODO shouldn't take a const Array for in place sorting.

Definition at line 694 of file ArrayMath.h.

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

## min() [1/7]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::min | ( | Array< T > & | result,
|  | const Array< T > & | a,
|  | const Array< T > & | b )

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

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

## min() [2/7]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::min | ( | Array< T > & | result,
|  | const Array< T > & | a,
|  | const T & | b )

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

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

## min() [3/7]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::min | ( | Array< T > & | result,
|  | const T & | a,
|  | const Array< T > & | b )

inline

Definition at line 574 of file ArrayMath.h.

References min().

## min() [4/7]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::min | ( | const Array< T > & | a | ) |

The minimum element of the array.

Requires that the type "T" has comparison operators.

Referenced by min(), min(), and minMax().

## min() [5/7]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::min | ( | const Array< T > & | a,
|  | const Array< T > & | b )

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

"a" and "b" must be conformant.

## min() [6/7]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::min | ( | const Array< T > & | a,
|  | const T & | b )

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

## min() [7/7]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::min | ( | const T & | a,
|  | const Array< T > & | b )

inline

Definition at line 583 of file ArrayMath.h.

References min().

## minMax() [1/3]

template<typename ScalarType>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::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.

References casacore::array.

## minMax() [2/3]

template<typename 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 )

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.

References casacore::array, and casacore::mask().

## minMax() [3/3]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::minMax | ( | T & | min,
|  | T & | max,
|  | const Array< T > & | a )

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.

References max(), and min().

## minMaxMasked()

template<typename 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 )

The array * weight is searched.

References casacore::array.

## myiptransform()

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 166 of file ArrayMath.h.

Referenced by arrayTransformInPlace().

## myltransform()

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 std::complex<float> array and std::complex<float> scalar would fail (see g++ bug 39678).

sequence = scalar OP sequence

Definition at line 144 of file ArrayMath.h.

Referenced by arrayContTransform().

## myrtransform()

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 155 of file ArrayMath.h.

Referenced by arrayContTransform().

## operator%() [1/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator% | ( | const Array< T > & | left,
|  | const Array< T > & | right )

## operator%() [2/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator% | ( | const Array< T > & | left,
|  | const T & | right )

## operator%() [3/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator% | ( | const T & | left,
|  | const Array< T > & | right )

## operator%=() [1/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator%= | ( | Array< T > & | left,
|  | const Array< T > & | other )

## operator%=() [2/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator%= | ( | Array< T > & | left,
|  | const T & | other )

## operator&() [1/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator& | ( | const Array< T > & | left,
|  | const Array< T > & | right )

## operator&() [2/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator& | ( | const Array< T > & | left,
|  | const T & | right )

## operator&() [3/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator& | ( | const T & | left,
|  | const Array< T > & | right )

## operator&=() [1/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator&= | ( | Array< T > & | left,
|  | const Array< T > & | other )

## operator&=() [2/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator&= | ( | Array< T > & | left,
|  | const T & | other )

## operator*() [1/6]

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

Definition at line 811 of file ArrayMath.h.

References arrayContTransform(), and casacore::checkArrayShapes().

## operator*() [2/6]

template<typename T>

Array< std::complex< T > > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator* | ( | const Array< std::complex< T > > & | left,
|  | const T & | other )

inline

Definition at line 821 of file ArrayMath.h.

References arrayContTransform().

## operator*() [3/6]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator* | ( | const Array< T > & | left,
|  | const Array< T > & | right )

inline

Definition at line 396 of file ArrayMath.h.

References arrayTransformResult(), and casacore::checkArrayShapes().

## operator*() [4/6]

template<class T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator* | ( | const Array< T > & | left,
|  | const T & | right )

inline

Definition at line 422 of file ArrayMath.h.

References arrayTransformResult().

## operator*() [5/6]

template<typename T>

Array< std::complex< T > > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator* | ( | const std::complex< T > & | left,
|  | const Array< T > & | other )

inline

Definition at line 830 of file ArrayMath.h.

References arrayContTransform(), and casacore::ArrayBase::shape().

## operator*() [6/6]

template<class T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator* | ( | const T & | left,
|  | const Array< T > & | right )

inline

Definition at line 447 of file ArrayMath.h.

References arrayTransformResult().

## operator*=() [1/4]

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 std::complex<float> and std::complex<double> are typedefs for std::complex.

Definition at line 781 of file ArrayMath.h.

References arrayTransformInPlace(), and casacore::checkArrayShapes().

## operator*=() [2/4]

template<typename T>

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

inline

Definition at line 789 of file ArrayMath.h.

References arrayTransformInPlace().

## operator*=() [3/4]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*= | ( | Array< T > & | left,
|  | const Array< T > & | other )

inline

Definition at line 343 of file ArrayMath.h.

References arrayTransformInPlace(), and casacore::checkArrayShapes().

## operator*=() [4/4]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator*= | ( | Array< T > & | left,
|  | const T & | other )

inline

Definition at line 366 of file ArrayMath.h.

References arrayTransformInPlace().

## operator+() [1/4]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+ | ( | const Array< T > & | a | ) |

Unary arithmetic operation.

## operator+() [2/4]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+ | ( | const Array< T > & | left,
|  | const Array< T > & | right )

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

## operator+() [3/4]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+ | ( | const Array< T > & | left,
|  | const T & | right )

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

## operator+() [4/4]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+ | ( | const T & | left,
|  | const Array< T > & | right )

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

## operator+=() [1/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+= | ( | Array< T > & | left,
|  | const Array< T > & | other )

Element by element arithmetic modifying left in-place.

left and other must be conformant.

## operator+=() [2/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator+= | ( | Array< T > & | left,
|  | const T & | other )

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.

## operator-() [1/4]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator- | ( | const Array< T > & | a | ) |

## operator-() [2/4]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator- | ( | const Array< T > & | left,
|  | const Array< T > & | right )

## operator-() [3/4]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator- | ( | const Array< T > & | left,
|  | const T & | right )

## operator-() [4/4]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator- | ( | const T & | left,
|  | const Array< T > & | right )

## operator-=() [1/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator-= | ( | Array< T > & | left,
|  | const Array< T > & | other )

## operator-=() [2/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator-= | ( | Array< T > & | left,
|  | const T & | other )

## operator/() [1/6]

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

Definition at line 840 of file ArrayMath.h.

References arrayContTransform(), and casacore::checkArrayShapes().

## operator/() [2/6]

template<typename T>

Array< std::complex< T > > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/ | ( | const Array< std::complex< T > > & | left,
|  | const T & | other )

inline

Definition at line 850 of file ArrayMath.h.

References arrayContTransform().

## operator/() [3/6]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/ | ( | const Array< T > & | left,
|  | const Array< T > & | right )

## operator/() [4/6]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/ | ( | const Array< T > & | left,
|  | const T & | right )

## operator/() [5/6]

template<typename T>

Array< std::complex< T > > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/ | ( | const std::complex< T > & | left,
|  | const Array< T > & | other )

inline

Definition at line 859 of file ArrayMath.h.

References arrayContTransform(), and casacore::ArrayBase::shape().

## operator/() [6/6]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/ | ( | const T & | left,
|  | const Array< T > & | right )

## operator/=() [1/4]

template<typename T>

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

inline

Definition at line 796 of file ArrayMath.h.

References arrayTransformInPlace(), and casacore::checkArrayShapes().

## operator/=() [2/4]

template<typename T>

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

inline

Definition at line 804 of file ArrayMath.h.

References arrayTransformInPlace().

## operator/=() [3/4]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/= | ( | Array< T > & | left,
|  | const Array< T > & | other )

inline

Definition at line 349 of file ArrayMath.h.

References arrayTransformInPlace(), and casacore::checkArrayShapes().

## operator/=() [4/4]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator/= | ( | Array< T > & | left,
|  | const T & | other )

inline

Definition at line 370 of file ArrayMath.h.

References arrayTransformInPlace().

## operator^() [1/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator^ | ( | const Array< T > & | left,
|  | const Array< T > & | right )

## operator^() [2/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator^ | ( | const Array< T > & | left,
|  | const T & | right )

## operator^() [3/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator^ | ( | const T & | left,
|  | const Array< T > & | right )

## operator^=() [1/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator^= | ( | Array< T > & | left,
|  | const Array< T > & | other )

## operator^=() [2/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator^= | ( | Array< T > & | left,
|  | const T & | other )

## operator|() [1/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator| | ( | const Array< T > & | left,
|  | const Array< T > & | right )

## operator|() [2/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator| | ( | const Array< T > & | left,
|  | const T & | right )

## operator|() [3/3]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator| | ( | const T & | left,
|  | const Array< T > & | right )

## operator|=() [1/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator|= | ( | Array< T > & | left,
|  | const Array< T > & | other )

## operator|=() [2/2]

template<typename T>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::operator|= | ( | Array< T > & | left,
|  | const T & | other )

## operator~()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::operator~ | ( | const Array< T > & | a | ) |

## phase() [1/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::phase | ( | Array< double > & | rarray,
|  | const Array< std::complex< double > > & | carray )

## phase() [2/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::phase | ( | Array< float > & | rarray,
|  | const Array< std::complex< float > > & | carray )

Modifies rarray in place.

rarray must be conformant.

## phase() [3/4]

Array< double > casacore::ArrayMath_global_functions_Array_mathematical_operations::phase | ( | const Array< std::complex< double > > & | carray | ) |

## phase() [4/4]

Array< float > casacore::ArrayMath_global_functions_Array_mathematical_operations::phase | ( | const Array< std::complex< float > > & | 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.

## pow() [1/4]

template<typename T>

Array< std::complex< T > > casacore::ArrayMath_global_functions_Array_mathematical_operations::pow | ( | const Array< std::complex< T > > & | a,
|  | const T & | b )

## pow() [2/4]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::pow | ( | const Array< T > & | a,
|  | const Array< T > & | b )

## pow() [3/4]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::pow | ( | const Array< T > & | a,
|  | const T & | b )

## pow() [4/4]

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::pow | ( | const T & | a,
|  | const Array< T > & | b )

## product()

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::product | ( | const Array< T > & | a | ) |

Product of every element of the array.

This could of course easily overflow.

## pstddev() [1/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::pstddev | ( | const Array< T > & | a,
|  | size_t | ddof = 0 )

## pstddev() [2/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::pstddev | ( | const Array< T > & | a,
|  | T | mean,
|  | size_t | ddof = 0 )

References mean().

## pvariance() [1/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::pvariance | ( | const Array< T > & | a,
|  | size_t | ddof = 0 )

## pvariance() [2/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::pvariance | ( | const Array< T > & | a,
|  | T | mean,
|  | size_t | ddof = 0 )

References mean().

## real() [1/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::real | ( | Array< double > & | rarray,
|  | const Array< std::complex< double > > & | carray )

## real() [2/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::real | ( | Array< float > & | rarray,
|  | const Array< std::complex< float > > & | carray )

Modifies rarray in place.

rarray must be conformant.

## real() [3/4]

Array< double > casacore::ArrayMath_global_functions_Array_mathematical_operations::real | ( | const Array< std::complex< double > > & | carray | ) |

## real() [4/4]

Array< float > casacore::ArrayMath_global_functions_Array_mathematical_operations::real | ( | const Array< std::complex< float > > & | carray | ) |

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

Referenced by makeComplex(), makeComplex(), and makeComplex().

## RealToComplex() [1/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::RealToComplex | ( | Array< std::complex< double > > & | carray,
|  | const Array< double > & | rarray )

## RealToComplex() [2/4]

void casacore::ArrayMath_global_functions_Array_mathematical_operations::RealToComplex | ( | Array< std::complex< float > > & | carray,
|  | const Array< float > & | rarray )

Modify the array "carray" in place.

"carray" must be the correct shape.

## RealToComplex() [3/4]

Array< std::complex< double > > casacore::ArrayMath_global_functions_Array_mathematical_operations::RealToComplex | ( | const Array< double > & | rarray | ) |

## RealToComplex() [4/4]

Array< std::complex< float > > 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.

## rms()

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::rms | ( | const Array< T > & | a | ) |

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

## round()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::round | ( | const Array< T > & | a | ) |

## setImag()

template<typename C, typename R>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::setImag | ( | Array< C > & | carray,
|  | const Array< R > & | rarray )

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

## setReal()

template<typename C, typename R>

void casacore::ArrayMath_global_functions_Array_mathematical_operations::setReal | ( | Array< C > & | carray,
|  | const Array< R > & | rarray )

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

## sign()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::sign | ( | const Array< T > & | a | ) |

## sin()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::sin | ( | const Array< T > & | a | ) |

## sinh()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::sinh | ( | const Array< T > & | a | ) |

## sqrt()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::sqrt | ( | const Array< T > & | a | ) |

## square()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::square | ( | const Array< T > & | val | ) |

Returns an array where every element is squared.

## stddev() [1/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::stddev | ( | const Array< T > & | a | ) |

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

## stddev() [2/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::stddev | ( | const Array< T > & | a,
|  | T | mean )

References mean().

## sum()

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::sum | ( | const Array< T > & | a | ) |

Sum of every element of the array.

## sumsqr()

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::sumsqr | ( | const Array< T > & | a | ) |

Sum the square of every element of the array.

## tan()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::tan | ( | const Array< T > & | a | ) |

## tanh()

template<typename T>

Array< T > casacore::ArrayMath_global_functions_Array_mathematical_operations::tanh | ( | const Array< T > & | a | ) |

## variance() [1/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::variance | ( | const Array< T > & | a | ) |

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

Similar to numpy the argument ddof (delta degrees of freedom) tells if the population variance (ddof=0) or the sample variance (ddof=1) is taken. The variance functions proper use ddof=1.
Note that for a complex valued T the absolute values are used; in that way the variance is equal to the sum of the variances of the real and imaginary parts. Hence the imaginary part in the return value is 0.

## variance() [2/2]

template<typename T>

T casacore::ArrayMath_global_functions_Array_mathematical_operations::variance | ( | const Array< T > & | a,
|  | T | mean )

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

References mean().

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

- casa/Arrays/ArrayMath.h