/*

 *

 *

 * Copyright (c) 1994

 * Hewlett-Packard Company

 *

 * Copyright (c) 1996,1997

 * Silicon Graphics Computer Systems, Inc.

 *

 * Copyright (c) 1997

 * Moscow Center for SPARC Technology

 *

 * Copyright (c) 1999

 * Boris Fomitchev

 *

 * This material is provided "as is", with absolutely no warranty expressed

 * or implied. Any use is at your own risk.

 *

 * Permission to use or copy this software for any purpose is hereby granted

 * without fee, provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 */

#ifndef _STLP_VALARRAY_C

#define _STLP_VALARRAY_C

#ifndef _STLP_VALARRAY_H

# include <stl/_valarray.h>

#endif

_STLP_BEGIN_NAMESPACE

template <class _Tp>

_Valarray_bool valarray<_Tp>:: operator!() const {

  _Valarray_bool __tmp(this->size(), _Valarray_bool::_NoInit());

  for (size_t __i = 0; __i < this->size(); ++__i)

    __tmp[__i] = !(*this)[__i];

  return __tmp;

}

// Behavior is undefined if __x and *this have different sizes

template <class _Tp>

valarray<_Tp>& valarray<_Tp>::operator=(const slice_array<_Tp>& __x)

{

  size_t __index = __x._M_slice.start();

  for (size_t __i = 0;

       __i < __x._M_slice.size();

       ++__i, __index += __x._M_slice.stride())

    (*this)[__i] = __x._M_array[__index];

  return *this;

}

template <class _Tp>

valarray<_Tp> valarray<_Tp>::operator[](slice __slice) const {

  valarray<_Tp> __tmp(__slice.size(), _NoInit());

  size_t __index = __slice.start();

  for (size_t __i = 0;

       __i < __slice.size();

       ++__i, __index += __slice.stride())

    __tmp[__i] = (*this)[__index];

  return __tmp;

}

template <class _Size>

bool _Gslice_Iter_tmpl<_Size>::_M_incr() {

  size_t __dim = _M_indices.size() - 1;

  ++_M_step;

  for (;;) {

    _M_1d_idx += _M_gslice._M_strides[__dim];

    if (++_M_indices[__dim] != _M_gslice._M_lengths[__dim])

      return true;

    else if (__dim != 0) {

      _M_1d_idx -= _M_gslice._M_strides[__dim] * _M_gslice._M_lengths[__dim];

      _M_indices[__dim] = 0;

      --__dim;

    }

    else

      return false;

  }

}

// 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>

valarray<_Tp> valarray<_Tp>::operator[](const gslice& __slice) const

{

  valarray<_Tp> __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;

}

template <class _Tp>

valarray<_Tp> valarray<_Tp>::operator[](const _Valarray_bool& __mask) const

{

  size_t _p_size = 0;

  {

    for (size_t __i = 0; __i < __mask.size(); ++__i)

      if (__mask[__i]) ++_p_size;

  }

  valarray<_Tp> __tmp(_p_size, _NoInit());

  size_t __idx = 0;

  {

    for (size_t __i = 0; __i < __mask.size(); ++__i)

      if (__mask[__i]) __tmp[__idx++] = (*this)[__i];

  }

  return __tmp;

}

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>

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 cshift

template <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;

}

_STLP_END_NAMESPACE

#endif /*  _STLP_VALARRAY_C */

// Local Variables:

// mode:C++

// End: