Logical operations for MaskedArrays, and between MaskedArrays and Arrays. More...

#include <MaskArrLogi.h>

Public Member Functions
template<class T >
bool	allLE (const MaskedArray< T > &l, const Array< T > &r)
	Element by element comparisons between the "l" and "r" arrays. More...

template<class T >
bool	allLT (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	allGE (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	allGT (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	allEQ (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	allNE (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	allAND (const MaskedArray< T > &l, const Array< T > &r)
	This only makes sense if the array element type is logical valued. More...

template<class T >
bool	allOR (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	allLE (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allLT (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allGE (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allGT (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allEQ (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allNE (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allAND (const Array< T > &l, const MaskedArray< T > &r)
	This only makes sense if the array element type is logical valued. More...

template<class T >
bool	allOR (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allLE (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allLT (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allGE (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allGT (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allEQ (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allNE (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	allAND (const MaskedArray< T > &l, const MaskedArray< T > &r)
	This only makes sense if the array element type is logical valued. More...

template<class T >
bool	allOR (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator<= (const MaskedArray< T > &l, const Array< T > &r)
	Element by element comparisons between the "l" and "r" arrays. More...

template<class T >
MaskedLogicalArray	operator< (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
MaskedLogicalArray	operator>= (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
MaskedLogicalArray	operator> (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
MaskedLogicalArray	operator== (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
MaskedLogicalArray	operator!= (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
MaskedLogicalArray	operator&& (const MaskedArray< T > &l, const Array< T > &r)
	This only makes sense if the array element type is logical valued. More...

template<class T >
MaskedLogicalArray	operator\|\| (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
MaskedLogicalArray	operator<= (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator< (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator>= (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator> (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator== (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator!= (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator&& (const Array< T > &l, const MaskedArray< T > &r)
	This only makes sense if the array element type is logical valued. More...

template<class T >
MaskedLogicalArray	operator\|\| (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator<= (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator< (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator>= (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator> (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator== (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator!= (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator&& (const MaskedArray< T > &l, const MaskedArray< T > &r)
	This only makes sense if the array element type is logical valued. More...

template<class T >
MaskedLogicalArray	operator\|\| (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
MaskedLogicalArray	operator! (const MaskedArray< T > &marray)
	Logical negation of a MaskedArray. More...

template<class T >
bool	allLE (const MaskedArray< T > &array, const T &val)
	Element by element comparisons between an array and a scalar, which behaves as if it were a conformant array filled with the value "val." The result is true only if the comparison is true for every element for which the mask of the MaskedArray is true. More...

template<class T >
bool	allLE (const T &val, const MaskedArray< T > &array)

template<class T >
bool	allLT (const MaskedArray< T > &array, const T &val)

template<class T >
bool	allLT (const T &val, const MaskedArray< T > &array)

template<class T >
bool	allGE (const MaskedArray< T > &array, const T &val)

template<class T >
bool	allGE (const T &val, const MaskedArray< T > &array)

template<class T >
bool	allGT (const MaskedArray< T > &array, const T &val)

template<class T >
bool	allGT (const T &val, const MaskedArray< T > &array)

template<class T >
bool	allEQ (const MaskedArray< T > &array, const T &val)

template<class T >
bool	allEQ (const T &val, const MaskedArray< T > &array)

template<class T >
bool	allNE (const MaskedArray< T > &array, const T &val)

template<class T >
bool	allNE (const T &val, const MaskedArray< T > &array)

template<class T >
bool	allAND (const MaskedArray< T > &array, const T &val)
	This only makes sense if the array element type is logical valued. More...

template<class T >
bool	allAND (const T &val, const MaskedArray< T > &array)

template<class T >
bool	allOR (const MaskedArray< T > &array, const T &val)

template<class T >
bool	allOR (const T &val, const MaskedArray< T > &array)

template<class T >
MaskedLogicalArray	operator<= (const MaskedArray< T > &array, const T &val)
	Element by element comparisons between an array and a scalar, which behaves as if it were a conformant array filled with the value "val." The result is an MaskedLogicalArray. More...

template<class T >
MaskedLogicalArray	operator<= (const T &val, const MaskedArray< T > &array)

template<class T >
MaskedLogicalArray	operator< (const MaskedArray< T > &array, const T &val)

template<class T >
MaskedLogicalArray	operator< (const T &val, const MaskedArray< T > &array)

template<class T >
MaskedLogicalArray	operator>= (const MaskedArray< T > &array, const T &val)

template<class T >
MaskedLogicalArray	operator>= (const T &val, const MaskedArray< T > &array)

template<class T >
MaskedLogicalArray	operator> (const MaskedArray< T > &array, const T &val)

template<class T >
MaskedLogicalArray	operator> (const T &val, const MaskedArray< T > &array)

template<class T >
MaskedLogicalArray	operator== (const MaskedArray< T > &array, const T &val)

template<class T >
MaskedLogicalArray	operator== (const T &val, const MaskedArray< T > &array)

template<class T >
MaskedLogicalArray	operator!= (const MaskedArray< T > &array, const T &val)

template<class T >
MaskedLogicalArray	operator!= (const T &val, const MaskedArray< T > &array)

template<class T >
MaskedLogicalArray	operator&& (const MaskedArray< T > &array, const T &val)
	This only makes sense if the array element type is logical valued. More...

template<class T >
MaskedLogicalArray	operator&& (const T &val, const MaskedArray< T > &array)

template<class T >
MaskedLogicalArray	operator\|\| (const MaskedArray< T > &array, const T &val)

template<class T >
MaskedLogicalArray	operator\|\| (const T &val, const MaskedArray< T > &array)

template<class T >
bool	anyLE (const MaskedArray< T > &l, const Array< T > &r)
	Element by element comparisons between the "l" and "r" arrays. More...

template<class T >
bool	anyLT (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	anyGE (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	anyGT (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	anyEQ (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	anyNE (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	anyAND (const MaskedArray< T > &l, const Array< T > &r)
	This only makes sense if the array element type is logical valued. More...

template<class T >
bool	anyOR (const MaskedArray< T > &l, const Array< T > &r)

template<class T >
bool	anyLE (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyLT (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyGE (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyGT (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyEQ (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyNE (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyAND (const Array< T > &l, const MaskedArray< T > &r)
	This only makes sense if the array element type is logical valued. More...

template<class T >
bool	anyOR (const Array< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyLE (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyLT (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyGE (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyGT (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyEQ (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyNE (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyAND (const MaskedArray< T > &l, const MaskedArray< T > &r)
	This only makes sense if the array element type is logical valued. More...

template<class T >
bool	anyOR (const MaskedArray< T > &l, const MaskedArray< T > &r)

template<class T >
bool	anyLE (const MaskedArray< T > &array, const T &val)
	Element by element comparisons between an array and a scalar, which behaves as if it were a conformant array filled with the value "val." The result is true only if the comparison is true for some element for which the mask of the MaskedArray is true. More...

template<class T >
bool	anyLE (const T &val, const MaskedArray< T > &array)

template<class T >
bool	anyLT (const MaskedArray< T > &array, const T &val)

template<class T >
bool	anyLT (const T &val, const MaskedArray< T > &array)

template<class T >
bool	anyGE (const MaskedArray< T > &array, const T &val)

template<class T >
bool	anyGE (const T &val, const MaskedArray< T > &array)

template<class T >
bool	anyGT (const MaskedArray< T > &array, const T &val)

template<class T >
bool	anyGT (const T &val, const MaskedArray< T > &array)

template<class T >
bool	anyEQ (const MaskedArray< T > &array, const T &val)

template<class T >
bool	anyEQ (const T &val, const MaskedArray< T > &array)

template<class T >
bool	anyNE (const MaskedArray< T > &array, const T &val)

template<class T >
bool	anyNE (const T &val, const MaskedArray< T > &array)

template<class T >
bool	anyAND (const MaskedArray< T > &array, const T &val)
	This only makes sense if the array element type is logical valued. More...

template<class T >
bool	anyAND (const T &val, const MaskedArray< T > &array)

template<class T >
bool	anyOR (const MaskedArray< T > &array, const T &val)

template<class T >
bool	anyOR (const T &val, const MaskedArray< T > &array)

Detailed Description

Logical operations for MaskedArrays, and between MaskedArrays and Arrays.

Review Status

Reviewed By:: UNKNOWN
Date Reviewed:: before2004/08/25
Test programs:: tMaskArrLogi tMaskArrExcp

Prerequisite

Etymology

MaskArrLogi is short for MaskedArrayLogical, which is too long by the old AIPS++ file naming conventions. This file contains global functions which perform element by element logical operations on masked arrays.

Synopsis

These functions perform element by element logical operations on masked arrays. With two arrays, they must both conform, and the result is done element by element, for those locations where the mask of the MaskedArray is true. For two MaskedArrays, the "and" of the masks is used.

There are two classes of functions. One class returns a MaskedLogicalArray. In these functions, the value of an element of the MaskedLogicalArray is the value of the logical operation applied to the corresponding elements of the input MaskedArrays. The other class of functions returns a single bool. The return value is true if the logical operation returns true for all elements of the input masked arrays for the "all" functions (e.g. allLE()), and returns true if the logical operation returns true for any elements of the input masked arrays for the "any" functions (e.g. anyLE()). The functions which return a single bool throw an exception if the AND of the masks of the input masked arrays has no true elements.

For instance allLE (a, b) imples that every element of a is less than or equal to every element of b. Note that with this definition allLE (a, b) and allGE (a, b) can both be false (e.g. a = [1,0] b = [0,1]).

NB comparison between two zero-sized arrays is not defined (should it throw an exception?).

Example

 Vector<int> a(10);
 Vector<int> b(10);
 LogicalVector l(10);
...
 l = a(a>0) < b(b>0);

This example sets those elements of l where ((a>0) && (b>0)) to (a<b). Elements of l where !((a>0) && (b>0)) are unchanged. The result of the comparison is a MaskedLogicalArray. The assignment from this MaskedLogicalArray to the LogicalArray l only assigns those elements where the mask is true.

Example

 Vector<int> a(10);
 Vector<int> b(10);
 bool result;
...
 result = allLT (a(a>0), b(b>0));

This example sets result to true if, for all elements where ((a>0) && (b>0)), a<b.

Motivation

One wants to be able to mask arrays and perform logical operations on those masked arrays. Since the masked arrays are only defined where the masks are true, the result must be a MaskedLogicalArray, or a single bool.

To Do

Reconsider where the origin of the returned LogicalArray should be located.

Definition at line 124 of file MaskArrLogi.h.

Member Function Documentation

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allAND	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

This only makes sense if the array element type is logical valued.

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allAND	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

This only makes sense if the array element type is logical valued.

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allAND	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

This only makes sense if the array element type is logical valued.

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allAND	(	const MaskedArray< T > &	array,
		const T &	val
	)

This only makes sense if the array element type is logical valued.

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allAND	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allEQ	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allEQ	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allEQ	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allEQ	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allEQ	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allGE	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allGE	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allGE	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allGE	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allGE	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allGT	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allGT	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allGT	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allGT	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allGT	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allLE	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

Element by element comparisons between the "l" and "r" arrays.

The result is true only if the comparison is true for every element of the arrays for which the mask of the MaskedArray is true. For two MaskedArrays, the "and" of the masks is used.

Thrown Exceptions

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allLE	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allLE	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allLE	(	const MaskedArray< T > &	array,
		const T &	val
	)

Element by element comparisons between an array and a scalar, which behaves as if it were a conformant array filled with the value "val." The result is true only if the comparison is true for every element for which the mask of the MaskedArray is true.

Thrown Exceptions

ArrayError

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allLE	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allLT	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allLT	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allLT	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allLT	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allLT	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allNE	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allNE	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allNE	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allNE	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allNE	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allOR	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allOR	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allOR	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allOR	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::allOR	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyAND	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

This only makes sense if the array element type is logical valued.

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyAND	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

This only makes sense if the array element type is logical valued.

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyAND	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

This only makes sense if the array element type is logical valued.

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyAND	(	const MaskedArray< T > &	array,
		const T &	val
	)

This only makes sense if the array element type is logical valued.

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyAND	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyEQ	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyEQ	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyEQ	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyEQ	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyEQ	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyGE	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyGE	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyGE	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyGE	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyGE	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyGT	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyGT	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyGT	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyGT	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyGT	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyLE	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

Element by element comparisons between the "l" and "r" arrays.

The result is true only if the comparison is true for some element of the arrays for which the mask of the MaskedArray is true. For two MaskedArrays, the "and" of the masks is used.

Thrown Exceptions

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyLE	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyLE	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyLE	(	const MaskedArray< T > &	array,
		const T &	val
	)

Element by element comparisons between an array and a scalar, which

behaves as if it were a conformant array filled with the value "val." The result is true only if the comparison is true for some element for which the mask of the MaskedArray is true.

Thrown Exceptions

ArrayError

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyLE	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyLT	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyLT	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyLT	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyLT	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyLT	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyNE	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyNE	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyNE	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyNE	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyNE	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyOR	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyOR	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyOR	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyOR	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

bool casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::anyOR	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator! ( const MaskedArray< T > & marray )

Logical negation of a MaskedArray.

This only makes sense if the array element type is logical valued.

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator!=	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator!=	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator!=	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator!=	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator!=	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator&&	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

This only makes sense if the array element type is logical valued.

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator&&	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

This only makes sense if the array element type is logical valued.

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator&&	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

This only makes sense if the array element type is logical valued.

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator&&	(	const MaskedArray< T > &	array,
		const T &	val
	)

This only makes sense if the array element type is logical valued.

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator&&	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator<	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator<	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator<	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator<	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator<	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator<=	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

Element by element comparisons between the "l" and "r" arrays.

The result is a MaskedLogicalArray.

The arrays must conform or an exception is thrown.

Thrown Exceptions

ArrayConformanceError

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator<=	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator<=	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator<=	(	const MaskedArray< T > &	array,
		const T &	val
	)

Element by element comparisons between an array and a scalar, which behaves as if it were a conformant array filled with the value "val." The result is an MaskedLogicalArray.

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator<=	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator==	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator==	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator==	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator==	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator==	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator>	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator>	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator>	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator>	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator>	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator>=	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator>=	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator>=	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator>=	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator>=	(	const T &	val,
		const MaskedArray< T > &	array
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator\|\|	(	const MaskedArray< T > &	l,
		const Array< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator\|\|	(	const Array< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator\|\|	(	const MaskedArray< T > &	l,
		const MaskedArray< T > &	r
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator\|\|	(	const MaskedArray< T > &	array,
		const T &	val
	)

template<class T >

MaskedLogicalArray casacore::MaskArrLogi_global_functions_MaskedArray_logical_operations::operator\|\|	(	const T &	val,
		const MaskedArray< T > &	array
	)

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

casa/Arrays/MaskArrLogi.h

Public Member Functions

Detailed Description

Review Status

Prerequisite

Etymology

Synopsis

Example

Example

Motivation

To Do

Member Function Documentation

Thrown Exceptions

Thrown Exceptions

Thrown Exceptions

Thrown Exceptions

Thrown Exceptions