STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Classes | Macros | Typedefs | Functions
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;
_W64 unsigned int size_t
Definition: crtdefs.h:496
valarray< size_t > _Sizarray
Definition: valarray:32
for(;0< _Count;)
Definition: algorithm:1944
_Check_return_ _In_ long _Size
Definition: io.h:325
#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;
_W64 unsigned int size_t
Definition: crtdefs.h:496
for(;0< _Count;)
Definition: algorithm:1944
_Check_return_ _In_ long _Size
Definition: io.h:325
#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;
_W64 unsigned int size_t
Definition: crtdefs.h:496
for(;0< _Count;)
Definition: algorithm:1944
_CRT_MANAGED_FP_DEPRECATE _In_ unsigned int _Mask
Definition: float.h:120
_Check_return_ _In_ long _Size
Definition: io.h:325
#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;
_W64 unsigned int size_t
Definition: crtdefs.h:496
for(;0< _Count;)
Definition: algorithm:1944
#define _VALARRAY_
#define _VALGOP (   RHS)
Value:
/* apply RHS(_Idx) to valarray */ \
for (size_t _Idx = 0; _Idx < size(); ++_Idx) \
_Myptr[_Idx] RHS; \
return (*this)
for(;0< _Count;)
Definition: algorithm:1944
return(_PAIR_TYPE(_FwdIt)(_First, _First))
#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)
for(;0< _Count;)
Definition: algorithm:1944
return(_PAIR_TYPE(_FwdIt)(_First, _First))

Typedef Documentation

typedef valarray<_Bool> _Boolarray

Function Documentation

