include/c++/stl/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 {
  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 {
  89   if (this->size() != 0) {
  90     _Gslice_Iter __i(__x._M_gslice);
  91     do
  92       (*this)[__i._M_step] = __x._M_array[__i._M_1d_idx];
  93     while(__i._M_incr());
  94   }
  95   return *this;
  96 }
  97
  98 template <class _Tp>
  99 valarray<_Tp> valarray<_Tp>::operator[](const gslice& __slice) const
 100 {
 101   valarray<_Tp> __tmp(__slice._M_size(), _NoInit());
 102   if (__tmp.size() != 0) {
 103     _Gslice_Iter __i(__slice);
 104     do __tmp[__i._M_step] = (*this)[__i._M_1d_idx]; while(__i._M_incr());
 105   }
 106   return __tmp;
 107 }
 108
 109 template <class _Tp>
 110 valarray<_Tp> valarray<_Tp>::operator[](const _Valarray_bool& __mask) const
 111 {
 112   size_t _p_size = 0;
 113   {
 114     for (size_t __i = 0; __i < __mask.size(); ++__i)
 115       if (__mask[__i]) ++_p_size;
 116   }
 117
 118   valarray<_Tp> __tmp(_p_size, _NoInit());
 119   size_t __idx = 0;
 120   {
 121     for (size_t __i = 0; __i < __mask.size(); ++__i)
 122       if (__mask[__i]) __tmp[__idx++] = (*this)[__i];
 123   }
 124
 125   return __tmp;
 126 }
 127
 128 template <class _Tp>
 129 valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array<_Tp>& __x) {
 130   for (size_t __i = 0; __i < __x._M_addr.size(); ++__i)
 131     (*this)[__i] = __x._M_array[__x._M_addr[__i]];
 132   return *this;
 133 }
 134
 135 template <class _Tp>
 136 valarray<_Tp>
 137 valarray<_Tp>::operator[](const _Valarray_size_t& __addr) const
 138 {
 139   valarray<_Tp> __tmp(__addr.size(), _NoInit());
 140   for (size_t __i = 0; __i < __addr.size(); ++__i)
 141     __tmp[__i] = (*this)[__addr[__i]];
 142   return __tmp;
 143 }
 144
 145 //----------------------------------------------------------------------
 146 // Other valarray noninline member functions
 147
 148 // Shift and cshift
 149
 150 template <class _Tp>
 151 valarray<_Tp> valarray<_Tp>::shift(int __n) const
 152 {
 153   valarray<_Tp> __tmp(this->size());
 154
 155   if (__n >= 0) {
 156     if (__n < this->size())
 157       copy(this->_M_first + __n, this->_M_first + this->size(),
 158            __tmp._M_first);
 159   }
 160   else {
 161     if (-__n < this->size())
 162       copy(this->_M_first, this->_M_first + this->size() + __n,
 163            __tmp._M_first - __n);
 164   }
 165   return __tmp;
 166 }
 167
 168 template <class _Tp>
 169 valarray<_Tp> valarray<_Tp>::cshift(int __m) const
 170 {
 171   valarray<_Tp> __tmp(this->size());
 172
 173   // Reduce __m to an equivalent number in the range [0, size()).  We
 174   // have to be careful with negative numbers, since the sign of a % b
 175   // is unspecified when a < 0.
 176   long __n = __m;
 177   if (this->size() < (numeric_limits<long>::max)())
 178     __n %= long(this->size());
 179   if (__n < 0)
 180     __n += this->size();
 181
 182   copy(this->_M_first,       this->_M_first + __n,
 183        __tmp._M_first + (this->size() - __n));
 184   copy(this->_M_first + __n, this->_M_first + this->size(),
 185        __tmp._M_first);
 186
 187   return __tmp;
 188 }
 189
 190 _STLP_END_NAMESPACE
 191
 192 #endif /*  _STLP_VALARRAY_C */
 193
 194 // Local Variables:
 195 // mode:C++
 196 // End: