reactos/include/c++/stlport/stl/_valarray.c

   1 /*
   2  *
   3  *
   4  * Copyright (c) 1994
   5  * Hewlett-Packard Company
   6  *
   7  * Copyright (c) 1996,1997
   8  * Silicon Graphics Computer Systems, Inc.
   9  *
  10  * Copyright (c) 1997
  11  * Moscow Center for SPARC Technology
  12  *
  13  * Copyright (c) 1999
  14  * Boris Fomitchev
  15  *
  16  * This material is provided "as is", with absolutely no warranty expressed
  17  * or implied. Any use is at your own risk.
  18  *
  19  * Permission to use or copy this software for any purpose is hereby granted
  20  * without fee, provided the above notices are retained on all copies.
  21  * Permission to modify the code and to distribute modified code is granted,
  22  * provided the above notices are retained, and a notice that the code was
  23  * modified is included with the above copyright notice.
  24  *
  25  */
  26 #ifndef _STLP_VALARRAY_C
  27 #define _STLP_VALARRAY_C
  28
  29 #ifndef _STLP_VALARRAY_H
  30 # include <stl/_valarray.h>
  31 #endif
  32
  33 _STLP_BEGIN_NAMESPACE
  34
  35 template <class _Tp>
  36 _Valarray_bool valarray<_Tp>:: operator!() const {
  37   _Valarray_bool __tmp(this->size(), _Valarray_bool::_NoInit());
  38   for (size_t __i = 0; __i < this->size(); ++__i)
  39     __tmp[__i] = !(*this)[__i];
  40   return __tmp;
  41 }
  42
  43 // Behavior is undefined if __x and *this have different sizes
  44 template <class _Tp>
  45 valarray<_Tp>& valarray<_Tp>::operator=(const slice_array<_Tp>& __x) {
  46   _STLP_ASSERT(__x._M_slice.size() == this->size())
  47   size_t __index = __x._M_slice.start();
  48   for (size_t __i = 0;
  49        __i < __x._M_slice.size();
  50        ++__i, __index += __x._M_slice.stride())
  51     (*this)[__i] = __x._M_array[__index];
  52   return *this;
  53 }
  54
  55 template <class _Tp>
  56 valarray<_Tp> valarray<_Tp>::operator[](slice __slice) const {
  57   valarray<_Tp> __tmp(__slice.size(), _NoInit());
  58   size_t __index = __slice.start();
  59   for (size_t __i = 0;
  60        __i < __slice.size();
  61        ++__i, __index += __slice.stride())
  62     __tmp[__i] = (*this)[__index];
  63   return __tmp;
  64 }
  65
  66 template <class _Size>
  67 bool _Gslice_Iter_tmpl<_Size>::_M_incr() {
  68   size_t __dim = _M_indices.size() - 1;
  69   ++_M_step;
  70   for (;;) {
  71     _M_1d_idx += _M_gslice._M_strides[__dim];
  72     if (++_M_indices[__dim] != _M_gslice._M_lengths[__dim])
  73       return true;
  74     else if (__dim != 0) {
  75       _M_1d_idx -= _M_gslice._M_strides[__dim] * _M_gslice._M_lengths[__dim];
  76       _M_indices[__dim] = 0;
  77       --__dim;
  78     }
  79     else
  80       return false;
  81   }
  82 }
  83
  84 // Behavior is undefined if __x and *this have different sizes, or if
  85 // __x was constructed from a degenerate gslice.
  86 template <class _Tp>
  87 valarray<_Tp>& valarray<_Tp>::operator=(const gslice_array<_Tp>& __x) {
  88   if (this->size() != 0) {
  89     _Gslice_Iter __i(__x._M_gslice);
  90     do
  91       (*this)[__i._M_step] = __x._M_array[__i._M_1d_idx];
  92     while(__i._M_incr());
  93   }
  94   return *this;
  95 }
  96
  97 template <class _Tp>
  98 valarray<_Tp> valarray<_Tp>::operator[](const gslice& __slice) const {
  99   valarray<_Tp> __tmp(__slice._M_size(), _NoInit());
 100   if (__tmp.size() != 0) {
 101     _Gslice_Iter __i(__slice);
 102     do __tmp[__i._M_step] = (*this)[__i._M_1d_idx]; while(__i._M_incr());
 103   }
 104   return __tmp;
 105 }
 106
 107 template <class _Tp>
 108 valarray<_Tp> valarray<_Tp>::operator[](const _Valarray_bool& __mask) const {
 109   size_t _p_size = 0;
 110   {
 111     for (size_t __i = 0; __i < __mask.size(); ++__i)
 112       if (__mask[__i]) ++_p_size;
 113   }
 114
 115   valarray<_Tp> __tmp(_p_size, _NoInit());
 116   size_t __idx = 0;
 117   {
 118     for (size_t __i = 0; __i < __mask.size(); ++__i)
 119       if (__mask[__i]) __tmp[__idx++] = (*this)[__i];
 120   }
 121
 122   return __tmp;
 123 }
 124
 125 template <class _Tp>
 126 valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array<_Tp>& __x) {
 127   _STLP_ASSERT(__x._M_addr.size() == this->size())
 128   for (size_t __i = 0; __i < __x._M_addr.size(); ++__i)
 129     (*this)[__i] = __x._M_array[__x._M_addr[__i]];
 130   return *this;
 131 }
 132
 133 template <class _Tp>
 134 valarray<_Tp>
 135 valarray<_Tp>::operator[](const _Valarray_size_t& __addr) const {
 136   valarray<_Tp> __tmp(__addr.size(), _NoInit());
 137   for (size_t __i = 0; __i < __addr.size(); ++__i)
 138     __tmp[__i] = (*this)[__addr[__i]];
 139   return __tmp;
 140 }
 141
 142 //----------------------------------------------------------------------
 143 // Other valarray noninline member functions
 144
 145 // Shift and cshift
 146
 147 template <class _Tp>
 148 valarray<_Tp> valarray<_Tp>::shift(int __n) const {
 149   valarray<_Tp> __tmp(this->size());
 150
 151   if (__n >= 0) {
 152     if (__n < this->size())
 153       copy(this->_M_first + __n, this->_M_first + this->size(),
 154            __tmp._M_first);
 155   }
 156   else {
 157     if (-__n < this->size())
 158       copy(this->_M_first, this->_M_first + this->size() + __n,
 159            __tmp._M_first - __n);
 160   }
 161   return __tmp;
 162 }
 163
 164 template <class _Tp>
 165 valarray<_Tp> valarray<_Tp>::cshift(int __m) const {
 166   valarray<_Tp> __tmp(this->size());
 167
 168   // Reduce __m to an equivalent number in the range [0, size()).  We
 169   // have to be careful with negative numbers, since the sign of a % b
 170   // is unspecified when a < 0.
 171   long __n = __m;
 172   if (this->size() < (numeric_limits<long>::max)())
 173     __n %= long(this->size());
 174   if (__n < 0)
 175     __n += this->size();
 176
 177   copy(this->_M_first,       this->_M_first + __n,
 178        __tmp._M_first + (this->size() - __n));
 179   copy(this->_M_first + __n, this->_M_first + this->size(),
 180        __tmp._M_first);
 181
 182   return __tmp;
 183 }
 184
 185 _STLP_END_NAMESPACE
 186
 187 #endif /*  _STLP_VALARRAY_C */
 188
 189 // Local Variables:
 190 // mode:C++
 191 // End: