void operator%= (const valarray<value_type>& __x) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] %= __x[__i._M_step]; while(__i._M_incr());    }  }  void operator+= (const valarray<value_type>& __x) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] += __x[__i._M_step]; while(__i._M_incr());    }  }  void operator-= (const valarray<value_type>& __x) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] -= __x[__i._M_step]; while(__i._M_incr());    }  }  void operator^= (const valarray<value_type>& __x) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] ^= __x[__i._M_step]; while(__i._M_incr());    }  }  void operator&= (const valarray<value_type>& __x) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] &= __x[__i._M_step]; while(__i._M_incr());    }  }  void operator|= (const valarray<value_type>& __x) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] |= __x[__i._M_step]; while(__i._M_incr());    }  }  void operator<<= (const valarray<value_type>& __x) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] <<= __x[__i._M_step]; while(__i._M_incr());    }  }  void operator>>= (const valarray<value_type>& __x) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] >>= __x[__i._M_step]; while(__i._M_incr());    }  }  void operator= (const value_type& __c) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] = __c; while(__i._M_incr());    }  }  ~gslice_array() {}private:                          gslice_array(gslice __gslice, valarray<_Tp>& __array)    : _M_gslice(__gslice), _M_array(__array)    {}  gslice                _M_gslice;  valarray<value_type>& _M_array;private:                        // Disable assignment  void operator=(const gslice_array&);};// valarray member functions dealing with gslice and gslice_array.  Note// that it is illegal (behavior is undefined) to construct a gslice_array// from a degenerate gslice.template <class _Tp>inline valarray<_Tp>::valarray(const gslice_array<_Tp>& __x)  : _Valarray_base<_Tp>(__x._M_gslice._M_size()){  typedef typename __type_traits<_Tp>::has_trivial_default_constructor          _Is_Trivial;  _M_initialize(_Is_Trivial());    *this = __x;}// Behavior is undefined if __x and *this have different sizes, or if// __x was constructed from a degenerate gslice.template <class _Tp>valarray<_Tp>& valarray<_Tp>::operator=(const gslice_array<_Tp>& __x){  if (this->size() != 0) {    _Gslice_Iter __i(__x._M_gslice);    do      (*this)[__i._M_step] = __x._M_array[__i._M_1d_idx];    while(__i._M_incr());  }  return *this;}template <class _Tp>inline gslice_array<_Tp> valarray<_Tp>::operator[](gslice __slice) {  return gslice_array<_Tp>(__slice, *this);}template <class _Tp>valarray<_Tp> valarray<_Tp>::operator[](gslice __slice) const{  valarray __tmp(__slice._M_size(), _NoInit());  if (__tmp.size() != 0) {    _Gslice_Iter __i(__slice);    do __tmp[__i._M_step] = (*this)[__i._M_1d_idx]; while(__i._M_incr());  }  return __tmp;}//----------------------------------------------------------------------// mask_arraytemplate <class _Tp>class mask_array {  friend class valarray<_Tp>;public:  typedef _Tp value_type;  void operator=(const valarray<value_type>& __x) const {    size_t __idx = 0;    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] = __x[__idx++];  }  void operator*=(const valarray<value_type>& __x) const {    size_t __idx = 0;    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] *= __x[__idx++];  }  void operator/=(const valarray<value_type>& __x) const {    size_t __idx = 0;    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] /= __x[__idx++];  }  void operator%=(const valarray<value_type>& __x) const {    size_t __idx = 0;    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] %= __x[__idx++];  }  void operator+=(const valarray<value_type>& __x) const {    size_t __idx = 0;    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] += __x[__idx++];  }  void operator-=(const valarray<value_type>& __x) const {    size_t __idx = 0;    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] -= __x[__idx++];  }    void operator^=(const valarray<value_type>& __x) const {    size_t __idx = 0;    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] ^= __x[__idx++];  }  void operator&=(const valarray<value_type>& __x) const {    size_t __idx = 0;    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] &= __x[__idx++];  }  void operator|=(const valarray<value_type>& __x) const {    size_t __idx = 0;    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] |= __x[__idx++];  }  void operator<<=(const valarray<value_type>& __x) const {    size_t __idx = 0;    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] <<= __x[__idx++];  }  void operator>>=(const valarray<value_type>& __x) const {    size_t __idx = 0;    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] >>= __x[__idx++];  }  void operator=(const value_type& __c) const {    for (size_t __i = 0; __i < _M_array.size(); ++__i)      if (_M_mask[__i]) _M_array[__i] = __c;  }  ~mask_array() {}  // Extension: number of true values in the mask  size_t _M_num_true() const {    size_t __result = 0;    for (size_t __i = 0; __i < _M_mask.size(); ++__i)      if (_M_mask[__i]) ++__result;    return __result;  }private:  mask_array(const valarray<bool>& __mask, valarray<_Tp>& __array)    : _M_mask(__mask), _M_array(__array)    {}  valarray<bool> _M_mask;  valarray<_Tp>& _M_array;private:                        // Disable assignment  void operator=(const mask_array&);};// valarray member functions dealing with mask_arraytemplate <class _Tp>inline valarray<_Tp>::valarray(const mask_array<_Tp>& __x)  : _Valarray_base<_Tp>(__x._M_num_true()){  typedef typename __type_traits<_Tp>::has_trivial_default_constructor          _Is_Trivial;  _M_initialize(_Is_Trivial());    *this = __x;}// Behavior is undefined if __x._M_num_true() != this->size()template <class _Tp>inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array<_Tp>& __x) {  size_t __idx = 0;  for (size_t __i = 0; __i < __x._M_array.size(); ++__i)    if (__x._M_mask[__i]) (*this)[__idx++] = __x._M_array[__i];  return *this;}template <class _Tp>inline mask_array<_Tp> valarray<_Tp>::operator[](const valarray<bool>& __mask){  return mask_array<_Tp>(__mask, *this);}template <class _Tp>valarray<_Tp> valarray<_Tp>::operator[](const valarray<bool>& __mask) const{  size_t __size = 0;  {    for (size_t __i = 0; __i < __mask.size(); ++__i)      if (__mask[__i]) ++__size;  }  valarray __tmp(__size, _NoInit());  size_t __idx = 0;  {    for (size_t __i = 0; __i < __mask.size(); ++__i)      if (__mask[__i]) __tmp[__idx++] = (*this)[__i];  }  return __tmp;}//----------------------------------------------------------------------// indirect_arraytemplate <class _Tp>class indirect_array {  friend class valarray<_Tp>;public:  typedef _Tp value_type;  void operator=(const valarray<value_type>& __x) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] = __x[__i];  }  void operator*=(const valarray<value_type>& __x) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] *= __x[__i];  }  void operator/=(const valarray<value_type>& __x) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] /= __x[__i];  }  void operator%=(const valarray<value_type>& __x) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] %= __x[__i];  }  void operator+=(const valarray<value_type>& __x) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] += __x[__i];  }  void operator-=(const valarray<value_type>& __x) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] -= __x[__i];  }  void operator^=(const valarray<value_type>& __x) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] ^= __x[__i];  }  void operator&=(const valarray<value_type>& __x) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] &= __x[__i];  }  void operator|=(const valarray<value_type>& __x) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] |= __x[__i];  }  void operator<<=(const valarray<value_type>& __x) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] <<= __x[__i];  }  void operator>>=(const valarray<value_type>& __x) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] >>= __x[__i];  }  void operator=(const value_type& __c) const {    for (size_t __i = 0; __i < _M_addr.size(); ++__i)      _M_array[_M_addr[__i]] = __c;  }  ~indirect_array() {}private:  indirect_array(const valarray<size_t>& __addr, valarray<_Tp>& __array)    : _M_addr(__addr), _M_array(__array)    {}  valarray<size_t> _M_addr;  valarray<_Tp>&   _M_array;private:                        // Disable assignment  void operator=(const indirect_array&);};// valarray member functions dealing with indirect_arraytemplate <class _Tp>inline valarray<_Tp>::valarray(const indirect_array<_Tp>& __x)  : _Valarray_base<_Tp>(__x._M_addr.size()){  typedef typename __type_traits<_Tp>::has_trivial_default_constructor          _Is_Trivial;  _M_initialize(_Is_Trivial());    *this = __x;}template <class _Tp>valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array<_Tp>& __x) {  for (size_t __i = 0; __i < __x._M_addr.size(); ++__i)    (*this)[__i] = __x._M_array[__x._M_addr[__i]];  return *this;}template <class _Tp>inline indirect_array<_Tp>valarray<_Tp>::operator[](const valarray<size_t>& __addr){  return indirect_array<_Tp>(__addr, *this);}template <class _Tp>valarray<_Tp>valarray<_Tp>::operator[](const valarray<size_t>& __addr) const{  valarray<_Tp> __tmp(__addr.size(), _NoInit());  for (size_t __i = 0; __i < __addr.size(); ++__i)    __tmp[__i] = (*this)[__addr[__i]];  return __tmp;}//----------------------------------------------------------------------// Other valarray noninline member functions// Shift and cshifttemplate <class _Tp>valarray<_Tp> valarray<_Tp>::shift(int __n) const{  valarray<_Tp> __tmp(this->size());  if (__n >= 0) {    if (__n < this->size())      copy(this->_M_first + __n, this->_M_first + this->size(),           __tmp._M_first);  }  else {    if (-__n < this->size())      copy(this->_M_first, this->_M_first + this->size() + __n,           __tmp._M_first - __n);  }  return __tmp;}template <class _Tp>valarray<_Tp> valarray<_Tp>::cshift(int __m) const{  valarray<_Tp> __tmp(this->size());  // Reduce __m to an equivalent number in the range [0, size()).  We  // have to be careful with negative numbers, since the sign of a % b  // is unspecified when a < 0.  long __n = __m;  if (this->size() < numeric_limits<long>::max())    __n %= long(this->size());  if (__n < 0)    __n += this->size();  copy(this->_M_first,       this->_M_first + __n,       __tmp._M_first + (this->size() - __n));  copy(this->_M_first + __n, this->_M_first + this->size(),       __tmp._M_first);  return __tmp;}__STL_END_NAMESPACE#endif /* __SGI_STL_VALARRAY */// Local Variables:// mode:C++// End: