/*

 * Copyright (c) 1999

 * Silicon Graphics Computer Systems, Inc.

 *

 * 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

#  define _STLP_VALARRAY

#include <algorithm>

#include <limits>

#ifndef _STLP_OUTERMOST_HEADER_ID

#  define _STLP_OUTERMOST_HEADER_ID 0x76

#  include <stl/_prolog.h>

#endif

#ifndef _STLP_INTERNAL_CMATH

#  include <stl/_cmath.h>

#endif

#include <new>

#ifndef _STLP_INTERNAL_NUMERIC_H

#  include <stl/_numeric.h>

#endif

_STLP_BEGIN_NAMESPACE

class slice;

class gslice;

template <class _Tp> class valarray;

typedef valarray<bool>    _Valarray_bool;

typedef valarray<size_t>  _Valarray_size_t;

template <class _Tp> class slice_array;

template <class _Tp> class gslice_array;

template <class _Tp> class mask_array;

template <class _Tp> class indirect_array;

//----------------------------------------------------------------------

// class valarray

// Base class to handle memory allocation and deallocation.  We can't just

// use vector<>, because vector<bool> would be unsuitable as an internal

// representation for valarray<bool>.

template <class _Tp>

struct _Valarray_base {

  _Tp*   _M_first;

  size_t _M_size;

  _Valarray_base() : _M_first(0), _M_size(0) {}

  _Valarray_base(size_t __n) : _M_first(0), _M_size(0) { _M_allocate(__n); }

  ~_Valarray_base() { _M_deallocate(); }

  void _M_allocate(size_t __n) {

    if (__n != 0) {

      _M_first = __STATIC_CAST(_Tp*, __stl_new(__n * sizeof(_Tp)));

      _M_size  = __n;

    }

    else {

      _M_first = 0;

      _M_size = 0;

    }

  }

  void _M_deallocate() {

    __stl_delete(_M_first);

    _M_first = 0;

    _M_size = 0;

  }

};

template <class _Tp>

class valarray : private _Valarray_base<_Tp>

{

  friend class gslice;

public:

  typedef _Tp value_type;

  // Basic constructors

  valarray() : _Valarray_base<_Tp>() {}

  explicit valarray(size_t __n) : _Valarray_base<_Tp>(__n)

    { uninitialized_fill_n(this->_M_first, this->_M_size, _STLP_DEFAULT_CONSTRUCTED(value_type)); }

  valarray(const value_type& __x, size_t __n) : _Valarray_base<_Tp>(__n)

    { uninitialized_fill_n(this->_M_first, this->_M_size, __x); }

  valarray(const value_type* __p, size_t __n) : _Valarray_base<_Tp>(__n)

    { uninitialized_copy(__p, __p + __n, this->_M_first); }

  valarray(const valarray<_Tp>& __x) : _Valarray_base<_Tp>(__x._M_size) {

    uninitialized_copy(__x._M_first, __x._M_first + __x._M_size,

                       this->_M_first);

  }

  // Constructors from auxiliary array types

  valarray(const slice_array<_Tp>&);

  valarray(const gslice_array<_Tp>&);

  valarray(const mask_array<_Tp>&);

  valarray(const indirect_array<_Tp>&);

  // Destructor

    ~valarray() { _STLP_STD::detail::_Destroy_Range( this->_M_first, this->_M_first + this->_M_size ); }

    struct _NoInit {};

    valarray( size_t __n, _NoInit ) :

        _Valarray_base<_Tp>(__n)

      { uninitialized_fill_n(this->_M_first, this->_M_size, _Tp() ); }

public:                         // Assignment

  // Basic assignment.  Note that 'x = y' is undefined if x.size() != y.size()

  valarray<_Tp>& operator=(const valarray<_Tp>& __x) {

    _STLP_ASSERT(__x.size() == this->size())

    if (this != &__x)

      copy(__x._M_first, __x._M_first + __x._M_size, this->_M_first);

    return *this;

  }

  // Scalar assignment

  valarray<_Tp>& operator=(const value_type& __x) {

    fill_n(this->_M_first, this->_M_size, __x);

    return *this;

  }

  // Assignment of auxiliary array types

  valarray<_Tp>& operator=(const slice_array<_Tp>&);

  valarray<_Tp>& operator=(const gslice_array<_Tp>&);

  valarray<_Tp>& operator=(const mask_array<_Tp>&);

  valarray<_Tp>& operator=(const indirect_array<_Tp>&);

public:                         // Element access

  value_type  operator[](size_t __n) const {

    _STLP_ASSERT(__n < this->size())

    return this->_M_first[__n];

  }

  value_type& operator[](size_t __n) {

    _STLP_ASSERT(__n < this->size())

    return this->_M_first[__n];

  }

  size_t size() const { return this->_M_size; }

public:                         // Subsetting operations with auxiliary type

  valarray<_Tp>       operator[](slice) const;

  slice_array<_Tp>    operator[](slice);

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

  gslice_array<_Tp>   operator[](const gslice&);

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

  mask_array<_Tp>     operator[](const _Valarray_bool&);

  valarray<_Tp>       operator[](const _Valarray_size_t&) const;

  indirect_array<_Tp> operator[](const _Valarray_size_t&);

public:                         // Unary operators.

  valarray<_Tp> operator+() const { return *this; }

  valarray<_Tp> operator-() const {

    valarray<_Tp> __tmp(this->size(), _NoInit());

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

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

    return __tmp;

  }

  valarray<_Tp> operator~() const {

    valarray<_Tp> __tmp(this->size(), _NoInit());

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

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

    return __tmp;

  }

  _Valarray_bool operator!() const;

public:                         // Scalar computed assignment.

  valarray<_Tp>& operator*= (const value_type& __x) {

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

      (*this)[__i] *= __x;

    return *this;

  }

  valarray<_Tp>& operator/= (const value_type& __x) {

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

      (*this)[__i] /= __x;

    return *this;

  }

  valarray<_Tp>& operator%= (const value_type& __x) {

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

      (*this)[__i] %= __x;

    return *this;

  }

  valarray<_Tp>& operator+= (const value_type& __x) {

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

      (*this)[__i] += __x;

    return *this;

  }

  valarray<_Tp>& operator-= (const value_type& __x) {

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

      (*this)[__i] -= __x;

    return *this;

  }

  valarray<_Tp>& operator^= (const value_type& __x) {

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

      (*this)[__i] ^= __x;

    return *this;

  }

  valarray<_Tp>& operator&= (const value_type& __x) {

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

      (*this)[__i] &= __x;

    return *this;

  }

  valarray<_Tp>& operator|= (const value_type& __x) {

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

      (*this)[__i] |= __x;

    return *this;

  }

  valarray<_Tp>& operator<<= (const value_type& __x) {

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

      (*this)[__i] <<= __x;

    return *this;

  }

  valarray<_Tp>& operator>>= (const value_type& __x) {

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

      (*this)[__i] >>= __x;

    return *this;

  }

public:                         // Array computed assignment.

  valarray<_Tp>& operator*= (const valarray<_Tp>& __x) {

    _STLP_ASSERT(__x.size() == this->size())

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

      (*this)[__i] *= __x[__i];

    return *this;

  }

  valarray<_Tp>& operator/= (const valarray<_Tp>& __x) {

    _STLP_ASSERT(__x.size() == this->size())

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

      (*this)[__i] /= __x[__i];

    return *this;

  }

  valarray<_Tp>& operator%= (const valarray<_Tp>& __x) {

    _STLP_ASSERT(__x.size() == this->size())

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

      (*this)[__i] %= __x[__i];

    return *this;

  }

  valarray<_Tp>& operator+= (const valarray<_Tp>& __x) {

    _STLP_ASSERT(__x.size() == this->size())

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

      (*this)[__i] += __x[__i];

    return *this;

  }

  valarray<_Tp>& operator-= (const valarray<_Tp>& __x) {

    _STLP_ASSERT(__x.size() == this->size())

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

      (*this)[__i] -= __x[__i];

    return *this;

  }

  valarray<_Tp>& operator^= (const valarray<_Tp>& __x) {

    _STLP_ASSERT(__x.size() == this->size())

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

      (*this)[__i] ^= __x[__i];

    return *this;

  }

  valarray<_Tp>& operator&= (const valarray<_Tp>& __x) {

    _STLP_ASSERT(__x.size() == this->size())

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

      (*this)[__i] &= __x[__i];

    return *this;

  }

  valarray<_Tp>& operator|= (const valarray<_Tp>& __x) {

    _STLP_ASSERT(__x.size() == this->size())

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

      (*this)[__i] |= __x[__i];

    return *this;

  }

  valarray<_Tp>& operator<<= (const valarray<_Tp>& __x) {

    _STLP_ASSERT(__x.size() == this->size())

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

      (*this)[__i] <<= __x[__i];

    return *this;

  }

  valarray<_Tp>& operator>>= (const valarray<_Tp>& __x) {

    _STLP_ASSERT(__x.size() == this->size())

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

      (*this)[__i] >>= __x[__i];

    return *this;

  }

public:                         // Other member functions.

  // The result is undefined for zero-length arrays

  value_type sum() const {

    _STLP_ASSERT(this->size() != 0)

    return accumulate(this->_M_first + 1, this->_M_first + this->_M_size,

                      (*this)[0]);

  }

  // The result is undefined for zero-length arrays

  value_type (min) () const {

    _STLP_ASSERT(this->size() != 0)

    return *min_element(this->_M_first + 0, this->_M_first + this->_M_size);

  }

  value_type (max) () const {

    _STLP_ASSERT(this->size() != 0)

    return *max_element(this->_M_first + 0, this->_M_first + this->_M_size);

  }

  valarray<_Tp> shift(int __n) const;

  valarray<_Tp> cshift(int __n) const;

  valarray<_Tp> apply(value_type __f(value_type)) const {

    valarray<_Tp> __tmp(this->size());

    transform(this->_M_first + 0, this->_M_first + this->_M_size, __tmp._M_first,

              __f);

    return __tmp;

  }

  valarray<_Tp> apply(value_type __f(const value_type&)) const {

    valarray<_Tp> __tmp(this->size());

    transform(this->_M_first + 0, this->_M_first + this->_M_size, __tmp._M_first,

              __f);

    return __tmp;

  }

  void resize(size_t __n, value_type __x = value_type()) {

    _STLP_STD::detail::_Destroy_Range( this->_M_first, this->_M_first + this->_M_size );

    _Valarray_base<_Tp>::_M_deallocate();

    _Valarray_base<_Tp>::_M_allocate(__n);

    uninitialized_fill_n(this->_M_first, this->_M_size, __x);

  }

};

//----------------------------------------------------------------------

// valarray non-member functions.

// Binary arithmetic operations between two arrays.  Behavior is

// undefined if the two arrays do not have the same length.

template <class _Tp>

inline valarray<_Tp>  _STLP_CALL operator*(const valarray<_Tp>& __x,

                                           const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i] * __y[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp>  _STLP_CALL operator/(const valarray<_Tp>& __x,

                                           const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i] / __y[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp>  _STLP_CALL operator%(const valarray<_Tp>& __x,

                                           const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i] % __y[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp>  _STLP_CALL operator+(const valarray<_Tp>& __x,

                                           const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i] + __y[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp>  _STLP_CALL operator-(const valarray<_Tp>& __x,

                                           const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i] - __y[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator^(const valarray<_Tp>& __x,

                                          const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i] ^ __y[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator&(const valarray<_Tp>& __x,

                                          const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i] & __y[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator|(const valarray<_Tp>& __x,

                                          const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i] | __y[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator<<(const valarray<_Tp>& __x,

                                           const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i] << __y[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator>>(const valarray<_Tp>& __x,

                                           const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i] >> __y[__i];

  return __tmp;

}

// Binary arithmetic operations between an array and a scalar.

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator*(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i]  * __c;

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator*(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __c * __x[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator/(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i]  / __c;

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator/(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __c / __x[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator%(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i]  % __c;

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator%(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __c % __x[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator+(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i]  + __c;

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator+(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __c + __x[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator-(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i]  - __c;

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator-(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __c - __x[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator^(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i]  ^ __c;

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator^(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __c ^ __x[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator&(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i]  & __c;

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator&(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __c & __x[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator|(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i]  | __c;

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator|(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __c | __x[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator<<(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i]  << __c;

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator<<(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __c << __x[__i];

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator>>(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __x[__i]  >> __c;

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> _STLP_CALL operator>>(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = __c >> __x[__i];

  return __tmp;

}

// Binary logical operations between two arrays.  Behavior is undefined

// if the two arrays have different lengths.  Note that operator== does

// not do what you might at first expect.

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator==(const valarray<_Tp>& __x,

                                            const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] == __y[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator<(const valarray<_Tp>& __x,

                                           const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] < __y[__i];

  return __tmp;

}

#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator!=(const valarray<_Tp>& __x,

                                            const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] != __y[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator>(const valarray<_Tp>& __x,

                                           const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] > __y[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator<=(const valarray<_Tp>& __x,

                                            const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] <= __y[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator>=(const valarray<_Tp>& __x,

                                            const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] >= __y[__i];

  return __tmp;

}

#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */

// fbp : swap ?

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator&&(const valarray<_Tp>& __x,

                                            const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] && __y[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator||(const valarray<_Tp>& __x,

                                            const valarray<_Tp>& __y) {

  _STLP_ASSERT(__x.size() == __y.size())

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] || __y[__i];

  return __tmp;

}

// Logical operations between an array and a scalar.

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator==(const valarray<_Tp>& __x, const _Tp& __c) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] == __c;

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator==(const _Tp& __c, const valarray<_Tp>& __x) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __c == __x[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator!=(const valarray<_Tp>& __x, const _Tp& __c) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] != __c;

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator!=(const _Tp& __c, const valarray<_Tp>& __x) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __c != __x[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator<(const valarray<_Tp>& __x, const _Tp& __c) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] < __c;

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator<(const _Tp& __c, const valarray<_Tp>& __x) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __c < __x[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator>(const valarray<_Tp>& __x, const _Tp& __c) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] > __c;

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator>(const _Tp& __c, const valarray<_Tp>& __x) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __c > __x[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator<=(const valarray<_Tp>& __x, const _Tp& __c) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i]  <= __c;

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator<=(const _Tp& __c, const valarray<_Tp>& __x) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __c <= __x[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator>=(const valarray<_Tp>& __x, const _Tp& __c) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] >= __c;

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator>=(const _Tp& __c, const valarray<_Tp>& __x) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __c >= __x[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator&&(const valarray<_Tp>& __x, const _Tp& __c) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] && __c;

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator&&(const _Tp& __c, const valarray<_Tp>& __x) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __c && __x[__i];

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator||(const valarray<_Tp>& __x, const _Tp& __c) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __x[__i] || __c;

  return __tmp;

}

template <class _Tp>

inline _Valarray_bool _STLP_CALL operator||(const _Tp& __c, const valarray<_Tp>& __x) {

  _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());

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

    __tmp[__i] = __c || __x[__i];

  return __tmp;

}

// valarray "transcendentals" (the list includes abs and sqrt, which,

// of course, are not transcendental).

template <class _Tp>

inline valarray<_Tp> abs(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::abs(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> acos(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::acos(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> asin(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::asin(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> atan(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::atan(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> atan2(const valarray<_Tp>& __x,

                           const valarray<_Tp>& __y) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::atan2(__x[__i], __y[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> atan2(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::atan2(__x[__i], __c);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> atan2(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::atan2(__c, __x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> cos(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::cos(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> cosh(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::cosh(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> exp(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::exp(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> log(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::log(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> log10(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::log10(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> pow(const valarray<_Tp>& __x,

                         const valarray<_Tp>& __y) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::pow(__x[__i], __y[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> pow(const valarray<_Tp>& __x, const _Tp& __c) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::pow(__x[__i], __c);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> pow(const _Tp& __c, const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::pow(__c, __x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> sin(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::sin(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> sinh(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::sinh(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> sqrt(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::sqrt(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> tan(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::tan(__x[__i]);

  return __tmp;

}

template <class _Tp>

inline valarray<_Tp> tanh(const valarray<_Tp>& __x) {

  typedef typename valarray<_Tp>::_NoInit _NoInit;

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

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

    __tmp[__i] = ::tanh(__x[__i]);

  return __tmp;

}

//----------------------------------------------------------------------

// slice and slice_array

class slice {

public:

  slice() : _M_start(0), _M_length(0), _M_stride(0) {}

  slice(size_t __start, size_t __length, size_t __stride)

    : _M_start(__start), _M_length(__length), _M_stride(__stride)

    {}

  __TRIVIAL_DESTRUCTOR(slice)

  size_t start()  const { return _M_start; }

  size_t size()   const { return _M_length; }

  size_t stride() const { return _M_stride; }

private:

  size_t _M_start;

  size_t _M_length;

  size_t _M_stride;

};

template <class _Tp>

class slice_array {

  friend class valarray<_Tp>;

public:

  typedef _Tp value_type;

  void operator=(const valarray<value_type>& __x) const {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] = __x[__i];

  }

  void operator*=(const valarray<value_type>& __x) const {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] *= __x[__i];

  }

  void operator/=(const valarray<value_type>& __x) const {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] /= __x[__i];

  }

  void operator%=(const valarray<value_type>& __x) const {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] %= __x[__i];

  }

  void operator+=(const valarray<value_type>& __x) const {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] += __x[__i];

  }

  void operator-=(const valarray<value_type>& __x) const {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] -= __x[__i];

  }

  void operator^=(const valarray<value_type>& __x) const {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] ^= __x[__i];

  }

  void operator&=(const valarray<value_type>& __x) const {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] &= __x[__i];

  }

  void operator|=(const valarray<value_type>& __x) const {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] |= __x[__i];

  }

  void operator<<=(const valarray<value_type>& __x) const {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] <<= __x[__i];

  }

  void operator>>=(const valarray<value_type>& __x) const {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] >>= __x[__i];

  }

  void operator=(const value_type& __c) /*const could be const but standard says NO (26.3.5.4-1)*/ {

    size_t __index = _M_slice.start();

    for (size_t __i = 0;

         __i < _M_slice.size();

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

      _M_array[__index] = __c;

  }

  // C++ Standard defect 253, copy constructor must be public.

  slice_array(const slice_array &__x)

    : _M_slice(__x._M_slice), _M_array(__x._M_array)

    {}

  ~slice_array() {}

private:

  slice_array(const slice& __slice, valarray<_Tp> &__array)

    : _M_slice(__slice), _M_array(__array)

    {}

  slice          _M_slice;

  valarray<_Tp>& _M_array;

private:

  // Disable default constructor and assignment

  slice_array();

  slice_array& operator=(const slice_array&);

};

// valarray member functions dealing with slice and slice_array

template <class _Tp>

inline valarray<_Tp>::valarray(const slice_array<_Tp>& __x) :

    _Valarray_base<_Tp>(__x._M_slice.size())

{

  uninitialized_fill_n(this->_M_first, this->_M_size, _Tp() );

  *this = __x;

}

template <class _Tp>

inline slice_array<_Tp> valarray<_Tp>::operator[](slice __slice)

{ return slice_array<_Tp>(__slice, *this); }

//----------------------------------------------------------------------

// gslice and gslice_array

template <class _Size>

struct _Gslice_Iter_tmpl;

class gslice {

  friend struct _Gslice_Iter_tmpl<size_t>;

public:

  gslice() : _M_start(0), _M_lengths(), _M_strides() {}

  gslice(size_t __start,

         const _Valarray_size_t& __lengths, const _Valarray_size_t& __strides)

    : _M_start(__start), _M_lengths(__lengths), _M_strides(__strides)

    {}

  __TRIVIAL_DESTRUCTOR(gslice)

  size_t start()            const { return _M_start; }

  _Valarray_size_t size()   const { return _M_lengths; }

  _Valarray_size_t stride() const { return _M_strides; }

  // Extension: check for an empty gslice.

  bool _M_empty() const { return _M_lengths.size() == 0; }

  // Extension: number of indices this gslice represents.  (For a degenerate

  // gslice, they're not necessarily all distinct.)

  size_t _M_size() const {

    return !this->_M_empty()

      ? accumulate(_M_lengths._M_first + 1,

                   _M_lengths._M_first + _M_lengths._M_size,

                   _M_lengths[0],

                   multiplies<size_t>())

      : 0;

  }

# ifndef __HP_aCC

private:

# endif

  size_t _M_start;

  _Valarray_size_t _M_lengths;

  _Valarray_size_t _M_strides;

};

// This is not an STL iterator.  It is constructed from a gslice, and it

// steps through the gslice indices in sequence.  See 23.3.6 of the C++

// standard, paragraphs 2-3, for an explanation of the sequence.  At

// each step we get two things: the ordinal (i.e. number of steps taken),

// and the one-dimensional index.

template <class _Size>

struct _Gslice_Iter_tmpl {

  _Gslice_Iter_tmpl(const gslice& __gslice)

    : _M_step(0), _M_1d_idx(__gslice.start()),

      _M_indices(size_t(0), __gslice._M_lengths.size()),

      _M_gslice(__gslice)

    {}

  bool _M_done() const { return _M_indices[0] == _M_gslice._M_lengths[0]; }

  bool _M_incr();

  _Size _M_step;

  _Size _M_1d_idx;

  valarray<_Size> _M_indices;

  const gslice& _M_gslice;

};

typedef _Gslice_Iter_tmpl<size_t> _Gslice_Iter;

template <class _Tp>

class gslice_array {

  friend class valarray<_Tp>;

public:

  typedef _Tp value_type;

  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 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 could be const but standard says NO (26.3.7.4-1)*/ {

    if (!_M_gslice._M_empty()) {

      _Gslice_Iter __i(_M_gslice);

      do _M_array[__i._M_1d_idx] = __c; while(__i._M_incr());

    }

  }

  // C++ Standard defect 253, copy constructor must be public.

  gslice_array(const gslice_array& __x)

    : _M_gslice(__x._M_gslice), _M_array(__x._M_array)

    {}

  ~gslice_array() {}

private:

  gslice_array(const gslice &__gslice, valarray<_Tp> &__array)

    : _M_gslice(__gslice), _M_array(__array)

    {}

  gslice                _M_gslice;

  valarray<value_type>& _M_array;

private:

  // Disable default constructor and assignment

  gslice_array();

  void operator=(const gslice_array<_Tp>&);

};

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

{

  uninitialized_fill_n(this->_M_first, this->_M_size, _Tp() );

  *this = __x;

}

template <class _Tp>

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

{ return gslice_array<_Tp>(__slice, *this); }

//----------------------------------------------------------------------

// mask_array

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

  }

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

  }

  // C++ Standard defect 253, copy constructor must be public.

  mask_array(const mask_array& __x)

    : _M_mask(__x._M_mask), _M_array(__x._M_array)

    {}

  ~mask_array() {}

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 default constructor and assignment

  mask_array();

  void operator=(const mask_array<_Tp>&);

};

// valarray member functions dealing with mask_array

template <class _Tp>

inline valarray<_Tp>::valarray(const mask_array<_Tp>& __x) :

    _Valarray_base<_Tp>(__x._M_num_true())

{

  uninitialized_fill_n(this->_M_first, this->_M_size, _Tp() );

  *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) {

  _STLP_ASSERT(__mask.size() == this->size())

  return mask_array<_Tp>(__mask, *this);

}

//----------------------------------------------------------------------

// indirect_array

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