template<class _Ty >
valarray<_Ty> abs ( const valarray< _Ty > &  _Left)
inline
900  { // apply abs to each element of valarray
901  _VALOP(_Ty, _Left.size(), abs(_Left[_Idx]));
902  }
valarray< _Ty > abs(const valarray< _Ty > &_Left)
Definition: valarray:899
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> acos ( const valarray< _Ty > &  _Left)
inline
906  { // apply acos to each element of valarray
907  _VALOP(_Ty, _Left.size(), _CSTD acos(_Left[_Idx]));
908  }
valarray< _Ty > acos(const valarray< _Ty > &_Left)
Definition: valarray:905
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
valarray<_Ty> asin ( const valarray< _Ty > &  _Left)
inline
912  { // apply asin to each element of valarray
913  _VALOP(_Ty, _Left.size(), _CSTD asin(_Left[_Idx]));
914  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
valarray< _Ty > asin(const valarray< _Ty > &_Left)
Definition: valarray:911
template<class _Ty >
valarray<_Ty> atan ( const valarray< _Ty > &  _Left)
inline
918  { // apply atan to each element of valarray
919  _VALOP(_Ty, _Left.size(), _CSTD atan(_Left[_Idx]));
920  }
valarray< _Ty > atan(const valarray< _Ty > &_Left)
Definition: valarray:917
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
valarray<_Ty> atan2 ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
925  { // apply atan2 to pairs of valarray elements
926  _VALOP(_Ty, _Left.size(), _CSTD atan2(_Left[_Idx], _Right[_Idx]));
927  }
valarray< _Ty > atan2(const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
Definition: valarray:923
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
valarray<_Ty> atan2 ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
931  { // apply atan2 to each valarray element and scalar
932  _VALOP(_Ty, _Left.size(), _CSTD atan2(_Left[_Idx], _Right));
933  }
valarray< _Ty > atan2(const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
Definition: valarray:923
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> atan2 ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
937  { // apply atan2 to scalar and each valarray element
938  _VALOP(_Ty, _Right.size(), _CSTD atan2(_Left, _Right[_Idx]));
939  }
valarray< _Ty > atan2(const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
Definition: valarray:923
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
_Ty* begin ( valarray< _Ty > &  _Array)
inline
498  { // get beginning of valarray
499  return (&_Array[0]);
500  }
template<class _Ty >
const _Ty* begin ( const valarray< _Ty > &  _Array)
inline
504  { // get beginning of valarray
505  return (&_Array[0]);
506  }
template<class _Ty >
valarray<_Ty> cos ( const valarray< _Ty > &  _Left)
inline
943  { // apply cos to each element of valarray
944  _VALOP(_Ty, _Left.size(), _CSTD cos(_Left[_Idx]));
945  }
valarray< _Ty > cos(const valarray< _Ty > &_Left)
Definition: valarray:942
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
valarray<_Ty> cosh ( const valarray< _Ty > &  _Left)
inline
949  { // apply cosh to each element of valarray
950  _VALOP(_Ty, _Left.size(), _CSTD cosh(_Left[_Idx]));
951  }
valarray< _Ty > cosh(const valarray< _Ty > &_Left)
Definition: valarray:948
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
_Ty* end ( valarray< _Ty > &  _Array)
inline
510  { // get end of valarray
511  return (&_Array[0] + _Array.size());
512  }
size_t size() const
Definition: valarray:312
template<class _Ty >
const _Ty* end ( const valarray< _Ty > &  _Array)
inline
516  { // get end of valarray
517  return (&_Array[0] + _Array.size());
518  }
size_t size() const
Definition: valarray:312
template<class _Ty >
valarray<_Ty> exp ( const valarray< _Ty > &  _Left)
inline
955  { // apply exp to each element of valarray
956  _VALOP(_Ty, _Left.size(), _CSTD exp(_Left[_Idx]));
957  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
valarray< _Ty > exp(const valarray< _Ty > &_Left)
Definition: valarray:954
template<class _Ty >
valarray<_Ty> log ( const valarray< _Ty > &  _Left)
inline
961  { // apply log to each element of valarray
962  _VALOP(_Ty, _Left.size(), _CSTD log(_Left[_Idx]));
963  }
valarray< _Ty > log(const valarray< _Ty > &_Left)
Definition: valarray:960
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
valarray<_Ty> log10 ( const valarray< _Ty > &  _Left)
inline
967  { // apply log10 to each element of valarray
968  _VALOP(_Ty, _Left.size(), _CSTD log10(_Left[_Idx]));
969  }
valarray< _Ty > log10(const valarray< _Ty > &_Left)
Definition: valarray:966
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
_Boolarray operator!= ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
796  { // return valarray != scalar
797  _VALOP(_Bool, _Left.size(), _Left[_Idx] != _Right);
798  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
_Boolarray operator!= ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
803  { // return scalar != valarray
804  _VALOP(_Bool, _Right.size(), _Left != _Right[_Idx]);
805  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator!= ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
810  { // return valarray != valarray
811  _VALOP(_Bool, _Left.size(), _Left[_Idx] != _Right[_Idx]);
812  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator% ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
551  { // return valarray % scalar
552  _VALOP(_Ty, _Left.size(), _Left[_Idx] % _Right);
553  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> operator% ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
558  { // return scalar % valarray
559  _VALOP(_Ty, _Right.size(), _Left % _Right[_Idx]);
560  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator% ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
705  { // return valarray % valarray
706  _VALOP(_Ty, _Left.size(), _Left[_Idx] % _Right[_Idx]);
707  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator& ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
607  { // return valarray & scalar
608  _VALOP(_Ty, _Left.size(), _Left[_Idx] & _Right);
609  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> operator& ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
614  { // return scalar & valarray
615  _VALOP(_Ty, _Right.size(), _Left & _Right[_Idx]);
616  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator& ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
733  { // return valarray & valarray
734  _VALOP(_Ty, _Left.size(), _Left[_Idx] & _Right[_Idx]);
735  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator&& ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
663  { // return valarray && scalar
664  _VALOP(_Bool, _Left.size(), _Left[_Idx] && _Right);
665  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
_Boolarray operator&& ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
670  { // return scalar && valarray
671  _VALOP(_Bool, _Right.size(), _Left && _Right[_Idx]);
672  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator&& ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
761  { // return valarray && valarray
762  _VALOP(_Bool, _Left.size(), _Left[_Idx] && _Right[_Idx]);
763  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator* ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
523  { // return valarray * scalar
524  _VALOP(_Ty, _Left.size(), _Left[_Idx] * _Right);
525  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> operator* ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
530  { // return scalar * valarray
531  _VALOP(_Ty, _Right.size(), _Left * _Right[_Idx]);
532  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator* ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
691  { // return valarray * valarray
692  _VALOP(_Ty, _Left.size(), _Left[_Idx] * _Right[_Idx]);
693  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator+ ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
565  { // return valarray + scalar
566  _VALOP(_Ty, _Left.size(), _Left[_Idx] + _Right);
567  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> operator+ ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
572  { // return scalar + valarray
573  _VALOP(_Ty, _Right.size(), _Left + _Right[_Idx]);
574  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator+ ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
712  { // return valarray + valarray
713  _VALOP(_Ty, _Left.size(), _Left[_Idx] + _Right[_Idx]);
714  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator- ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
579  { // return valarray - scalar
580  _VALOP(_Ty, _Left.size(), _Left[_Idx] - _Right);
581  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> operator- ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
586  { // return scalar - valarray
587  _VALOP(_Ty, _Right.size(), _Left - _Right[_Idx]);
588  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator- ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
719  { // return valarray - valarray
720  _VALOP(_Ty, _Left.size(), _Left[_Idx] - _Right[_Idx]);
721  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator/ ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
537  { // return valarray / scalar
538  _VALOP(_Ty, _Left.size(), _Left[_Idx] / _Right);
539  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> operator/ ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
544  { // return scalar / valarray
545  _VALOP(_Ty, _Right.size(), _Left / _Right[_Idx]);
546  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator/ ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
698  { // return valarray ? valarray
699  _VALOP(_Ty, _Left.size(), _Left[_Idx] / _Right[_Idx]);
700  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator< ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
817  { // return valarray < scalar
818  _VALOP(_Bool, _Left.size(), _Left[_Idx] < _Right);
819  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
_Boolarray operator< ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
824  { // return scalar < valarray
825  _VALOP(_Bool, _Right.size(), _Left < _Right[_Idx]);
826  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator< ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
831  { // return valarray < valarray
832  _VALOP(_Bool, _Left.size(), _Left[_Idx] < _Right[_Idx]);
833  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator<< ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
635  { // return valarray << scalar
636  _VALOP(_Ty, _Left.size(), _Left[_Idx] << _Right);
637  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> operator<< ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
642  { // return scalar << valarray
643  _VALOP(_Ty, _Right.size(), _Left << _Right[_Idx]);
644  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator<< ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
747  { // return valarray << valarray
748  _VALOP(_Ty, _Left.size(), _Left[_Idx] << _Right[_Idx]);
749  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator<= ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
859  { // return valarray <= scalar
860  _VALOP(_Bool, _Left.size(), _Left[_Idx] <= _Right);
861  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
_Boolarray operator<= ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
866  { // return scalar <= valarray
867  _VALOP(_Bool, _Right.size(), _Left <= _Right[_Idx]);
868  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator<= ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
873  { // return valarray <= valarray
874  _VALOP(_Bool, _Left.size(), _Left[_Idx] <= _Right[_Idx]);
875  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator== ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
775  { // return valarray == scalar
776  _VALOP(_Bool, _Left.size(), _Left[_Idx] == _Right);
777  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
_Boolarray operator== ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
782  { // return scalar == valarray
783  _VALOP(_Bool, _Right.size(), _Left == _Right[_Idx]);
784  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator== ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
789  { // return valarray == valarray
790  _VALOP(_Bool, _Left.size(), _Left[_Idx] == _Right[_Idx]);
791  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator> ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
838  { // return valarray > scalar
839  _VALOP(_Bool, _Left.size(), _Left[_Idx] > _Right);
840  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
_Boolarray operator> ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
845  { // return scalar > valarray
846  _VALOP(_Bool, _Right.size(), _Left > _Right[_Idx]);
847  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator> ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
852  { // return valarray > valarray
853  _VALOP(_Bool, _Left.size(), _Left[_Idx] > _Right[_Idx]);
854  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator>= ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
880  { // return valarray >= scalar
881  _VALOP(_Bool, _Left.size(), _Left[_Idx] >= _Right);
882  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
_Boolarray operator>= ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
887  { // return scalar >= valarray
888  _VALOP(_Bool, _Right.size(), _Left >= _Right[_Idx]);
889  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator>= ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
894  { // return valarray >= valarray
895  _VALOP(_Bool, _Left.size(), _Left[_Idx] >= _Right[_Idx]);
896  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator>> ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
649  { // return valarray >> scalar
650  _VALOP(_Ty, _Left.size(), _Left[_Idx] >> _Right);
651  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> operator>> ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
656  { // return scalar >> valarray
657  _VALOP(_Ty, _Right.size(), _Left >> _Right[_Idx]);
658  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator>> ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
754  { // return valarray >> valarray
755  _VALOP(_Ty, _Left.size(), _Left[_Idx] >> _Right[_Idx]);
756  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator^ ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
593  { // return valarray ^ scalar
594  _VALOP(_Ty, _Left.size(), _Left[_Idx] ^ _Right);
595  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> operator^ ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
600  { // return scalar ^ valarray
601  _VALOP(_Ty, _Right.size(), _Left ^ _Right[_Idx]);
602  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator^ ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
726  { // return valarray ^ valarray
727  _VALOP(_Ty, _Left.size(), _Left[_Idx] ^ _Right[_Idx]);
728  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator| ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
621  { // return valarray | scalar
622  _VALOP(_Ty, _Left.size(), _Left[_Idx] | _Right);
623  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> operator| ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
628  { // return scalar | valarray
629  _VALOP(_Ty, _Right.size(), _Left | _Right[_Idx]);
630  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> operator| ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
740  { // return valarray | valarray
741  _VALOP(_Ty, _Left.size(), _Left[_Idx] | _Right[_Idx]);
742  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator|| ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
677  { // return valarray || scalar
678  _VALOP(_Bool, _Left.size(), _Left[_Idx] || _Right);
679  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
_Boolarray operator|| ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
684  { // return scalar || valarray
685  _VALOP(_Bool, _Right.size(), _Left || _Right[_Idx]);
686  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
_Boolarray operator|| ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
768  { // return valarray || valarray
769  _VALOP(_Bool, _Left.size(), _Left[_Idx] || _Right[_Idx]);
770  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
template<class _Ty >
valarray<_Ty> pow ( const valarray< _Ty > &  _Left,
const valarray< _Ty > &  _Right 
)
inline
974  { // apply pow to pairs of valarray elements
975  _VALOP(_Ty, _Left.size(), _CSTD pow(_Left[_Idx], _Right[_Idx]));
976  }
valarray< _Ty > pow(const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
Definition: valarray:972
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
valarray<_Ty> pow ( const valarray< _Ty > &  _Left,
const _Ty &  _Right 
)
inline
980  { // apply pow to each valarray element and scalar
981  _VALOP(_Ty, _Left.size(), _CSTD pow(_Left[_Idx], _Right));
982  }
valarray< _Ty > pow(const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
Definition: valarray:972
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
const _Ty & _Right
Definition: algorithm:4087
template<class _Ty >
valarray<_Ty> pow ( const _Ty &  _Left,
const valarray< _Ty > &  _Right 
)
inline
986  { // apply pow to scalar and each valarray element
987  _VALOP(_Ty, _Right.size(), _CSTD pow(_Left, _Right[_Idx]));
988  }
valarray< _Ty > pow(const valarray< _Ty > &_Left, const valarray< _Ty > &_Right)
Definition: valarray:972
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
valarray<_Ty> sin ( const valarray< _Ty > &  _Left)
inline
992  { // apply sin to each element of valarray
993  _VALOP(_Ty, _Left.size(), _CSTD sin(_Left[_Idx]));
994  }
size_t size() const
Definition: valarray:312
valarray< _Ty > sin(const valarray< _Ty > &_Left)
Definition: valarray:991
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
valarray<_Ty> sinh ( const valarray< _Ty > &  _Left)
inline
998  { // apply sinh to each element of valarray
999  _VALOP(_Ty, _Left.size(), _CSTD sinh(_Left[_Idx]));
1000  }
size_t size() const
Definition: valarray:312
valarray< _Ty > sinh(const valarray< _Ty > &_Left)
Definition: valarray:997
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
valarray<_Ty> sqrt ( const valarray< _Ty > &  _Left)
inline
1004  { // apply sqrt to each element of valarray
1005  _VALOP(_Ty, _Left.size(), _CSTD sqrt(_Left[_Idx]));
1006  }
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
valarray< _Ty > sqrt(const valarray< _Ty > &_Left)
Definition: valarray:1003
template<class _Ty >
void swap ( valarray< _Ty > &  _Left,
valarray< _Ty > &  _Right 
)
inline
492  { // swap _Left and _Right valarrays
493  _Left.swap(_Right);
494  }
void swap(_Myt &_Right) _NOEXCEPT
Definition: valarray:142
template<class _Ty >
valarray<_Ty> tan ( const valarray< _Ty > &  _Left)
inline
1010  { // apply tan to each element of valarray
1011  _VALOP(_Ty, _Left.size(), _CSTD tan(_Left[_Idx]));
1012  }
valarray< _Ty > tan(const valarray< _Ty > &_Left)
Definition: valarray:1009
size_t size() const
Definition: valarray:312
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559
template<class _Ty >
valarray<_Ty> tanh ( const valarray< _Ty > &  _Left)
inline
1016  { // apply tanh to each element of valarray
1017  _VALOP(_Ty, _Left.size(), _CSTD tanh(_Left[_Idx]));
1018  }
size_t size() const
Definition: valarray:312
valarray< _Ty > tanh(const valarray< _Ty > &_Left)
Definition: valarray:1015
#define _VALOP(TYPE, LENGTH, RHS)
Definition: valarray:35
#define _CSTD
Definition: yvals.h:559