ReactOS  0.4.14-dev-614-gbfd8a84
_valarray.h File Reference
#include <stl/_cmath.h>
#include <stl/_new.h>
#include <stl/_algo.h>
#include <stl/_numeric.h>
#include <stl/_limits.h>
#include <stl/_valarray.c>
Include dependency graph for _valarray.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  valarray< _Tp >
 
class  slice_array< _Tp >
 
class  gslice_array< _Tp >
 
class  mask_array< _Tp >
 
class  indirect_array< _Tp >
 
struct  _Valarray_base< _Tp >
 
class  valarray< _Tp >
 
struct  valarray< _Tp >::_NoInit
 
class  slice
 
class  slice_array< _Tp >
 
struct  _Gslice_Iter_tmpl< _Size >
 
class  gslice
 
struct  _Gslice_Iter_tmpl< _Size >
 
class  gslice_array< _Tp >
 
class  mask_array< _Tp >
 
class  indirect_array< _Tp >
 

Typedefs

typedef valarray< bool_Valarray_bool
 
typedef valarray< size_t_Valarray_size_t
 
typedef _Gslice_Iter_tmpl< size_t_Gslice_Iter
 

Functions

template<class _Tp >
valarray< _Tp > _STLP_CALL operator * (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator/ (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator% (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator+ (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator- (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator^ (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator & (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator| (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator<< (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator>> (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator * (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator * (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator/ (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator/ (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator% (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator% (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator+ (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator+ (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator- (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator- (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator^ (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator^ (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator & (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator & (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator| (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator| (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator<< (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator<< (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator>> (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > _STLP_CALL operator>> (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator== (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator< (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator && (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator|| (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator== (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator== (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator!= (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator!= (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator< (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator< (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator> (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator> (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator<= (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator<= (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator>= (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator>= (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator && (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator && (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator|| (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
_Valarray_bool _STLP_CALL operator|| (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > abs (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > acos (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > asin (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > atan (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > atan2 (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > atan2 (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > atan2 (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > cos (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > cosh (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > exp (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > log (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > log10 (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > pow (const valarray< _Tp > &__x, const valarray< _Tp > &__y)
 
template<class _Tp >
valarray< _Tp > pow (const valarray< _Tp > &__x, const _Tp &__c)
 
template<class _Tp >
valarray< _Tp > pow (const _Tp &__c, const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > sin (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > sinh (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > sqrt (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > tan (const valarray< _Tp > &__x)
 
template<class _Tp >
valarray< _Tp > tanh (const valarray< _Tp > &__x)
 

Typedef Documentation

◆ _Gslice_Iter

Definition at line 1301 of file _valarray.h.

◆ _Valarray_bool

Definition at line 47 of file _valarray.h.

◆ _Valarray_size_t

Definition at line 49 of file _valarray.h.

Function Documentation

◆ abs()

template<class _Tp >
valarray<_Tp> abs ( const valarray< _Tp > &  __x)
inline

Definition at line 892 of file _valarray.h.

892  {
893  typedef typename valarray<_Tp>::_NoInit _NoInit;
894  valarray<_Tp> __tmp(__x.size(), _NoInit());
895  for (size_t __i = 0; __i < __x.size(); ++__i)
896  __tmp[__i] = ::abs(__x[__i]);
897  return __tmp;
898 }
size_t size() const
Definition: _valarray.h:164
valarray< _Tp > abs(const valarray< _Tp > &__x)
Definition: _valarray.h:892

◆ acos()

template<class _Tp >
valarray<_Tp> acos ( const valarray< _Tp > &  __x)
inline

Definition at line 901 of file _valarray.h.

901  {
902  typedef typename valarray<_Tp>::_NoInit _NoInit;
903  valarray<_Tp> __tmp(__x.size(), _NoInit());
904  for (size_t __i = 0; __i < __x.size(); ++__i)
905  __tmp[__i] = ::acos(__x[__i]);
906  return __tmp;
907 }
valarray< _Tp > acos(const valarray< _Tp > &__x)
Definition: _valarray.h:901
size_t size() const
Definition: _valarray.h:164

Referenced by _CIacos(), acosf(), AngleBetweenVectorsRad(), D3DRMQuaternionSlerp(), CMathTest::import_checks(), Math_acos(), CDrvDefExt::PaintStaticControls(), pres_acos(), rpn_acos(), and ValarrayTest::transcendentals().

◆ asin()

template<class _Tp >
valarray<_Tp> asin ( const valarray< _Tp > &  __x)
inline

Definition at line 910 of file _valarray.h.

910  {
911  typedef typename valarray<_Tp>::_NoInit _NoInit;
912  valarray<_Tp> __tmp(__x.size(), _NoInit());
913  for (size_t __i = 0; __i < __x.size(); ++__i)
914  __tmp[__i] = ::asin(__x[__i]);
915  return __tmp;
916 }
valarray< _Tp > asin(const valarray< _Tp > &__x)
Definition: _valarray.h:910
size_t size() const
Definition: _valarray.h:164

Referenced by _CIasin(), asinf(), CMathTest::import_checks(), Math_asin(), pres_asin(), rpn_asin(), and ValarrayTest::transcendentals().

◆ atan()

template<class _Tp >
valarray<_Tp> atan ( const valarray< _Tp > &  __x)
inline

Definition at line 919 of file _valarray.h.

919  {
920  typedef typename valarray<_Tp>::_NoInit _NoInit;
921  valarray<_Tp> __tmp(__x.size(), _NoInit());
922  for (size_t __i = 0; __i < __x.size(); ++__i)
923  __tmp[__i] = ::atan(__x[__i]);
924  return __tmp;
925 }
valarray< _Tp > atan(const valarray< _Tp > &__x)
Definition: _valarray.h:919
size_t size() const
Definition: _valarray.h:164

Referenced by _CIatan(), atanf(), GdipCreateLineBrushFromRectWithAngle(), Global_Atn(), CMathTest::import_checks(), Math_atan(), pres_atan(), rpn_atan(), and ValarrayTest::transcendentals().

◆ atan2() [1/3]

template<class _Tp >
valarray<_Tp> atan2 ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 928 of file _valarray.h.

929  {
930  typedef typename valarray<_Tp>::_NoInit _NoInit;
931  valarray<_Tp> __tmp(__x.size(), _NoInit());
932  for (size_t __i = 0; __i < __x.size(); ++__i)
933  __tmp[__i] = ::atan2(__x[__i], __y[__i]);
934  return __tmp;
935 }
valarray< _Tp > atan2(const valarray< _Tp > &__x, const valarray< _Tp > &__y)
Definition: _valarray.h:928
size_t size() const
Definition: _valarray.h:164

Referenced by _CIatan2(), acos(), arg(), asin(), atan2(), atan2f(), EMFDRV_ArcChordPie(), gdiplus_atan2(), CMathTest::import_checks(), IntArc(), IntGdiWidenPath(), log10T(), logT(), Math_atan2(), PATH_Arc(), powT(), pres_atan2(), and ValarrayTest::transcendentals().

◆ atan2() [2/3]

template<class _Tp >
valarray<_Tp> atan2 ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 938 of file _valarray.h.

938  {
939  typedef typename valarray<_Tp>::_NoInit _NoInit;
940  valarray<_Tp> __tmp(__x.size(), _NoInit());
941  for (size_t __i = 0; __i < __x.size(); ++__i)
942  __tmp[__i] = ::atan2(__x[__i], __c);
943  return __tmp;
944 }
valarray< _Tp > atan2(const valarray< _Tp > &__x, const valarray< _Tp > &__y)
Definition: _valarray.h:928
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ atan2() [3/3]

template<class _Tp >
valarray<_Tp> atan2 ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 947 of file _valarray.h.

947  {
948  typedef typename valarray<_Tp>::_NoInit _NoInit;
949  valarray<_Tp> __tmp(__x.size(), _NoInit());
950  for (size_t __i = 0; __i < __x.size(); ++__i)
951  __tmp[__i] = ::atan2(__c, __x[__i]);
952  return __tmp;
953 }
valarray< _Tp > atan2(const valarray< _Tp > &__x, const valarray< _Tp > &__y)
Definition: _valarray.h:928
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ cos()

template<class _Tp >
valarray<_Tp> cos ( const valarray< _Tp > &  __x)
inline

Definition at line 956 of file _valarray.h.

956  {
957  typedef typename valarray<_Tp>::_NoInit _NoInit;
958  valarray<_Tp> __tmp(__x.size(), _NoInit());
959  for (size_t __i = 0; __i < __x.size(); ++__i)
960  __tmp[__i] = ::cos(__x[__i]);
961  return __tmp;
962 }
valarray< _Tp > cos(const valarray< _Tp > &__x)
Definition: _valarray.h:956
size_t size() const
Definition: _valarray.h:164

◆ cosh()

template<class _Tp >
valarray<_Tp> cosh ( const valarray< _Tp > &  __x)
inline

Definition at line 965 of file _valarray.h.

965  {
966  typedef typename valarray<_Tp>::_NoInit _NoInit;
967  valarray<_Tp> __tmp(__x.size(), _NoInit());
968  for (size_t __i = 0; __i < __x.size(); ++__i)
969  __tmp[__i] = ::cosh(__x[__i]);
970  return __tmp;
971 }
size_t size() const
Definition: _valarray.h:164
valarray< _Tp > cosh(const valarray< _Tp > &__x)
Definition: _valarray.h:965

◆ exp()

template<class _Tp >
valarray<_Tp> exp ( const valarray< _Tp > &  __x)
inline

Definition at line 974 of file _valarray.h.

974  {
975  typedef typename valarray<_Tp>::_NoInit _NoInit;
976  valarray<_Tp> __tmp(__x.size(), _NoInit());
977  for (size_t __i = 0; __i < __x.size(); ++__i)
978  __tmp[__i] = ::exp(__x[__i]);
979  return __tmp;
980 }
valarray< _Tp > exp(const valarray< _Tp > &__x)
Definition: _valarray.h:974
size_t size() const
Definition: _valarray.h:164

◆ log()

template<class _Tp >
valarray<_Tp> log ( const valarray< _Tp > &  __x)
inline

Definition at line 983 of file _valarray.h.

983  {
984  typedef typename valarray<_Tp>::_NoInit _NoInit;
985  valarray<_Tp> __tmp(__x.size(), _NoInit());
986  for (size_t __i = 0; __i < __x.size(); ++__i)
987  __tmp[__i] = ::log(__x[__i]);
988  return __tmp;
989 }
valarray< _Tp > log(const valarray< _Tp > &__x)
Definition: _valarray.h:983
size_t size() const
Definition: _valarray.h:164

◆ log10()

template<class _Tp >
valarray<_Tp> log10 ( const valarray< _Tp > &  __x)
inline

Definition at line 992 of file _valarray.h.

992  {
993  typedef typename valarray<_Tp>::_NoInit _NoInit;
994  valarray<_Tp> __tmp(__x.size(), _NoInit());
995  for (size_t __i = 0; __i < __x.size(); ++__i)
996  __tmp[__i] = ::log10(__x[__i]);
997  return __tmp;
998 }
size_t size() const
Definition: _valarray.h:164
valarray< _Tp > log10(const valarray< _Tp > &__x)
Definition: _valarray.h:992

◆ operator &() [1/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator & ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 444 of file _valarray.h.

445  {
446  _STLP_ASSERT(__x.size() == __y.size())
447  typedef typename valarray<_Tp>::_NoInit _NoInit;
448  valarray<_Tp> __tmp(__x.size(), _NoInit());
449  for (size_t __i = 0; __i < __x.size(); ++__i)
450  __tmp[__i] = __x[__i] & __y[__i];
451  return __tmp;
452 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator &() [2/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator & ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 598 of file _valarray.h.

598  {
599  typedef typename valarray<_Tp>::_NoInit _NoInit;
600  valarray<_Tp> __tmp(__x.size(), _NoInit());
601  for (size_t __i = 0; __i < __x.size(); ++__i)
602  __tmp[__i] = __x[__i] & __c;
603  return __tmp;
604 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator &() [3/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator & ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 607 of file _valarray.h.

607  {
608  typedef typename valarray<_Tp>::_NoInit _NoInit;
609  valarray<_Tp> __tmp(__x.size(), _NoInit());
610  for (size_t __i = 0; __i < __x.size(); ++__i)
611  __tmp[__i] = __c & __x[__i];
612  return __tmp;
613 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator &&() [1/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator && ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 739 of file _valarray.h.

740  {
741  _STLP_ASSERT(__x.size() == __y.size())
742  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
743  for (size_t __i = 0; __i < __x.size(); ++__i)
744  __tmp[__i] = __x[__i] && __y[__i];
745  return __tmp;
746 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator &&() [2/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator && ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 857 of file _valarray.h.

857  {
858  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
859  for (size_t __i = 0; __i < __x.size(); ++__i)
860  __tmp[__i] = __x[__i] && __c;
861  return __tmp;
862 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator &&() [3/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator && ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 865 of file _valarray.h.

865  {
866  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
867  for (size_t __i = 0; __i < __x.size(); ++__i)
868  __tmp[__i] = __c && __x[__i];
869  return __tmp;
870 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator *() [1/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator * ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 378 of file _valarray.h.

379  {
380  _STLP_ASSERT(__x.size() == __y.size())
381  typedef typename valarray<_Tp>::_NoInit _NoInit;
382  valarray<_Tp> __tmp(__x.size(), _NoInit());
383  for (size_t __i = 0; __i < __x.size(); ++__i)
384  __tmp[__i] = __x[__i] * __y[__i];
385  return __tmp;
386 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator *() [2/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator * ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 490 of file _valarray.h.

490  {
491  typedef typename valarray<_Tp>::_NoInit _NoInit;
492  valarray<_Tp> __tmp(__x.size(), _NoInit());
493  for (size_t __i = 0; __i < __x.size(); ++__i)
494  __tmp[__i] = __x[__i] * __c;
495  return __tmp;
496 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator *() [3/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator * ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 499 of file _valarray.h.

499  {
500  typedef typename valarray<_Tp>::_NoInit _NoInit;
501  valarray<_Tp> __tmp(__x.size(), _NoInit());
502  for (size_t __i = 0; __i < __x.size(); ++__i)
503  __tmp[__i] = __c * __x[__i];
504  return __tmp;
505 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator!=() [1/2]

template<class _Tp >
_Valarray_bool _STLP_CALL operator!= ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 777 of file _valarray.h.

777  {
778  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
779  for (size_t __i = 0; __i < __x.size(); ++__i)
780  __tmp[__i] = __x[__i] != __c;
781  return __tmp;
782 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator!=() [2/2]

template<class _Tp >
_Valarray_bool _STLP_CALL operator!= ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 785 of file _valarray.h.

785  {
786  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
787  for (size_t __i = 0; __i < __x.size(); ++__i)
788  __tmp[__i] = __c != __x[__i];
789  return __tmp;
790 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator%() [1/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator% ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 400 of file _valarray.h.

401  {
402  _STLP_ASSERT(__x.size() == __y.size())
403  typedef typename valarray<_Tp>::_NoInit _NoInit;
404  valarray<_Tp> __tmp(__x.size(), _NoInit());
405  for (size_t __i = 0; __i < __x.size(); ++__i)
406  __tmp[__i] = __x[__i] % __y[__i];
407  return __tmp;
408 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator%() [2/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator% ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 526 of file _valarray.h.

526  {
527  typedef typename valarray<_Tp>::_NoInit _NoInit;
528  valarray<_Tp> __tmp(__x.size(), _NoInit());
529  for (size_t __i = 0; __i < __x.size(); ++__i)
530  __tmp[__i] = __x[__i] % __c;
531  return __tmp;
532 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator%() [3/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator% ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 535 of file _valarray.h.

535  {
536  typedef typename valarray<_Tp>::_NoInit _NoInit;
537  valarray<_Tp> __tmp(__x.size(), _NoInit());
538  for (size_t __i = 0; __i < __x.size(); ++__i)
539  __tmp[__i] = __c % __x[__i];
540  return __tmp;
541 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator+() [1/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator+ ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 411 of file _valarray.h.

412  {
413  _STLP_ASSERT(__x.size() == __y.size())
414  typedef typename valarray<_Tp>::_NoInit _NoInit;
415  valarray<_Tp> __tmp(__x.size(), _NoInit());
416  for (size_t __i = 0; __i < __x.size(); ++__i)
417  __tmp[__i] = __x[__i] + __y[__i];
418  return __tmp;
419 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator+() [2/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator+ ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 544 of file _valarray.h.

544  {
545  typedef typename valarray<_Tp>::_NoInit _NoInit;
546  valarray<_Tp> __tmp(__x.size(), _NoInit());
547  for (size_t __i = 0; __i < __x.size(); ++__i)
548  __tmp[__i] = __x[__i] + __c;
549  return __tmp;
550 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator+() [3/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator+ ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 553 of file _valarray.h.

553  {
554  typedef typename valarray<_Tp>::_NoInit _NoInit;
555  valarray<_Tp> __tmp(__x.size(), _NoInit());
556  for (size_t __i = 0; __i < __x.size(); ++__i)
557  __tmp[__i] = __c + __x[__i];
558  return __tmp;
559 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator-() [1/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator- ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 422 of file _valarray.h.

423  {
424  _STLP_ASSERT(__x.size() == __y.size())
425  typedef typename valarray<_Tp>::_NoInit _NoInit;
426  valarray<_Tp> __tmp(__x.size(), _NoInit());
427  for (size_t __i = 0; __i < __x.size(); ++__i)
428  __tmp[__i] = __x[__i] - __y[__i];
429  return __tmp;
430 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator-() [2/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator- ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 562 of file _valarray.h.

562  {
563  typedef typename valarray<_Tp>::_NoInit _NoInit;
564  valarray<_Tp> __tmp(__x.size(), _NoInit());
565  for (size_t __i = 0; __i < __x.size(); ++__i)
566  __tmp[__i] = __x[__i] - __c;
567  return __tmp;
568 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator-() [3/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator- ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 571 of file _valarray.h.

571  {
572  typedef typename valarray<_Tp>::_NoInit _NoInit;
573  valarray<_Tp> __tmp(__x.size(), _NoInit());
574  for (size_t __i = 0; __i < __x.size(); ++__i)
575  __tmp[__i] = __c - __x[__i];
576  return __tmp;
577 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator/() [1/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator/ ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 389 of file _valarray.h.

390  {
391  _STLP_ASSERT(__x.size() == __y.size())
392  typedef typename valarray<_Tp>::_NoInit _NoInit;
393  valarray<_Tp> __tmp(__x.size(), _NoInit());
394  for (size_t __i = 0; __i < __x.size(); ++__i)
395  __tmp[__i] = __x[__i] / __y[__i];
396  return __tmp;
397 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator/() [2/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator/ ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 508 of file _valarray.h.

508  {
509  typedef typename valarray<_Tp>::_NoInit _NoInit;
510  valarray<_Tp> __tmp(__x.size(), _NoInit());
511  for (size_t __i = 0; __i < __x.size(); ++__i)
512  __tmp[__i] = __x[__i] / __c;
513  return __tmp;
514 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator/() [3/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator/ ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 517 of file _valarray.h.

517  {
518  typedef typename valarray<_Tp>::_NoInit _NoInit;
519  valarray<_Tp> __tmp(__x.size(), _NoInit());
520  for (size_t __i = 0; __i < __x.size(); ++__i)
521  __tmp[__i] = __c / __x[__i];
522  return __tmp;
523 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator<() [1/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator< ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 684 of file _valarray.h.

685  {
686  _STLP_ASSERT(__x.size() == __y.size())
687  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
688  for (size_t __i = 0; __i < __x.size(); ++__i)
689  __tmp[__i] = __x[__i] < __y[__i];
690  return __tmp;
691 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator<() [2/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator< ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 793 of file _valarray.h.

793  {
794  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
795  for (size_t __i = 0; __i < __x.size(); ++__i)
796  __tmp[__i] = __x[__i] < __c;
797  return __tmp;
798 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator<() [3/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator< ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 801 of file _valarray.h.

801  {
802  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
803  for (size_t __i = 0; __i < __x.size(); ++__i)
804  __tmp[__i] = __c < __x[__i];
805  return __tmp;
806 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator<<() [1/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator<< ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 466 of file _valarray.h.

467  {
468  _STLP_ASSERT(__x.size() == __y.size())
469  typedef typename valarray<_Tp>::_NoInit _NoInit;
470  valarray<_Tp> __tmp(__x.size(), _NoInit());
471  for (size_t __i = 0; __i < __x.size(); ++__i)
472  __tmp[__i] = __x[__i] << __y[__i];
473  return __tmp;
474 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator<<() [2/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator<< ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 634 of file _valarray.h.

634  {
635  typedef typename valarray<_Tp>::_NoInit _NoInit;
636  valarray<_Tp> __tmp(__x.size(), _NoInit());
637  for (size_t __i = 0; __i < __x.size(); ++__i)
638  __tmp[__i] = __x[__i] << __c;
639  return __tmp;
640 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator<<() [3/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator<< ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 643 of file _valarray.h.

643  {
644  typedef typename valarray<_Tp>::_NoInit _NoInit;
645  valarray<_Tp> __tmp(__x.size(), _NoInit());
646  for (size_t __i = 0; __i < __x.size(); ++__i)
647  __tmp[__i] = __c << __x[__i];
648  return __tmp;
649 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator<=() [1/2]

template<class _Tp >
_Valarray_bool _STLP_CALL operator<= ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 825 of file _valarray.h.

825  {
826  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
827  for (size_t __i = 0; __i < __x.size(); ++__i)
828  __tmp[__i] = __x[__i] <= __c;
829  return __tmp;
830 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator<=() [2/2]

template<class _Tp >
_Valarray_bool _STLP_CALL operator<= ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 833 of file _valarray.h.

833  {
834  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
835  for (size_t __i = 0; __i < __x.size(); ++__i)
836  __tmp[__i] = __c <= __x[__i];
837  return __tmp;
838 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator==() [1/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator== ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 674 of file _valarray.h.

675  {
676  _STLP_ASSERT(__x.size() == __y.size())
677  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
678  for (size_t __i = 0; __i < __x.size(); ++__i)
679  __tmp[__i] = __x[__i] == __y[__i];
680  return __tmp;
681 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator==() [2/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator== ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 761 of file _valarray.h.

761  {
762  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
763  for (size_t __i = 0; __i < __x.size(); ++__i)
764  __tmp[__i] = __x[__i] == __c;
765  return __tmp;
766 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator==() [3/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator== ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 769 of file _valarray.h.

769  {
770  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
771  for (size_t __i = 0; __i < __x.size(); ++__i)
772  __tmp[__i] = __c == __x[__i];
773  return __tmp;
774 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator>() [1/2]

template<class _Tp >
_Valarray_bool _STLP_CALL operator> ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 809 of file _valarray.h.

809  {
810  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
811  for (size_t __i = 0; __i < __x.size(); ++__i)
812  __tmp[__i] = __x[__i] > __c;
813  return __tmp;
814 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator>() [2/2]

template<class _Tp >
_Valarray_bool _STLP_CALL operator> ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 817 of file _valarray.h.

817  {
818  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
819  for (size_t __i = 0; __i < __x.size(); ++__i)
820  __tmp[__i] = __c > __x[__i];
821  return __tmp;
822 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator>=() [1/2]

template<class _Tp >
_Valarray_bool _STLP_CALL operator>= ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 841 of file _valarray.h.

841  {
842  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
843  for (size_t __i = 0; __i < __x.size(); ++__i)
844  __tmp[__i] = __x[__i] >= __c;
845  return __tmp;
846 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator>=() [2/2]

template<class _Tp >
_Valarray_bool _STLP_CALL operator>= ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 849 of file _valarray.h.

849  {
850  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
851  for (size_t __i = 0; __i < __x.size(); ++__i)
852  __tmp[__i] = __c >= __x[__i];
853  return __tmp;
854 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator>>() [1/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator>> ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 477 of file _valarray.h.

478  {
479  _STLP_ASSERT(__x.size() == __y.size())
480  typedef typename valarray<_Tp>::_NoInit _NoInit;
481  valarray<_Tp> __tmp(__x.size(), _NoInit());
482  for (size_t __i = 0; __i < __x.size(); ++__i)
483  __tmp[__i] = __x[__i] >> __y[__i];
484  return __tmp;
485 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator>>() [2/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator>> ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 652 of file _valarray.h.

652  {
653  typedef typename valarray<_Tp>::_NoInit _NoInit;
654  valarray<_Tp> __tmp(__x.size(), _NoInit());
655  for (size_t __i = 0; __i < __x.size(); ++__i)
656  __tmp[__i] = __x[__i] >> __c;
657  return __tmp;
658 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator>>() [3/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator>> ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 661 of file _valarray.h.

661  {
662  typedef typename valarray<_Tp>::_NoInit _NoInit;
663  valarray<_Tp> __tmp(__x.size(), _NoInit());
664  for (size_t __i = 0; __i < __x.size(); ++__i)
665  __tmp[__i] = __c >> __x[__i];
666  return __tmp;
667 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator^() [1/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator^ ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 433 of file _valarray.h.

434  {
435  _STLP_ASSERT(__x.size() == __y.size())
436  typedef typename valarray<_Tp>::_NoInit _NoInit;
437  valarray<_Tp> __tmp(__x.size(), _NoInit());
438  for (size_t __i = 0; __i < __x.size(); ++__i)
439  __tmp[__i] = __x[__i] ^ __y[__i];
440  return __tmp;
441 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator^() [2/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator^ ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 580 of file _valarray.h.

580  {
581  typedef typename valarray<_Tp>::_NoInit _NoInit;
582  valarray<_Tp> __tmp(__x.size(), _NoInit());
583  for (size_t __i = 0; __i < __x.size(); ++__i)
584  __tmp[__i] = __x[__i] ^ __c;
585  return __tmp;
586 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator^() [3/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator^ ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 589 of file _valarray.h.

589  {
590  typedef typename valarray<_Tp>::_NoInit _NoInit;
591  valarray<_Tp> __tmp(__x.size(), _NoInit());
592  for (size_t __i = 0; __i < __x.size(); ++__i)
593  __tmp[__i] = __c ^ __x[__i];
594  return __tmp;
595 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator|() [1/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator| ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 455 of file _valarray.h.

456  {
457  _STLP_ASSERT(__x.size() == __y.size())
458  typedef typename valarray<_Tp>::_NoInit _NoInit;
459  valarray<_Tp> __tmp(__x.size(), _NoInit());
460  for (size_t __i = 0; __i < __x.size(); ++__i)
461  __tmp[__i] = __x[__i] | __y[__i];
462  return __tmp;
463 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator|() [2/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator| ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 616 of file _valarray.h.

616  {
617  typedef typename valarray<_Tp>::_NoInit _NoInit;
618  valarray<_Tp> __tmp(__x.size(), _NoInit());
619  for (size_t __i = 0; __i < __x.size(); ++__i)
620  __tmp[__i] = __x[__i] | __c;
621  return __tmp;
622 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator|() [3/3]

template<class _Tp >
valarray<_Tp> _STLP_CALL operator| ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 625 of file _valarray.h.

625  {
626  typedef typename valarray<_Tp>::_NoInit _NoInit;
627  valarray<_Tp> __tmp(__x.size(), _NoInit());
628  for (size_t __i = 0; __i < __x.size(); ++__i)
629  __tmp[__i] = __c | __x[__i];
630  return __tmp;
631 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator||() [1/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator|| ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 749 of file _valarray.h.

750  {
751  _STLP_ASSERT(__x.size() == __y.size())
752  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
753  for (size_t __i = 0; __i < __x.size(); ++__i)
754  __tmp[__i] = __x[__i] || __y[__i];
755  return __tmp;
756 }
size_t size() const
Definition: _valarray.h:164
#define _STLP_ASSERT(expr)
Definition: _debug.h:165

◆ operator||() [2/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator|| ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 873 of file _valarray.h.

873  {
874  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
875  for (size_t __i = 0; __i < __x.size(); ++__i)
876  __tmp[__i] = __x[__i] || __c;
877  return __tmp;
878 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ operator||() [3/3]

template<class _Tp >
_Valarray_bool _STLP_CALL operator|| ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 881 of file _valarray.h.

881  {
882  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
883  for (size_t __i = 0; __i < __x.size(); ++__i)
884  __tmp[__i] = __c || __x[__i];
885  return __tmp;
886 }
#define __c
Definition: schilyio.h:209
size_t size() const
Definition: _valarray.h:164

◆ pow() [1/3]

template<class _Tp >
valarray<_Tp> pow ( const valarray< _Tp > &  __x,
const valarray< _Tp > &  __y 
)
inline

Definition at line 1001 of file _valarray.h.

1002  {
1003  typedef typename valarray<_Tp>::_NoInit _NoInit;
1004  valarray<_Tp> __tmp(__x.size(), _NoInit());
1005  for (size_t __i = 0; __i < __x.size(); ++__i)
1006  __tmp[__i] = ::pow(__x[__i], __y[__i]);
1007  return __tmp;
1008 }
valarray< _Tp > pow(const valarray< _Tp > &__x, const valarray< _Tp > &__y)
Definition: _valarray.h:1001
size_t size() const
Definition: _valarray.h:164

Referenced by pow().

◆ pow() [2/3]

template<class _Tp >
valarray<_Tp> pow ( const valarray< _Tp > &  __x,
const _Tp &  __c 
)
inline

Definition at line 1011 of file _valarray.h.

1011  {
1012  typedef typename valarray<_Tp>::_NoInit _NoInit;
1013  valarray<_Tp> __tmp(__x.size(), _NoInit());
1014  for (size_t __i = 0; __i < __x.size(); ++__i)
1015  __tmp[__i] = ::pow(__x[__i], __c);
1016  return __tmp;
1017 }
#define __c
Definition: schilyio.h:209
valarray< _Tp > pow(const valarray< _Tp > &__x, const valarray< _Tp > &__y)
Definition: _valarray.h:1001
size_t size() const
Definition: _valarray.h:164

◆ pow() [3/3]

template<class _Tp >
valarray<_Tp> pow ( const _Tp &  __c,
const valarray< _Tp > &  __x 
)
inline

Definition at line 1020 of file _valarray.h.

1020  {
1021  typedef typename valarray<_Tp>::_NoInit _NoInit;
1022  valarray<_Tp> __tmp(__x.size(), _NoInit());
1023  for (size_t __i = 0; __i < __x.size(); ++__i)
1024  __tmp[__i] = ::pow(__c, __x[__i]);
1025  return __tmp;
1026 }
#define __c
Definition: schilyio.h:209
valarray< _Tp > pow(const valarray< _Tp > &__x, const valarray< _Tp > &__y)
Definition: _valarray.h:1001
size_t size() const
Definition: _valarray.h:164

◆ sin()

template<class _Tp >
valarray<_Tp> sin ( const valarray< _Tp > &  __x)
inline

Definition at line 1029 of file _valarray.h.

1029  {
1030  typedef typename valarray<_Tp>::_NoInit _NoInit;
1031  valarray<_Tp> __tmp(__x.size(), _NoInit());
1032  for (size_t __i = 0; __i < __x.size(); ++__i)
1033  __tmp[__i] = ::sin(__x[__i]);
1034  return __tmp;
1035 }
valarray< _Tp > sin(const valarray< _Tp > &__x)
Definition: _valarray.h:1029
size_t size() const
Definition: _valarray.h:164

◆ sinh()

template<class _Tp >
valarray<_Tp> sinh ( const valarray< _Tp > &  __x)
inline

Definition at line 1038 of file _valarray.h.

1038  {
1039  typedef typename valarray<_Tp>::_NoInit _NoInit;
1040  valarray<_Tp> __tmp(__x.size(), _NoInit());
1041  for (size_t __i = 0; __i < __x.size(); ++__i)
1042  __tmp[__i] = ::sinh(__x[__i]);
1043  return __tmp;
1044 }
valarray< _Tp > sinh(const valarray< _Tp > &__x)
Definition: _valarray.h:1038
size_t size() const
Definition: _valarray.h:164

◆ sqrt()

template<class _Tp >
valarray<_Tp> sqrt ( const valarray< _Tp > &  __x)
inline

Definition at line 1047 of file _valarray.h.

1047  {
1048  typedef typename valarray<_Tp>::_NoInit _NoInit;
1049  valarray<_Tp> __tmp(__x.size(), _NoInit());
1050  for (size_t __i = 0; __i < __x.size(); ++__i)
1051  __tmp[__i] = ::sqrt(__x[__i]);
1052  return __tmp;
1053 }
valarray< _Tp > sqrt(const valarray< _Tp > &__x)
Definition: _valarray.h:1047
size_t size() const
Definition: _valarray.h:164

◆ tan()

template<class _Tp >
valarray<_Tp> tan ( const valarray< _Tp > &  __x)
inline

Definition at line 1056 of file _valarray.h.

1056  {
1057  typedef typename valarray<_Tp>::_NoInit _NoInit;
1058  valarray<_Tp> __tmp(__x.size(), _NoInit());
1059  for (size_t __i = 0; __i < __x.size(); ++__i)
1060  __tmp[__i] = ::tan(__x[__i]);
1061  return __tmp;
1062 }
valarray< _Tp > tan(const valarray< _Tp > &__x)
Definition: _valarray.h:1056
size_t size() const
Definition: _valarray.h:164

◆ tanh()

template<class _Tp >
valarray<_Tp> tanh ( const valarray< _Tp > &  __x)
inline

Definition at line 1065 of file _valarray.h.

1065  {
1066  typedef typename valarray<_Tp>::_NoInit _NoInit;
1067  valarray<_Tp> __tmp(__x.size(), _NoInit());
1068  for (size_t __i = 0; __i < __x.size(); ++__i)
1069  __tmp[__i] = ::tanh(__x[__i]);
1070  return __tmp;
1071 }
size_t size() const
Definition: _valarray.h:164
valarray< _Tp > tanh(const valarray< _Tp > &__x)
Definition: _valarray.h:1065