home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / valarray < prev    next >
Encoding:
Text File  |  1998-06-16  |  29.3 KB  |  940 lines
  1. // valarray standard header
  2.  
  3. #if     _MSC_VER > 1000
  4. #pragma once
  5. #endif
  6.  
  7. #ifndef _VALARRAY_
  8. #define _VALARRAY_
  9. #include <cstring>
  10. #include <xstddef>
  11.  
  12. #ifdef  _MSC_VER
  13. #pragma pack(push,8)
  14. #endif  /* _MSC_VER */
  15. _STD_BEGIN
  16. class gslice;
  17. class slice;
  18. template<class _Ty>
  19.     class gslice_array;
  20. template<class _Ty>
  21.     class indirect_array;
  22. template<class _Ty>
  23.     class mask_array;
  24. template<class _Ty>
  25.     class slice_array;
  26. template<class _Ty>
  27.     class valarray;
  28. typedef valarray<_Bool> _Boolarray;
  29. typedef valarray<size_t> _Sizarray;
  30.         // TEMPLATE CLASS valarray
  31. #define _VALOP(TYPE, LENGTH, RHS) \
  32.     valarray<TYPE> _Ans(LENGTH); \
  33.     for (size_t _I = 0; _I < _Ans.size(); ++_I) \
  34.         _Ans[_I] = RHS; \
  35.     return (_Ans)
  36. #define _VALGOP(RHS) \
  37.     for (size_t _I = 0; _I < size(); ++_I) \
  38.         _Ptr[_I] RHS; \
  39.     return (*this)
  40. #define _VALGOP2(RHS) \
  41.     for (size_t _I = 0; _I < _L.size(); ++_I) \
  42.         _L[_I] RHS; \
  43.     return (_L)
  44. template<class _Ty>
  45.     class valarray {
  46. public:
  47.     typedef _Ty value_type;
  48.     explicit valarray(size_t _N = 0)
  49.         {_Tidy(), _Res = _N, _Grow(_N); }
  50.     valarray(const _Ty& _X, size_t _N)
  51.         {_Tidy(), _Grow(_N, &_X); }
  52.     valarray(const _Ty *_S, size_t _N)
  53.         {_Tidy(), _Grow(_N, _S, 1); }
  54.     valarray(const valarray<_Ty>& _X)
  55.         {_Tidy(), _Grow(_X.size(), _X._Ptr, 1); }
  56.     valarray(const slice_array<_Ty>& _Sl)
  57.         {_Tidy();
  58.         *this = _Sl; }
  59.     valarray(const gslice_array<_Ty>& _Gs)
  60.         {_Tidy();
  61.         *this = _Gs; }
  62.     valarray(const mask_array<_Ty>& _Ma)
  63.         {_Tidy();
  64.         *this = _Ma; }
  65.     valarray(const indirect_array<_Ty>& _Ia)
  66.         {_Tidy();
  67.         *this = _Ia; }
  68.     ~valarray()
  69.         {_Tidy(true); }
  70.     valarray<_Ty>& operator=(const valarray<_Ty>& _R)
  71.         {if (this == &_R)
  72.             return (*this);
  73.         _Grow(_R.size(), 0, 0, true);
  74.         _VALGOP(= _R[_I]); }
  75.     valarray<_Ty>& operator=(const _Ty& _R)
  76.         {_VALGOP(= _R); }
  77.     void resize(size_t _N, const _Ty& _C = _Ty())
  78.         {_Grow(_N, &_C, 0, true); }
  79.     valarray<_Ty>& operator=(const slice_array<_Ty>& _Sl);
  80.     valarray<_Ty>& operator=(const gslice_array<_Ty>& _Gs);
  81.     valarray<_Ty>& operator=(const mask_array<_Ty>& _Ma);
  82.     valarray<_Ty>& operator=(const indirect_array<_Ty>& _Ia);
  83.     size_t size() const
  84.         {return (_Len); }
  85.     _Ty operator[](size_t _I) const
  86.         {return (_Ptr[_I]); } 
  87.     _Ty& operator[](size_t _I)
  88.         {return (_Ptr[_I]); }
  89.     valarray<_Ty> operator[](slice _Sl) const;
  90.     slice_array<_Ty> operator[](slice _Sl);
  91.     valarray<_Ty> operator[](const gslice& _Gs) const;
  92.     gslice_array<_Ty> operator[](const gslice& _Gs);
  93.     valarray<_Ty> operator[](
  94.         const _Boolarray& _Ba) const;
  95.     mask_array<_Ty> operator[](
  96.         const _Boolarray& _Ba);
  97.     valarray<_Ty> operator[](const _Sizarray& _Ia) const;
  98.     indirect_array<_Ty> operator[](const _Sizarray& _Ia);
  99.     _Ty sum() const
  100.         {_Ty _Sum = _Ptr[0];
  101.         for (size_t _I = 0; ++_I < size(); )
  102.             _Sum += _Ptr[_I];
  103.         return (_Sum); }
  104.     _Ty min() const
  105.         {_Ty _Min = _Ptr[0];
  106.         for (size_t _I = 0; ++_I < size(); )
  107.             if (_Ptr[_I] < _Min)
  108.                 _Min = _Ptr[_I];
  109.         return (_Min); }
  110.     _Ty max() const
  111.         {_Ty _Max = _Ptr[0];
  112.         for (size_t _I = 0; ++_I < size(); )
  113.             if (_Max < _Ptr[_I])
  114.                 _Max = _Ptr[_I];
  115.         return (_Max); }
  116.     valarray<_Ty> shift(int _N) const
  117.         {static _Ty _Def;
  118.         _VALOP(_Ty, size(),
  119.             0 < _N && size() - _I <= _N
  120.                 || _N < 0 && _I  < -_N
  121.                     ? _Def : _Ptr[_I + _N]); }
  122.     valarray<_Ty> cshift(int _N) const
  123.         {if (size() == 0)
  124.             ;
  125.         else if (_N < 0)
  126.             {if ((_N += size()) < 0)
  127.                 _N = size() - (-_N) % size(); }
  128.         else if (size() <= _N)
  129.             _N %= size();
  130.         _VALOP(_Ty, size(),
  131.             size() - _I <= _N
  132.                 ? _Ptr[_I - size() + _N] : _Ptr[_I + _N]); }
  133.     valarray<_Ty> apply(_Ty _F(_Ty)) const
  134.         {_VALOP(_Ty, size(), _F(_Ptr[_I])); }
  135.     valarray<_Ty> apply(_Ty _F(const _Ty&)) const
  136.         {_VALOP(_Ty, size(), _F(_Ptr[_I])); }
  137.     void free()
  138.         {_Tidy(true); }
  139. private:
  140.     void _Grow(size_t _N, const _Ty *_S = 0, size_t _D = 0,
  141.         bool _Trim = 0)
  142.         {size_t _Os = _Ptr == 0 ? 0 : _Res;
  143.         if (_N == 0)
  144.             {if (_Trim)
  145.                 _Tidy(true); }
  146.         else if (_N == _Os || _N < _Os && !_Trim)
  147.             ;
  148.         else
  149.             {size_t _I, _M = _Ptr == 0 && _N < _Res ? _Res : _N;
  150.             _Ty *_Np = new _Ty[_M];
  151.             if (_Np == 0)
  152.                 _Nomemory();
  153.             size_t _Nm = _N < _Len ? _N : _Len;
  154.             for (_I = 0; _I < _Nm; ++_I)
  155.                 _Np[_I] = _Ptr[_I];
  156.             if (_S != 0)
  157.                 for (; _I < _M; ++_I, _S += _D)
  158.                     _Np[_I] = *_S;
  159.             _Tidy(true), _Ptr = _Np, _Res = _M; }
  160.         _Len = _N; }
  161.     void _Tidy(bool _Constructed = 0)
  162.         {if (_Constructed && _Ptr != 0)
  163.             delete[] _Ptr;
  164.         _Len = 0, _Ptr = 0, _Res = 0; }
  165.      _Ty *_Ptr;
  166.     size_t _Len, _Res;
  167.     };
  168.         // valarray MEMBER TEMPLATE OPERATORS
  169. template<class _Ty> inline
  170.     valarray<_Ty> operator+(const valarray<_Ty>& _L)
  171.     {_VALOP(_Ty, _L.size(), +_L[_I]); }
  172. template<class _Ty> inline
  173.     valarray<_Ty> operator-(const valarray<_Ty>& _L)
  174.     {_VALOP(_Ty, _L.size(), -_L[_I]); }
  175. template<class _Ty> inline
  176.     valarray<_Ty> operator~(const valarray<_Ty>& _L)
  177.     {_VALOP(_Ty, _L.size(), ~_L[_I]); }
  178. template<class _Ty> inline
  179.     _Boolarray operator!(const valarray<_Ty>& _L)
  180.     {_VALOP(_Bool, _L.size(), !_L[_I]); }
  181. template<class _Ty> inline
  182.     valarray<_Ty>& operator*=(valarray<_Ty>& _L, const _Ty& _R)
  183.     {_VALGOP2(*= _R); }
  184. template<class _Ty> inline
  185.     valarray<_Ty>& operator/=(valarray<_Ty>& _L, const _Ty& _R)
  186.     {_VALGOP2(/= _R); }
  187. template<class _Ty> inline
  188.     valarray<_Ty>& operator%=(valarray<_Ty>& _L, const _Ty& _R)
  189.     {_VALGOP2(%= _R); }
  190. template<class _Ty> inline
  191.     valarray<_Ty>& operator+=(valarray<_Ty>& _L, const _Ty& _R)
  192.     {_VALGOP2(+= _R); }
  193. template<class _Ty> inline
  194.     valarray<_Ty>& operator-=(valarray<_Ty>& _L, const _Ty& _R)
  195.     {_VALGOP2(-= _R); }
  196. template<class _Ty> inline
  197.     valarray<_Ty>& operator^=(valarray<_Ty>& _L, const _Ty& _R)
  198.     {_VALGOP2(^= _R); }
  199. template<class _Ty> inline
  200.     valarray<_Ty>& operator&=(valarray<_Ty>& _L, const _Ty& _R)
  201.     {_VALGOP2(&= _R); }
  202. template<class _Ty> inline
  203.     valarray<_Ty>& operator|=(valarray<_Ty>& _L, const _Ty& _R)
  204.     {_VALGOP2(|= _R); }
  205. template<class _Ty> inline
  206.     valarray<_Ty>& operator<<=(valarray<_Ty>& _L, const _Ty& _R)
  207.     {_VALGOP2(<<= _R); }
  208. template<class _Ty> inline
  209.     valarray<_Ty>& operator>>=(valarray<_Ty>& _L, const _Ty& _R)
  210.     {_VALGOP2(>>= _R); }
  211. template<class _Ty> inline
  212.     valarray<_Ty>& operator*=(valarray<_Ty>& _L,
  213.         const valarray<_Ty>& _R)
  214.     {_VALGOP2(*= _R[_I]); }
  215. template<class _Ty> inline
  216.     valarray<_Ty>& operator/=(valarray<_Ty>& _L,
  217.         const valarray<_Ty>& _R)
  218.     {_VALGOP2(/= _R[_I]); }
  219. template<class _Ty> inline
  220.     valarray<_Ty>& operator%=(valarray<_Ty>& _L,
  221.         const valarray<_Ty>& _R)
  222.     {_VALGOP2(%= _R[_I]); }
  223. template<class _Ty> inline
  224.     valarray<_Ty>& operator+=(valarray<_Ty>& _L,
  225.         const valarray<_Ty>& _R)
  226.     {_VALGOP2(+= _R[_I]); }
  227. template<class _Ty> inline
  228.     valarray<_Ty>& operator-=(valarray<_Ty>& _L,
  229.         const valarray<_Ty>& _R)
  230.     {_VALGOP2(-= _R[_I]); }
  231. template<class _Ty> inline
  232.     valarray<_Ty>& operator^=(valarray<_Ty>& _L,
  233.         const valarray<_Ty>& _R)
  234.     {_VALGOP2(^= _R[_I]); }
  235. template<class _Ty> inline
  236.     valarray<_Ty>& operator|=(valarray<_Ty>& _L,
  237.         const valarray<_Ty>& _R)
  238.     {_VALGOP2(|= _R[_I]); }
  239. template<class _Ty> inline
  240.     valarray<_Ty>& operator&=(valarray<_Ty>& _L,
  241.         const valarray<_Ty>& _R)
  242.     {_VALGOP2(&= _R[_I]); }
  243. template<class _Ty> inline
  244.     valarray<_Ty>& operator<<=(valarray<_Ty>& _L,
  245.         const valarray<_Ty>& _R)
  246.     {_VALGOP2(<<= _R[_I]); }
  247. template<class _Ty> inline
  248.     valarray<_Ty>& operator>>=(valarray<_Ty>& _L,
  249.         const valarray<_Ty>& _R)
  250.     {_VALGOP2(>>= _R[_I]); }
  251.         // valarray TEMPLATE FUNCTIONS
  252. template<class _Ty> inline
  253.     valarray<_Ty> operator*(const valarray<_Ty>& _L,
  254.         const _Ty& _R)
  255.     {_VALOP(_Ty, _L.size(), _L[_I] * _R); }
  256. template<class _Ty> inline
  257.     valarray<_Ty> operator*(const _Ty& _L,
  258.         const valarray<_Ty>& _R)
  259.     {_VALOP(_Ty, _R.size(), _L * _R[_I]); }
  260. template<class _Ty> inline
  261.     valarray<_Ty> operator/(const valarray<_Ty>& _L,
  262.         const _Ty& _R)
  263.     {_VALOP(_Ty, _L.size(), _L[_I] / _R); }
  264. template<class _Ty> inline
  265.     valarray<_Ty> operator/(const _Ty& _L,
  266.         const valarray<_Ty>& _R)
  267.     {_VALOP(_Ty, _R.size(), _L / _R[_I]); }
  268. template<class _Ty> inline
  269.     valarray<_Ty> operator%(const valarray<_Ty>& _L,
  270.         const _Ty& _R)
  271.     {_VALOP(_Ty, _L.size(), _L[_I] % _R); }
  272. template<class _Ty> inline
  273.     valarray<_Ty> operator%(const _Ty& _L,
  274.         const valarray<_Ty>& _R)
  275.     {_VALOP(_Ty, _R.size(), _L % _R[_I]); }
  276. template<class _Ty> inline
  277.     valarray<_Ty> operator+(const valarray<_Ty>& _L,
  278.         const _Ty& _R)
  279.     {_VALOP(_Ty, _L.size(), _L[_I] + _R); }
  280. template<class _Ty> inline
  281.     valarray<_Ty> operator+(const _Ty& _L,
  282.         const valarray<_Ty>& _R)
  283.     {_VALOP(_Ty, _R.size(), _L + _R[_I]); }
  284. template<class _Ty> inline
  285.     valarray<_Ty> operator-(const valarray<_Ty>& _L,
  286.         const _Ty& _R)
  287.     {_VALOP(_Ty, _L.size(), _L[_I] - _R); }
  288. template<class _Ty> inline
  289.     valarray<_Ty> operator-(const _Ty& _L,
  290.         const valarray<_Ty>& _R)
  291.     {_VALOP(_Ty, _R.size(), _L - _R[_I]); }
  292. template<class _Ty> inline
  293.     valarray<_Ty> operator^(const valarray<_Ty>& _L,
  294.         const _Ty& _R)
  295.     {_VALOP(_Ty, _L.size(), _L[_I] ^ _R); }
  296. template<class _Ty> inline
  297.     valarray<_Ty> operator^(const _Ty& _L,
  298.         const valarray<_Ty>& _R)
  299.     {_VALOP(_Ty, _R.size(), _L ^ _R[_I]); }
  300. template<class _Ty> inline
  301.     valarray<_Ty> operator&(const valarray<_Ty>& _L,
  302.         const _Ty& _R)
  303.     {_VALOP(_Ty, _L.size(), _L[_I] & _R); }
  304. template<class _Ty> inline
  305.     valarray<_Ty> operator&(const _Ty& _L,
  306.         const valarray<_Ty>& _R)
  307.     {_VALOP(_Ty, _R.size(), _L & _R[_I]); }
  308. template<class _Ty> inline
  309.     valarray<_Ty> operator|(const valarray<_Ty>& _L,
  310.         const _Ty& _R)
  311.     {_VALOP(_Ty, _L.size(), _L[_I] | _R); }
  312. template<class _Ty> inline
  313.     valarray<_Ty> operator|(const _Ty& _L,
  314.         const valarray<_Ty>& _R)
  315.     {_VALOP(_Ty, _R.size(), _L | _R[_I]); }
  316. template<class _Ty> inline
  317.     valarray<_Ty> operator<<(const valarray<_Ty>& _L,
  318.         const _Ty& _R)
  319.     {_VALOP(_Ty, _L.size(), _L[_I] << _R); }
  320. template<class _Ty> inline
  321.     valarray<_Ty> operator<<(const _Ty& _L,
  322.         const valarray<_Ty>& _R)
  323.     {_VALOP(_Ty, _R.size(), _L << _R[_I]); }
  324. template<class _Ty> inline
  325.     valarray<_Ty> operator>>(const valarray<_Ty>& _L,
  326.         const _Ty& _R)
  327.     {_VALOP(_Ty, _L.size(), _L[_I] >> _R); }
  328. template<class _Ty> inline
  329.     valarray<_Ty> operator>>(const _Ty& _L,
  330.         const valarray<_Ty>& _R)
  331.     {_VALOP(_Ty, _R.size(), _L >> _R[_I]); }
  332. template<class _Ty> inline
  333.     _Boolarray operator&&(const valarray<_Ty>& _L,
  334.         const _Ty& _R)
  335.     {_VALOP(_Bool, _L.size(), _L[_I] && _R); }
  336. template<class _Ty> inline
  337.     _Boolarray operator&&(const _Ty& _L,
  338.         const valarray<_Ty>& _R)
  339.     {_VALOP(_Bool, _R.size(), _L && _R[_I]); }
  340. template<class _Ty> inline
  341.     _Boolarray operator||(const valarray<_Ty>& _L,
  342.         const _Ty& _R)
  343.     {_VALOP(_Bool, _L.size(), _L[_I] || _R); }
  344. template<class _Ty> inline
  345.     _Boolarray operator||(const _Ty& _L,
  346.         const valarray<_Ty>& _R)
  347.     {_VALOP(_Bool, _R.size(), _L || _R[_I]); }
  348. template<class _Ty> inline
  349.     valarray<_Ty> operator*(const valarray<_Ty>& _L,
  350.         const valarray<_Ty>& _R)
  351.     {_VALOP(_Ty, _L.size(), _L[_I] * _R[_I]); }
  352. template<class _Ty> inline
  353.     valarray<_Ty> operator/(const valarray<_Ty>& _L,
  354.         const valarray<_Ty>& _R)
  355.     {_VALOP(_Ty, _L.size(), _L[_I] / _R[_I]); }
  356. template<class _Ty> inline
  357.     valarray<_Ty> operator%(const valarray<_Ty>& _L,
  358.         const valarray<_Ty>& _R)
  359.     {_VALOP(_Ty, _L.size(), _L[_I] % _R[_I]); }
  360. template<class _Ty> inline
  361.     valarray<_Ty> operator+(const valarray<_Ty>& _L,
  362.         const valarray<_Ty>& _R)
  363.     {_VALOP(_Ty, _L.size(), _L[_I] + _R[_I]); }
  364. template<class _Ty> inline
  365.     valarray<_Ty> operator-(const valarray<_Ty>& _L,
  366.         const valarray<_Ty>& _R)
  367.     {_VALOP(_Ty, _L.size(), _L[_I] - _R[_I]); }
  368. template<class _Ty> inline
  369.     valarray<_Ty> operator^(const valarray<_Ty>& _L,
  370.         const valarray<_Ty>& _R)
  371.     {_VALOP(_Ty, _L.size(), _L[_I] ^ _R[_I]); }
  372. template<class _Ty> inline
  373.     valarray<_Ty> operator&(const valarray<_Ty>& _L,
  374.         const valarray<_Ty>& _R)
  375.     {_VALOP(_Ty, _L.size(), _L[_I] & _R[_I]); }
  376. template<class _Ty> inline
  377.     valarray<_Ty> operator|(const valarray<_Ty>& _L,
  378.         const valarray<_Ty>& _R)
  379.     {_VALOP(_Ty, _L.size(), _L[_I] | _R[_I]); }
  380. template<class _Ty> inline
  381.     valarray<_Ty> operator<<(const valarray<_Ty>& _L,
  382.         const valarray<_Ty>& _R)
  383.     {_VALOP(_Ty, _L.size(), _L[_I] << _R[_I]); }
  384. template<class _Ty> inline
  385.     valarray<_Ty> operator>>(const valarray<_Ty>& _L,
  386.         const valarray<_Ty>& _R)
  387.     {_VALOP(_Ty, _L.size(), _L[_I] >> _R[_I]); }
  388. template<class _Ty> inline
  389.     _Boolarray operator&&(const valarray<_Ty>& _L,
  390.         const valarray<_Ty>& _R)
  391.     {_VALOP(_Bool, _L.size(), _L[_I] && _R[_I]); }
  392. template<class _Ty> inline
  393.     _Boolarray operator||(const valarray<_Ty>& _L,
  394.         const valarray<_Ty>& _R)
  395.     {_VALOP(_Bool, _L.size(), _L[_I] || _R[_I]); }
  396. template<class _Ty> inline
  397.     _Boolarray operator==(const valarray<_Ty>& _L,
  398.         const _Ty& _R)
  399.     {_VALOP(_Bool, _L.size(), _L[_I] == _R); }
  400. template<class _Ty> inline
  401.     _Boolarray operator==(const _Ty& _L,
  402.         const valarray<_Ty>& _R)
  403.     {_VALOP(_Bool, _R.size(), _L == _R[_I]); }
  404. template<class _Ty> inline
  405.     _Boolarray operator==(const valarray<_Ty>& _L,
  406.         const valarray<_Ty>& _R)
  407.     {_VALOP(_Bool, _L.size(), _L[_I] == _R[_I]); }
  408. template<class _Ty> inline
  409.     _Boolarray operator!=(const valarray<_Ty>& _L,
  410.         const _Ty& _R)
  411.     {_VALOP(_Bool, _L.size(), _L[_I] != _R); }
  412. template<class _Ty> inline
  413.     _Boolarray operator!=(const _Ty& _L,
  414.         const valarray<_Ty>& _R)
  415.     {_VALOP(_Bool, _R.size(), _L != _R[_I]); }
  416. template<class _Ty> inline
  417.     _Boolarray operator!=(const valarray<_Ty>& _L,
  418.         const valarray<_Ty>& _R)
  419.     {_VALOP(_Bool, _L.size(), _L[_I] != _R[_I]); }
  420. template<class _Ty> inline
  421.     _Boolarray operator<(const valarray<_Ty>& _L,
  422.         const _Ty& _R)
  423.     {_VALOP(_Bool, _L.size(), _L[_I] < _R); }
  424. template<class _Ty> inline
  425.     _Boolarray operator<(const _Ty& _L,
  426.         const valarray<_Ty>& _R)
  427.     {_VALOP(_Bool, _R.size(), _L < _R[_I]); }
  428. template<class _Ty> inline
  429.     _Boolarray operator<(const valarray<_Ty>& _L,
  430.         const valarray<_Ty>& _R)
  431.     {_VALOP(_Bool, _L.size(), _L[_I] < _R[_I]); }
  432. template<class _Ty> inline
  433.     _Boolarray operator>(const valarray<_Ty>& _L,
  434.         const _Ty& _R)
  435.     {_VALOP(_Bool, _L.size(), _L[_I] > _R); }
  436. template<class _Ty> inline
  437.     _Boolarray operator>(const _Ty& _L,
  438.         const valarray<_Ty>& _R)
  439.     {_VALOP(_Bool, _R.size(), _L > _R[_I]); }
  440. template<class _Ty> inline
  441.     _Boolarray operator>(const valarray<_Ty>& _L,
  442.         const valarray<_Ty>& _R)
  443.     {_VALOP(_Bool, _L.size(), _L[_I] > _R[_I]); }
  444. template<class _Ty> inline
  445.     _Boolarray operator<=(const valarray<_Ty>& _L,
  446.         const _Ty& _R)
  447.     {_VALOP(_Bool, _L.size(), _L[_I] <= _R); }
  448. template<class _Ty> inline
  449.     _Boolarray operator<=(const _Ty& _L,
  450.         const valarray<_Ty>& _R)
  451.     {_VALOP(_Bool, _R.size(), _L <= _R[_I]); }
  452. template<class _Ty> inline
  453.     _Boolarray operator<=(const valarray<_Ty>& _L,
  454.         const valarray<_Ty>& _R)
  455.     {_VALOP(_Bool, _L.size(), _L[_I] <= _R[_I]); }
  456. template<class _Ty> inline
  457.     _Boolarray operator>=(const valarray<_Ty>& _L,
  458.         const _Ty& _R)
  459.     {_VALOP(_Bool, _L.size(), _L[_I] >= _R); }
  460. template<class _Ty> inline
  461.     _Boolarray operator>=(const _Ty& _L,
  462.         const valarray<_Ty>& _R)
  463.     {_VALOP(_Bool, _R.size(), _L >= _R[_I]); }
  464. template<class _Ty> inline
  465.     _Boolarray operator>=(const valarray<_Ty>& _L,
  466.         const valarray<_Ty>& _R)
  467.     {_VALOP(_Bool, _L.size(), _L[_I] >= _R[_I]); }
  468. template<class _Ty> inline
  469.     valarray<_Ty> abs(const valarray<_Ty>& _X)
  470.     {_VALOP(_Ty, _X.size(), ::abs(_X[_I])); }
  471. template<class _Ty> inline
  472.     valarray<_Ty> acos(const valarray<_Ty>& _X)
  473.     {_VALOP(_Ty, _X.size(), ::acos(_X[_I])); }
  474. template<class _Ty> inline
  475.     valarray<_Ty> asin(const valarray<_Ty>& _X)
  476.     {_VALOP(_Ty, _X.size(), ::asin(_X[_I])); }
  477. template<class _Ty> inline
  478.     valarray<_Ty> atan(const valarray<_Ty>& _X)
  479.     {_VALOP(_Ty, _X.size(), ::atan(_X[_I])); }
  480. template<class _Ty> inline
  481.     valarray<_Ty> atan2(const valarray<_Ty>& _X,
  482.         const valarray<_Ty>& _Y)
  483.     {_VALOP(_Ty, _X.size(), ::atan2(_X[_I], _Y[_I])); }
  484. template<class _Ty> inline
  485.     valarray<_Ty> atan2(const valarray<_Ty>& _X, const _Ty& _Y)
  486.     {_VALOP(_Ty, _X.size(), ::atan2(_X[_I], _Y)); }
  487. template<class _Ty> inline
  488.     valarray<_Ty> atan2(const _Ty& _X, const valarray<_Ty>& _Y)
  489.     {_VALOP(_Ty, _Y.size(), ::atan2(_X, _Y[_I])); }
  490. template<class _Ty> inline
  491.     valarray<_Ty> cos(const valarray<_Ty>& _X)
  492.     {_VALOP(_Ty, _X.size(), ::cos(_X[_I])); }
  493. template<class _Ty> inline
  494.     valarray<_Ty> cosh(const valarray<_Ty>& _X)
  495.     {_VALOP(_Ty, _X.size(), ::cosh(_X[_I])); }
  496. template<class _Ty> inline
  497.     valarray<_Ty> exp(const valarray<_Ty>& _X)
  498.     {_VALOP(_Ty, _X.size(), ::exp(_X[_I])); }
  499. template<class _Ty> inline
  500.     valarray<_Ty> log(const valarray<_Ty>& _X)
  501.     {_VALOP(_Ty, _X.size(), ::log(_X[_I])); }
  502. template<class _Ty> inline
  503.     valarray<_Ty> log10(const valarray<_Ty>& _X)
  504.     {_VALOP(_Ty, _X.size(), ::log10(_X[_I])); }
  505. template<class _Ty> inline
  506.     valarray<_Ty> pow(const valarray<_Ty>& _X,
  507.         const valarray<_Ty>& _Y)
  508.     {_VALOP(_Ty, _X.size(), ::pow(_X[_I], _Y[_I])); }
  509. template<class _Ty> inline
  510.     valarray<_Ty> pow(const valarray<_Ty>& _X, const _Ty& _Y)
  511.     {_VALOP(_Ty, _X.size(), ::pow(_X[_I], _Y)); }
  512. template<class _Ty> inline
  513.     valarray<_Ty> pow(const _Ty& _X, const valarray<_Ty>& _Y)
  514.     {_VALOP(_Ty, _Y.size(), ::pow(_X, _Y[_I])); }
  515. template<class _Ty> inline
  516.     valarray<_Ty> sin(const valarray<_Ty>& _X)
  517.     {_VALOP(_Ty, _X.size(), ::sin(_X[_I])); }
  518. template<class _Ty> inline
  519.     valarray<_Ty> sinh(const valarray<_Ty>& _X)
  520.     {_VALOP(_Ty, _X.size(), ::sinh(_X[_I])); }
  521. template<class _Ty> inline
  522.     valarray<_Ty> sqrt(const valarray<_Ty>& _X)
  523.     {_VALOP(_Ty, _X.size(), ::sqrt(_X[_I])); }
  524. template<class _Ty> inline
  525.     valarray<_Ty> tan(const valarray<_Ty>& _X)
  526.     {_VALOP(_Ty, _X.size(), ::tan(_X[_I])); }
  527. template<class _Ty> inline
  528.     valarray<_Ty> tanh(const valarray<_Ty>& _X)
  529.     {_VALOP(_Ty, _X.size(), ::tanh(_X[_I])); }
  530.         // CLASS slice
  531. class slice {
  532. public:
  533.     slice()
  534.         : _Start(0), _Len(0), _Stride(0) {}
  535.     slice(size_t _S, size_t _L, size_t _D)
  536.         : _Start(_S), _Len(_L), _Stride(_D) {}
  537.     size_t start() const
  538.         {return (_Start); }
  539.     size_t size() const
  540.         {return (_Len); }
  541.     size_t stride() const
  542.         {return (_Stride); }
  543. protected:
  544.     size_t _Start, _Len, _Stride;
  545.     };
  546.         // TEMPLATE CLASS slice_array
  547. #define _SLOP(RHS) \
  548.     size_t _N = _Start; \
  549.     for (size_t _I = 0; _I < _Len; ++_I, _N += _Stride) \
  550.         _Ptr[_N] RHS;
  551. #define _SLOP2(RHS) \
  552.     size_t _N = _L.start(); \
  553.     for (size_t _I = 0; _I < _L.size(); \
  554.         ++_I, _N += _L.stride()) \
  555.         _L._Data(_N) RHS;
  556. template<class _Ty>
  557.     class slice_array : public slice {
  558. public:
  559.     typedef _Ty value_type;
  560.     void operator=(const valarray<_Ty>& _R) const
  561.         {_SLOP(= _R[_I]); }
  562.     void operator=(const _Ty& _R)
  563.         {_SLOP(= _R); }
  564.     _Ty& _Data(size_t _I) const
  565.         {return (_Ptr[_I]); }
  566. private:
  567.     friend class valarray<_Ty>;
  568.     slice_array(const slice& _Sl, _Ty *_Pd)
  569.         : slice(_Sl), _Ptr(_Pd) {}
  570.     _Ty *_Ptr;
  571.     };
  572.         // slice_array MEMBER TEMPLATE OPERATORS
  573. template<class _Ty> inline
  574.     void operator*=(const slice_array<_Ty>& _L,
  575.         const valarray<_Ty>& _R)
  576.     {_SLOP2(*= _R[_I]); }
  577. template<class _Ty> inline
  578.     void operator/=(const slice_array<_Ty>& _L,
  579.         const valarray<_Ty>& _R)
  580.     {_SLOP2(/= _R[_I]); }
  581. template<class _Ty> inline
  582.     void operator%=(const slice_array<_Ty>& _L,
  583.         const valarray<_Ty>& _R)
  584.     {_SLOP2(%= _R[_I]); }
  585. template<class _Ty> inline
  586.     void operator+=(const slice_array<_Ty>& _L,
  587.         const valarray<_Ty>& _R)
  588.     {_SLOP2(+= _R[_I]); }
  589. template<class _Ty> inline
  590.     void operator-=(const slice_array<_Ty>& _L,
  591.         const valarray<_Ty>& _R)
  592.     {_SLOP2(-= _R[_I]); }
  593. template<class _Ty> inline
  594.     void operator^=(const slice_array<_Ty>& _L,
  595.         const valarray<_Ty>& _R)
  596.     {_SLOP2(^= _R[_I]); }
  597. template<class _Ty> inline
  598.     void operator&=(const slice_array<_Ty>& _L,
  599.         const valarray<_Ty>& _R)
  600.     {_SLOP2(&= _R[_I]); }
  601. template<class _Ty> inline
  602.     void operator|=(const slice_array<_Ty>& _L,
  603.         const valarray<_Ty>& _R)
  604.     {_SLOP2(|= _R[_I]); }
  605. template<class _Ty> inline
  606.     void operator<<=(const slice_array<_Ty>& _L,
  607.         const valarray<_Ty>& _R)
  608.     {_SLOP2(<<= _R[_I]); }
  609. template<class _Ty> inline
  610.     void operator>>=(const slice_array<_Ty>& _L,
  611.         const valarray<_Ty>& _R)
  612.     {_SLOP2(>>= _R[_I]); }
  613.         // CLASS gslice
  614. class gslice {
  615. public:
  616.     gslice()
  617.         : _Start(0) {}
  618.     gslice(size_t _S, const _Sizarray& _L,
  619.         const _Sizarray& _D)
  620.         : _Start(_S), _Len(_L), _Stride(_D) {}
  621.     size_t start() const
  622.         {return (_Start); }
  623.     _Sizarray size() const
  624.         {return (_Len); }
  625.     _Sizarray stride() const
  626.         {return (_Stride); }
  627.     size_t _Nslice() const
  628.         {return (_Len.size()); }
  629.     size_t _Off(_Sizarray& _Idx) const
  630.         {size_t _I, _K = _Start;
  631.         for (_I = 0; _I < _Idx.size(); ++_I)
  632.             _K += _Idx[_I] * _Stride[_I];
  633.         while (0 < _I--)
  634.             if (++_Idx[_I] < _Len[_I])
  635.                 break;
  636.             else
  637.                 _Idx[_I] = 0;
  638.         return (_K); }
  639.     size_t _Totlen() const
  640.         {if (_Len.size() == 0)
  641.             return (0);
  642.         size_t _L = _Len[0];
  643.         for (size_t _I = 0; ++_I < _Len.size(); )
  644.             _L *= _Len[_I];
  645.         return (_L); }
  646. private:
  647.     size_t _Start;
  648.     _Sizarray _Len;
  649.     _Sizarray _Stride;
  650.     };
  651.         // TEMPLATE CLASS gslice_array
  652. #define _GSLOP(RHS) \
  653.     _Sizarray _Idx((size_t)0, _Nslice()); \
  654.     size_t _N = _Totlen(); \
  655.     for (size_t _I = 0; _I < _N; ++_I) \
  656.         _Ptr[_Off(_Idx)] RHS;
  657. #define _GSLOP2(RHS) \
  658.     _Sizarray _Idx((size_t)0, _L._Nslice()); \
  659.     size_t _N = _L._Totlen(); \
  660.     for (size_t _I = 0; _I < _N; ++_I) \
  661.         _L._Data(_L._Off(_Idx)) RHS;
  662. template<class _Ty>
  663.     class gslice_array : public gslice {
  664. public:
  665.     typedef _Ty value_type;
  666.     void operator=(const valarray<_Ty>& _R) const
  667.         {_GSLOP(= _R[_I]); }
  668.     void operator=(const _Ty& _R)
  669.         {_GSLOP(= _R); }
  670.     _Ty& _Data(size_t _I) const
  671.         {return (_Ptr[_I]); }
  672. private:
  673.     friend class valarray<_Ty>;
  674.     gslice_array(const gslice& _Gs, _Ty *_Pd)
  675.         : gslice(_Gs), _Ptr(_Pd) {}
  676.     _Ty *_Ptr;
  677.     };
  678.         // gslice_array MEMBER TEMPLATE OPERATORS
  679. template<class _Ty> inline
  680.     void operator*=(const gslice_array<_Ty>& _L,
  681.         const valarray<_Ty>& _R)
  682.     {_GSLOP2(*= _R[_I]); }
  683. template<class _Ty> inline
  684.     void operator/=(const gslice_array<_Ty>& _L,
  685.         const valarray<_Ty>& _R)
  686.     {_GSLOP2(/= _R[_I]); }
  687. template<class _Ty> inline
  688.     void operator%=(const gslice_array<_Ty>& _L,
  689.         const valarray<_Ty>& _R)
  690.     {_GSLOP2(%= _R[_I]); }
  691. template<class _Ty> inline
  692.     void operator+=(const gslice_array<_Ty>& _L,
  693.         const valarray<_Ty>& _R)
  694.     {_GSLOP2(+= _R[_I]); }
  695. template<class _Ty> inline
  696.     void operator-=(const gslice_array<_Ty>& _L,
  697.         const valarray<_Ty>& _R)
  698.     {_GSLOP2(-= _R[_I]); }
  699. template<class _Ty> inline
  700.     void operator^=(const gslice_array<_Ty>& _L,
  701.         const valarray<_Ty>& _R)
  702.     {_GSLOP2(^= _R[_I]); }
  703. template<class _Ty> inline
  704.     void operator&=(const gslice_array<_Ty>& _L,
  705.         const valarray<_Ty>& _R)
  706.     {_GSLOP2(&= _R[_I]); }
  707. template<class _Ty> inline
  708.     void operator|=(const gslice_array<_Ty>& _L,
  709.         const valarray<_Ty>& _R)
  710.     {_GSLOP2(|= _R[_I]); }
  711. template<class _Ty> inline
  712.     void operator<<=(const gslice_array<_Ty>& _L,
  713.         const valarray<_Ty>& _R)
  714.     {_GSLOP2(<<= _R[_I]); }
  715. template<class _Ty> inline
  716.     void operator>>=(const gslice_array<_Ty>& _L,
  717.         const valarray<_Ty>& _R)
  718.     {_GSLOP2(>>= _R[_I]); }
  719.         // TEMPLATE CLASS mask_array
  720. #define _MOP(RHS) \
  721.     size_t _N = 0; \
  722.     size_t _M = _Totlen(); \
  723.     for (size_t _I = 0; _I < _M; ++_N) \
  724.         if (_Mask(_N)) \
  725.             _Ptr[_N] RHS, ++_I;
  726. #define _MOP2(RHS) \
  727.     size_t _N = 0; \
  728.     size_t _M = _L._Totlen(); \
  729.     for (size_t _I = 0; _I < _M; ++_N) \
  730.         if (_L._Mask(_N)) \
  731.             _L._Data(_N) RHS, ++_I;
  732. template<class _Ty>
  733.     class mask_array {
  734. public:
  735.     typedef _Ty value_type;
  736.     void operator=(const valarray<_Ty>& _R)
  737.         {_MOP(= _R[_I]); }
  738.     void operator=(const _Ty& _R)
  739.         {_MOP(= _R); }
  740.     _Ty& _Data(size_t _I) const
  741.         {return (_Ptr[_I]); }
  742.     bool _Mask(size_t _I) const
  743.         {return (_Marr[_I]); }
  744.     size_t _Totlen() const
  745.         {size_t _N = 0;
  746.         for (size_t _I = 0; _I < _Marr.size(); ++_I)
  747.             if (_Marr[_I])
  748.                 ++_N;
  749.         return (_N); }
  750. private:
  751.     friend class valarray<_Ty>;
  752.     mask_array(const _Boolarray& _Ma, _Ty *_Pd)
  753.         : _Marr(_Ma), _Ptr(_Pd) {}
  754.     _Boolarray _Marr;
  755.     _Ty *_Ptr;
  756.     };
  757.         // mask_array MEMBER TEMPLATE OPERATORS
  758. template<class _Ty> inline
  759.     void operator*=(const mask_array<_Ty>& _L,
  760.         const valarray<_Ty>& _R)
  761.     {_MOP2(*= _R[_I]); }
  762. template<class _Ty> inline
  763.     void operator/=(const mask_array<_Ty>& _L,
  764.         const valarray<_Ty>& _R)
  765.     {_MOP2(/= _R[_I]); }
  766. template<class _Ty> inline
  767.     void operator%=(const mask_array<_Ty>& _L,
  768.         const valarray<_Ty>& _R)
  769.     {_MOP2(%= _R[_I]); }
  770. template<class _Ty> inline
  771.     void operator+=(const mask_array<_Ty>& _L,
  772.         const valarray<_Ty>& _R)
  773.     {_MOP2(+= _R[_I]); }
  774. template<class _Ty> inline
  775.     void operator-=(const mask_array<_Ty>& _L,
  776.         const valarray<_Ty>& _R)
  777.     {_MOP2(-= _R[_I]); }
  778. template<class _Ty> inline
  779.     void operator^=(const mask_array<_Ty>& _L,
  780.         const valarray<_Ty>& _R)
  781.     {_MOP2(^= _R[_I]); }
  782. template<class _Ty> inline
  783.     void operator&=(const mask_array<_Ty>& _L,
  784.         const valarray<_Ty>& _R)
  785.     {_MOP2(&= _R[_I]); }
  786. template<class _Ty> inline
  787.     void operator|=(const mask_array<_Ty>& _L,
  788.         const valarray<_Ty>& _R)
  789.     {_MOP2(|= _R[_I]); }
  790. template<class _Ty> inline
  791.     void operator<<=(const mask_array<_Ty>& _L,
  792.         const valarray<_Ty>& _R)
  793.     {_MOP2(<<= _R[_I]); }
  794. template<class _Ty> inline
  795.     void operator>>=(const mask_array<_Ty>& _L,
  796.         const valarray<_Ty>& _R)
  797.     {_MOP2(>>= _R[_I]); }
  798.         // TEMPLATE CLASS indirect_array
  799. #define _IOP(RHS) \
  800.     size_t _L = _Totlen(); \
  801.     for (size_t _I = 0; _I < _L; ++_I) \
  802.         _Ptr[_Indir(_I)] RHS;
  803. #define _IOP2(RHS) \
  804.     size_t _N = _L._Totlen(); \
  805.     for (size_t _I = 0; _I < _N; ++_I) \
  806.         _L._Data(_L._Indir(_I)) RHS;
  807. template<class _Ty>
  808.     class indirect_array {
  809. public:
  810.     typedef _Ty value_type;
  811.     void operator=(const valarray<_Ty>& _R) const
  812.         {_IOP(= _R[_I]); }
  813.     void operator=(const _Ty& _R)
  814.         {_IOP(= _R); }
  815.     _Ty& _Data(size_t _I) const
  816.         {return (_Ptr[_I]); }
  817.     size_t _Indir(size_t _I) const
  818.         {return (_Iarr[_I]); }
  819.     size_t _Totlen() const
  820.         {return (_Iarr.size()); }
  821. private:
  822.     friend class valarray<_Ty>;
  823.     indirect_array(const _Sizarray& _Ia, _Ty *_Pd)
  824.         : _Iarr(_Ia), _Ptr(_Pd) {}
  825.     _Sizarray _Iarr;
  826.     _Ty *_Ptr;
  827.     };
  828.         // indirect_array MEMBER TEMPLATE OPERATORS
  829. template<class _Ty> inline
  830.     void operator*=(const indirect_array<_Ty>& _L,
  831.         const valarray<_Ty>& _R)
  832.     {_IOP2(*= _R[_I]); }
  833. template<class _Ty> inline
  834.     void operator/=(const indirect_array<_Ty>& _L,
  835.         const valarray<_Ty>& _R)
  836.     {_IOP2(/= _R[_I]); }
  837. template<class _Ty> inline
  838.     void operator%=(const indirect_array<_Ty>& _L,
  839.         const valarray<_Ty>& _R)
  840.     {_IOP2(%= _R[_I]); }
  841. template<class _Ty> inline
  842.     void operator+=(const indirect_array<_Ty>& _L,
  843.         const valarray<_Ty>& _R)
  844.     {_IOP2(+= _R[_I]); }
  845. template<class _Ty> inline
  846.     void operator-=(const indirect_array<_Ty>& _L,
  847.         const valarray<_Ty>& _R)
  848.     {_IOP2(-= _R[_I]); }
  849. template<class _Ty> inline
  850.     void operator^=(const indirect_array<_Ty>& _L,
  851.         const valarray<_Ty>& _R)
  852.     {_IOP2(^= _R[_I]); }
  853. template<class _Ty> inline
  854.     void operator&=(const indirect_array<_Ty>& _L,
  855.         const valarray<_Ty>& _R)
  856.     {_IOP2(&= _R[_I]); }
  857. template<class _Ty> inline
  858.     void operator|=(const indirect_array<_Ty>& _L,
  859.         const valarray<_Ty>& _R)
  860.     {_IOP2(|= _R[_I]); }
  861. template<class _Ty> inline
  862.     void operator<<=(const indirect_array<_Ty>& _L,
  863.         const valarray<_Ty>& _R)
  864.     {_IOP2(<<= _R[_I]); }
  865. template<class _Ty> inline
  866.     void operator>>=(const indirect_array<_Ty>& _L,
  867.         const valarray<_Ty>& _R)
  868.     {_IOP2(>>= _R[_I]); }
  869.         // slice_array TEMPLATE FUNCTIONS
  870. template<class _Ty> inline
  871.     valarray<_Ty>& valarray<_Ty>::operator=(
  872.         const slice_array<_Ty>& _Sl)
  873.     {_Grow(_Sl.size(), &_Sl._Data(_Sl.start()),
  874.         _Sl.stride(), true);
  875.     return (*this); }
  876. template<class _Ty> inline
  877.     valarray<_Ty> valarray<_Ty>::operator[](slice _Sl) const
  878.     {return (valarray<_Ty>(slice_array<_Ty>(_Sl, _Ptr))); }
  879. template<class _Ty> inline
  880.     slice_array<_Ty> valarray<_Ty>::operator[](slice _Sl)
  881.     {return (slice_array<_Ty>(_Sl, _Ptr)); }
  882.         // gslice_array TEMPLATE FUNCTIONS
  883. template<class _Ty> inline
  884.     valarray<_Ty>& valarray<_Ty>::operator=(
  885.         const gslice_array<_Ty>& _Gs)
  886.     {_Grow(_Gs._Totlen(), 0, 0, true);
  887.     _Sizarray _Idx((size_t)0, _Gs._Nslice());
  888.     _VALGOP(= _Gs._Data(_Gs._Off(_Idx))); }
  889. template<class _Ty> inline
  890.     valarray<_Ty> valarray<_Ty>::operator[](
  891.         const gslice& _Gs) const
  892.     {return (valarray<_Ty>(gslice_array<_Ty>(_Gs, _Ptr))); }
  893. template<class _Ty> inline
  894.     gslice_array<_Ty> valarray<_Ty>::operator[](
  895.         const gslice& _Gs)
  896.     {return (gslice_array<_Ty>(_Gs, _Ptr)); }
  897.         // mask_array TEMPLATE FUNCTIONS
  898. template<class _Ty> inline
  899.     valarray<_Ty>& valarray<_Ty>::operator=(
  900.         const mask_array<_Ty>& _Ma)
  901.     {_Grow(_Ma._Totlen(), 0, 0, true);
  902.     size_t _N = 0;
  903.     for (size_t _I = 0; _I < size(); ++_N)
  904.         if (_Ma._Mask(_N))
  905.             _Ptr[_I++] = _Ma._Data(_N);
  906.     return (*this); }
  907. template<class _Ty> inline
  908.     valarray<_Ty> valarray<_Ty>::operator[](
  909.         const _Boolarray& _Ba) const
  910.     {return (valarray<_Ty>(mask_array<_Ty>(_Ba, _Ptr))); }
  911. template<class _Ty> inline
  912.     mask_array<_Ty> valarray<_Ty>::operator[](
  913.         const _Boolarray& _Ba)
  914.     {return (mask_array<_Ty>(_Ba, _Ptr)); }
  915.         // indirect_array TEMPLATE FUNCTIONS
  916. template<class _Ty> inline
  917.     valarray<_Ty>& valarray<_Ty>::operator=(
  918.         const indirect_array<_Ty>& _Ia)
  919.     {_Grow(_Ia._Totlen(), 0, 0, true);
  920.     _VALGOP(= _Ia._Data(_Ia._Indir(_I))); }
  921. template<class _Ty> inline
  922.     valarray<_Ty> valarray<_Ty>::operator[](
  923.         const _Sizarray& _Ia) const
  924.     {return (valarray<_Ty>(indirect_array<_Ty>(_Ia, _Ptr))); }
  925. template<class _Ty> inline
  926.     indirect_array<_Ty> valarray<_Ty>::operator[](
  927.         const _Sizarray& _Ia)
  928.     {return (indirect_array<_Ty>(_Ia, _Ptr)); }
  929. _STD_END
  930. #ifdef  _MSC_VER
  931. #pragma pack(pop)
  932. #endif  /* _MSC_VER */
  933.  
  934. #endif /* _VALARRAY_ */
  935.  
  936. /*
  937.  * Copyright (c) 1995 by P.J. Plauger.  ALL RIGHTS RESERVED. 
  938.  * Consult your license regarding permissions and restrictions.
  939.  */
  940.