valarray File Reference

#include <cmath>
#include <xmemory>

Classes
class	gslice_array< _Ty >
class	indirect_array< _Ty >
class	mask_array< _Ty >
class	slice_array< _Ty >
class	valarray< _Ty >
class	valarray< _Ty >
class	slice
class	slice_array< _Ty >
class	gslice
class	gslice_array< _Ty >
class	mask_array< _Ty >
class	indirect_array< _Ty >

Macros
#define	_VALARRAY_
#define	_VALOP(TYPE, LENGTH, RHS)
#define	_VALGOP(RHS)
#define	_SLOP(RHS)
#define	_GSLOP(RHS)
#define	_MOP(RHS)
#define	_IOP(RHS)

Typedefs
typedef valarray< bool >	_Boolarray
typedef valarray< size_t >	_Sizarray

Functions
template<class _Ty >
void	swap (valarray< _Ty > &_Left, valarray< _Ty > &_Right) _NOEXCEPT
template<class _Ty >
_Ty *	begin (valarray< _Ty > &_Array)
template<class _Ty >
const _Ty *	begin (const valarray< _Ty > &_Array)
template<class _Ty >
_Ty *	end (valarray< _Ty > &_Array)
template<class _Ty >
const _Ty *	end (const valarray< _Ty > &_Array)
template<class _Ty >
valarray< _Ty >	operator* (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	operator* (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator/ (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	operator/ (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator% (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	operator% (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator+ (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	operator+ (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator- (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	operator- (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator^ (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	operator^ (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator& (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	operator& (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator| (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	operator| (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator<< (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	operator<< (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator>> (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	operator>> (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator&& (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
_Boolarray	operator&& (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator|| (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
_Boolarray	operator|| (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator* (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator/ (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator% (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator+ (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator- (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator^ (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator& (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator| (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator<< (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	operator>> (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator&& (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator|| (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator== (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
_Boolarray	operator== (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator== (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator!= (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
_Boolarray	operator!= (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator!= (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator< (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
_Boolarray	operator< (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator< (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator> (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
_Boolarray	operator> (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator> (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator<= (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
_Boolarray	operator<= (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator<= (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator>= (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
_Boolarray	operator>= (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
_Boolarray	operator>= (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	abs (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	acos (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	asin (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	atan (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	atan2 (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	atan2 (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	atan2 (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	cos (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	cosh (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	exp (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	log (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	log10 (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	pow (const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	pow (const valarray< _Ty > &_Left, const _Ty &_Right)
template<class _Ty >
valarray< _Ty >	pow (const _Ty &_Left, const valarray< _Ty > &_Right)
template<class _Ty >
valarray< _Ty >	sin (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	sinh (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	sqrt (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	tan (const valarray< _Ty > &_Left)
template<class _Ty >
valarray< _Ty >	tanh (const valarray< _Ty > &_Left)

Macro Definition Documentation

#define _GSLOP

(

RHS

)

Value:

/* apply RHS(_Idx) to gslice_array */ \
	_Sizarray _Indexarray((size_t)0, _Nslice()); \
	size_t _Size = _Totlen(); \
	for (size_t _Idx = 0; _Idx < _Size; ++_Idx) \
        _Myptr[_Off(_Indexarray)] RHS;

#define _IOP

(

RHS

)

Value:

/* apply RHS(_Idx) to indirect_array */ \
	size_t _Size = _Totlen(); \
	for (size_t _Idx = 0; _Idx < _Size; ++_Idx) \
        _Myptr[_Indir(_Idx)] RHS;

#define _MOP

(

RHS

)

Value:

/* apply RHS(_Idx) to mask_array */ \
	size_t _Off = 0; \
	size_t _Size = _Totlen(); \
	for (size_t _Idx = 0; _Idx < _Size; ++_Off) \
        if (_Mask(_Off)) \
            _Myptr[_Off] RHS, ++_Idx;

#define _SLOP

(

RHS

)

Value:

/* apply RHS(_Idx) to slice_array */ \
	size_t _Off = _Start; \
	for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) \
        _Myptr[_Off] RHS;

#define _VALARRAY_

#define _VALGOP

(

RHS

)

Value:

/* apply RHS(_Idx) to valarray */ \
	for (size_t _Idx = 0; _Idx < size(); ++_Idx) \
        _Myptr[_Idx] RHS; \
	return (*this)

#define _VALOP	(		TYPE,
			LENGTH,
			RHS
	)

Value:

/* assign RHS(_Idx) to new valarray */ \
    valarray<TYPE> _Ans(LENGTH); \
	for (size_t _Idx = 0; _Idx < _Ans.size(); ++_Idx) \
        _Ans[_Idx] = RHS; \
	return (_Ans)

Typedef Documentation

typedef valarray<bool> _Boolarray

typedef valarray<size_t> _Sizarray

Function Documentation

template<class _Ty >

valarray<_Ty> abs ( const valarray< _Ty > &  _Left )

inline

    {   // apply abs to each element of valarray
    _VALOP(_Ty, _Left.size(), abs(_Left[_Idx]));
    }

template<class _Ty >

valarray<_Ty> acos ( const valarray< _Ty > &  _Left )

inline

    {   // apply acos to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD acos(_Left[_Idx]));
    }

template<class _Ty >

valarray<_Ty> asin ( const valarray< _Ty > &  _Left )

inline

    {   // apply asin to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD asin(_Left[_Idx]));
    }

template<class _Ty >

valarray<_Ty> atan ( const valarray< _Ty > &  _Left )

inline

    {   // apply atan to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD atan(_Left[_Idx]));
    }

template<class _Ty >

valarray<_Ty> atan2 ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // apply atan2 to pairs of valarray elements
    _VALOP(_Ty, _Left.size(), _CSTD atan2(_Left[_Idx], _Right[_Idx]));
    }

template<class _Ty >

valarray<_Ty> atan2 ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // apply atan2 to each valarray element and scalar
    _VALOP(_Ty, _Left.size(), _CSTD atan2(_Left[_Idx], _Right));
    }

template<class _Ty >

valarray<_Ty> atan2 ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // apply atan2 to scalar and each valarray element
    _VALOP(_Ty, _Right.size(), _CSTD atan2(_Left, _Right[_Idx]));
    }

template<class _Ty >

_Ty* begin ( valarray< _Ty > &  _Array )

inline

    {   // get beginning of valarray
    return (&_Array[0]);
    }

template<class _Ty >

const _Ty* begin ( const valarray< _Ty > &  _Array )

inline

    {   // get beginning of valarray
    return (&_Array[0]);
    }

template<class _Ty >

valarray<_Ty> cos ( const valarray< _Ty > &  _Left )

inline

    {   // apply cos to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD cos(_Left[_Idx]));
    }

template<class _Ty >

valarray<_Ty> cosh ( const valarray< _Ty > &  _Left )

inline

    {   // apply cosh to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD cosh(_Left[_Idx]));
    }

template<class _Ty >

_Ty* end ( valarray< _Ty > &  _Array )

inline

    {   // get end of valarray
    return (&_Array[0] + _Array.size());
    }

template<class _Ty >

const _Ty* end ( const valarray< _Ty > &  _Array )

inline

    {   // get end of valarray
    return (&_Array[0] + _Array.size());
    }

template<class _Ty >

valarray<_Ty> exp ( const valarray< _Ty > &  _Left )

inline

    {   // apply exp to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD exp(_Left[_Idx]));
    }

template<class _Ty >

valarray<_Ty> log ( const valarray< _Ty > &  _Left )

inline

    {   // apply log to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD log(_Left[_Idx]));
    }

template<class _Ty >

valarray<_Ty> log10 ( const valarray< _Ty > &  _Left )

inline

    {   // apply log10 to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD log10(_Left[_Idx]));
    }

template<class _Ty >

_Boolarray operator!= ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray != scalar
    _VALOP(bool, _Left.size(), _Left[_Idx] != _Right);
    }

template<class _Ty >

_Boolarray operator!= ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar != valarray
    _VALOP(bool, _Right.size(), _Left != _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator!= ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray != valarray
    _VALOP(bool, _Left.size(), _Left[_Idx] != _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator% ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray % scalar
    _VALOP(_Ty, _Left.size(), _Left[_Idx] % _Right);
    }

template<class _Ty >

valarray<_Ty> operator% ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar % valarray
    _VALOP(_Ty, _Right.size(), _Left % _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator% ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray % valarray
    _VALOP(_Ty, _Left.size(), _Left[_Idx] % _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator& ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray & scalar
    _VALOP(_Ty, _Left.size(), _Left[_Idx] & _Right);
    }

template<class _Ty >

valarray<_Ty> operator& ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar & valarray
    _VALOP(_Ty, _Right.size(), _Left & _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator& ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray & valarray
    _VALOP(_Ty, _Left.size(), _Left[_Idx] & _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator&& ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray && scalar
    _VALOP(bool, _Left.size(), _Left[_Idx] && _Right);
    }

template<class _Ty >

_Boolarray operator&& ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar && valarray
    _VALOP(bool, _Right.size(), _Left && _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator&& ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray && valarray
    _VALOP(bool, _Left.size(), _Left[_Idx] && _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator* ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray * scalar
    _VALOP(_Ty, _Left.size(), _Left[_Idx] * _Right);
    }

template<class _Ty >

valarray<_Ty> operator* ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar * valarray
    _VALOP(_Ty, _Right.size(), _Left * _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator* ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray * valarray
    _VALOP(_Ty, _Left.size(), _Left[_Idx] * _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator+ ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray + scalar
    _VALOP(_Ty, _Left.size(), _Left[_Idx] + _Right);
    }

template<class _Ty >

valarray<_Ty> operator+ ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar + valarray
    _VALOP(_Ty, _Right.size(), _Left + _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator+ ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray + valarray
    _VALOP(_Ty, _Left.size(), _Left[_Idx] + _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator- ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray - scalar
    _VALOP(_Ty, _Left.size(), _Left[_Idx] - _Right);
    }

template<class _Ty >

valarray<_Ty> operator- ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar - valarray
    _VALOP(_Ty, _Right.size(), _Left - _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator- ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray - valarray
    _VALOP(_Ty, _Left.size(), _Left[_Idx] - _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator/ ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray / scalar
    _VALOP(_Ty, _Left.size(), _Left[_Idx] / _Right);
    }

template<class _Ty >

valarray<_Ty> operator/ ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar / valarray
    _VALOP(_Ty, _Right.size(), _Left / _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator/ ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray ? valarray
    _VALOP(_Ty, _Left.size(), _Left[_Idx] / _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator< ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray < scalar
    _VALOP(bool, _Left.size(), _Left[_Idx] < _Right);
    }

template<class _Ty >

_Boolarray operator< ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar < valarray
    _VALOP(bool, _Right.size(), _Left < _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator< ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray < valarray
    _VALOP(bool, _Left.size(), _Left[_Idx] < _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator<< ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray << scalar
    _VALOP(_Ty, _Left.size(), _Left[_Idx] << _Right);
    }

template<class _Ty >

valarray<_Ty> operator<< ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar << valarray
    _VALOP(_Ty, _Right.size(), _Left << _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator<< ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray << valarray
    _VALOP(_Ty, _Left.size(), _Left[_Idx] << _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator<= ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray <= scalar
    _VALOP(bool, _Left.size(), _Left[_Idx] <= _Right);
    }

template<class _Ty >

_Boolarray operator<= ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar <= valarray
    _VALOP(bool, _Right.size(), _Left <= _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator<= ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray <= valarray
    _VALOP(bool, _Left.size(), _Left[_Idx] <= _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator== ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray == scalar
    _VALOP(bool, _Left.size(), _Left[_Idx] == _Right);
    }

template<class _Ty >

_Boolarray operator== ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar == valarray
    _VALOP(bool, _Right.size(), _Left == _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator== ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray == valarray
    _VALOP(bool, _Left.size(), _Left[_Idx] == _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator> ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray > scalar
    _VALOP(bool, _Left.size(), _Left[_Idx] > _Right);
    }

template<class _Ty >

_Boolarray operator> ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar > valarray
    _VALOP(bool, _Right.size(), _Left > _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator> ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray > valarray
    _VALOP(bool, _Left.size(), _Left[_Idx] > _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator>= ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray >= scalar
    _VALOP(bool, _Left.size(), _Left[_Idx] >= _Right);
    }

template<class _Ty >

_Boolarray operator>= ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar >= valarray
    _VALOP(bool, _Right.size(), _Left >= _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator>= ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray >= valarray
    _VALOP(bool, _Left.size(), _Left[_Idx] >= _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator>> ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray >> scalar
    _VALOP(_Ty, _Left.size(), _Left[_Idx] >> _Right);
    }

template<class _Ty >

valarray<_Ty> operator>> ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar >> valarray
    _VALOP(_Ty, _Right.size(), _Left >> _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator>> ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray >> valarray
    _VALOP(_Ty, _Left.size(), _Left[_Idx] >> _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator^ ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray ^ scalar
    _VALOP(_Ty, _Left.size(), _Left[_Idx] ^ _Right);
    }

template<class _Ty >

valarray<_Ty> operator^ ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar ^ valarray
    _VALOP(_Ty, _Right.size(), _Left ^ _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator^ ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray ^ valarray
    _VALOP(_Ty, _Left.size(), _Left[_Idx] ^ _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator| ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray | scalar
    _VALOP(_Ty, _Left.size(), _Left[_Idx] | _Right);
    }

template<class _Ty >

valarray<_Ty> operator| ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar | valarray
    _VALOP(_Ty, _Right.size(), _Left | _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> operator| ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray | valarray
    _VALOP(_Ty, _Left.size(), _Left[_Idx] | _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator|| ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // return valarray || scalar
    _VALOP(bool, _Left.size(), _Left[_Idx] || _Right);
    }

template<class _Ty >

_Boolarray operator|| ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return scalar || valarray
    _VALOP(bool, _Right.size(), _Left || _Right[_Idx]);
    }

template<class _Ty >

_Boolarray operator|| ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // return valarray || valarray
    _VALOP(bool, _Left.size(), _Left[_Idx] || _Right[_Idx]);
    }

template<class _Ty >

valarray<_Ty> pow ( const valarray< _Ty > &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // apply pow to pairs of valarray elements
    _VALOP(_Ty, _Left.size(), _CSTD pow(_Left[_Idx], _Right[_Idx]));
    }

template<class _Ty >

valarray<_Ty> pow ( const valarray< _Ty > &  _Left, const _Ty &  _Right  )

inline

    {   // apply pow to each valarray element and scalar
    _VALOP(_Ty, _Left.size(), _CSTD pow(_Left[_Idx], _Right));
    }

template<class _Ty >

valarray<_Ty> pow ( const _Ty &  _Left, const valarray< _Ty > &  _Right  )

inline

    {   // apply pow to scalar and each valarray element
    _VALOP(_Ty, _Right.size(), _CSTD pow(_Left, _Right[_Idx]));
    }

template<class _Ty >

valarray<_Ty> sin ( const valarray< _Ty > &  _Left )

inline

    {   // apply sin to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD sin(_Left[_Idx]));
    }

template<class _Ty >

valarray<_Ty> sinh ( const valarray< _Ty > &  _Left )

inline

    {   // apply sinh to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD sinh(_Left[_Idx]));
    }

template<class _Ty >

valarray<_Ty> sqrt ( const valarray< _Ty > &  _Left )

inline

    {   // apply sqrt to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD sqrt(_Left[_Idx]));
    }

template<class _Ty >

void swap ( valarray< _Ty > &  _Left, valarray< _Ty > &  _Right  )

inline

    {   // swap _Left and _Right valarrays
    _Left.swap(_Right);
    }

template<class _Ty >

valarray<_Ty> tan ( const valarray< _Ty > &  _Left )

inline

    {   // apply tan to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD tan(_Left[_Idx]));
    }

template<class _Ty >

valarray<_Ty> tanh ( const valarray< _Ty > &  _Left )

inline

    {   // apply tanh to each element of valarray
    _VALOP(_Ty, _Left.size(), _CSTD tanh(_Left[_Idx]));
    }