1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/epoc32/include/tools/stlport/stl/_valarray.h Wed Mar 31 12:33:34 2010 +0100
1.3 @@ -0,0 +1,1665 @@
1.4 +/*
1.5 + * Copyright (c) 1999
1.6 + * Silicon Graphics Computer Systems, Inc.
1.7 + *
1.8 + * Copyright (c) 1999
1.9 + * Boris Fomitchev
1.10 + *
1.11 + * This material is provided "as is", with absolutely no warranty expressed
1.12 + * or implied. Any use is at your own risk.
1.13 + *
1.14 + * Permission to use or copy this software for any purpose is hereby granted
1.15 + * without fee, provided the above notices are retained on all copies.
1.16 + * Permission to modify the code and to distribute modified code is granted,
1.17 + * provided the above notices are retained, and a notice that the code was
1.18 + * modified is included with the above copyright notice.
1.19 + *
1.20 + */
1.21 +
1.22 +#ifndef _STLP_VALARRAY_H
1.23 +#define _STLP_VALARRAY_H
1.24 +
1.25 +#ifndef _STLP_INTERNAL_CMATH
1.26 +# include <stl/_cmath.h>
1.27 +#endif
1.28 +
1.29 +#ifndef _STLP_INTERNAL_NEW
1.30 +# include <stl/_new.h>
1.31 +#endif
1.32 +
1.33 +#ifndef _STLP_INTERNAL_ALGO_H
1.34 +# include <stl/_algo.h>
1.35 +#endif
1.36 +
1.37 +#ifndef _STLP_INTERNAL_NUMERIC_H
1.38 +# include <stl/_numeric.h>
1.39 +#endif
1.40 +
1.41 +#ifndef _STLP_INTERNAL_LIMITS
1.42 +# include <stl/_limits.h>
1.43 +#endif
1.44 +
1.45 +/* As we only need the _STLP_ASSERT macro from _debug.h we test it to include _debug.h */
1.46 +#ifndef _STLP_ASSERT
1.47 +# include <stl/debug/_debug.h>
1.48 +#endif
1.49 +
1.50 +_STLP_BEGIN_NAMESPACE
1.51 +
1.52 +class slice;
1.53 +class gslice;
1.54 +
1.55 +template <class _Tp> class valarray;
1.56 +typedef valarray<bool> _Valarray_bool;
1.57 +typedef valarray<size_t> _Valarray_size_t;
1.58 +
1.59 +template <class _Tp> class slice_array;
1.60 +template <class _Tp> class gslice_array;
1.61 +template <class _Tp> class mask_array;
1.62 +template <class _Tp> class indirect_array;
1.63 +
1.64 +//----------------------------------------------------------------------
1.65 +// class valarray
1.66 +
1.67 +// Base class to handle memory allocation and deallocation. We can't just
1.68 +// use vector<>, because vector<bool> would be unsuitable as an internal
1.69 +// representation for valarray<bool>.
1.70 +
1.71 +template <class _Tp>
1.72 +struct _Valarray_base
1.73 +{
1.74 + _Tp* _M_first;
1.75 + size_t _M_size;
1.76 +
1.77 + _Valarray_base() : _M_first(0), _M_size(0) {}
1.78 + _Valarray_base(size_t __n) : _M_first(0), _M_size(0) { _M_allocate(__n); }
1.79 + ~_Valarray_base() { _M_deallocate(); }
1.80 +
1.81 + void _M_allocate(size_t __n) {
1.82 + if (__n != 0) {
1.83 + _M_first = __STATIC_CAST(_Tp*, (malloc(__n * sizeof(_Tp))));
1.84 + _M_size = __n;
1.85 +#if !defined(_STLP_NO_BAD_ALLOC) && defined(_STLP_USE_EXCEPTIONS)
1.86 + if (_M_first == 0) {
1.87 + _M_size = 0;
1.88 + throw _STLP_STD::bad_alloc();
1.89 + }
1.90 +#endif
1.91 + }
1.92 + else {
1.93 + _M_first = 0;
1.94 + _M_size = 0;
1.95 + }
1.96 + }
1.97 +
1.98 + void _M_deallocate() {
1.99 + free(_M_first);
1.100 + _M_first = 0;
1.101 + _M_size = 0;
1.102 + }
1.103 +};
1.104 +
1.105 +template <class _Tp>
1.106 +class valarray : private _Valarray_base<_Tp>
1.107 +{
1.108 + friend class gslice;
1.109 +
1.110 +public:
1.111 + typedef _Tp value_type;
1.112 +
1.113 + // Basic constructors
1.114 + valarray() : _Valarray_base<_Tp>() {}
1.115 + explicit valarray(size_t __n) : _Valarray_base<_Tp>(__n)
1.116 + { uninitialized_fill_n(this->_M_first, this->_M_size, _STLP_DEFAULT_CONSTRUCTED(value_type)); }
1.117 + valarray(const value_type& __x, size_t __n) : _Valarray_base<_Tp>(__n)
1.118 + { uninitialized_fill_n(this->_M_first, this->_M_size, __x); }
1.119 + valarray(const value_type* __p, size_t __n) : _Valarray_base<_Tp>(__n)
1.120 + { uninitialized_copy(__p, __p + __n, this->_M_first); }
1.121 + valarray(const valarray<_Tp>& __x) : _Valarray_base<_Tp>(__x._M_size) {
1.122 + uninitialized_copy(__x._M_first, __x._M_first + __x._M_size,
1.123 + this->_M_first);
1.124 + }
1.125 +
1.126 + // Constructors from auxiliary array types
1.127 + valarray(const slice_array<_Tp>&);
1.128 + valarray(const gslice_array<_Tp>&);
1.129 + valarray(const mask_array<_Tp>&);
1.130 + valarray(const indirect_array<_Tp>&);
1.131 +
1.132 + // Destructor
1.133 + ~valarray() { _STLP_STD::_Destroy_Range(this->_M_first, this->_M_first + this->_M_size); }
1.134 +
1.135 + // Extension: constructor that doesn't initialize valarray elements to a
1.136 + // specific value. This is faster for types such as int and double.
1.137 +private:
1.138 + void _M_initialize(const __true_type&) {}
1.139 + void _M_initialize(const __false_type&)
1.140 + { uninitialized_fill_n(this->_M_first, this->_M_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
1.141 +
1.142 +public:
1.143 + struct _NoInit {};
1.144 + valarray(size_t __n, _NoInit) : _Valarray_base<_Tp>(__n) {
1.145 + typedef typename __type_traits<_Tp>::has_trivial_default_constructor _Is_Trivial;
1.146 + _M_initialize(_Is_Trivial());
1.147 + }
1.148 +
1.149 +public: // Assignment
1.150 + // Basic assignment. Note that 'x = y' is undefined if x.size() != y.size()
1.151 + valarray<_Tp>& operator=(const valarray<_Tp>& __x) {
1.152 + _STLP_ASSERT(__x.size() == this->size())
1.153 + if (this != &__x)
1.154 + copy(__x._M_first, __x._M_first + __x._M_size, this->_M_first);
1.155 + return *this;
1.156 + }
1.157 +
1.158 + // Scalar assignment
1.159 + valarray<_Tp>& operator=(const value_type& __x) {
1.160 + fill_n(this->_M_first, this->_M_size, __x);
1.161 + return *this;
1.162 + }
1.163 +
1.164 + // Assignment of auxiliary array types
1.165 + valarray<_Tp>& operator=(const slice_array<_Tp>&);
1.166 + valarray<_Tp>& operator=(const gslice_array<_Tp>&);
1.167 + valarray<_Tp>& operator=(const mask_array<_Tp>&);
1.168 + valarray<_Tp>& operator=(const indirect_array<_Tp>&);
1.169 +
1.170 +public: // Element access
1.171 + value_type operator[](size_t __n) const { return this->_M_first[__n]; }
1.172 + value_type& operator[](size_t __n) { return this->_M_first[__n]; }
1.173 + size_t size() const { return this->_M_size; }
1.174 +
1.175 +public: // Subsetting operations with auxiliary type
1.176 + valarray<_Tp> operator[](slice) const;
1.177 + slice_array<_Tp> operator[](slice);
1.178 + valarray<_Tp> operator[](const gslice&) const;
1.179 + gslice_array<_Tp> operator[](const gslice&);
1.180 + valarray<_Tp> operator[](const _Valarray_bool&) const;
1.181 + mask_array<_Tp> operator[](const _Valarray_bool&);
1.182 + valarray<_Tp> operator[](const _Valarray_size_t&) const;
1.183 + indirect_array<_Tp> operator[](const _Valarray_size_t&);
1.184 +
1.185 +public: // Unary operators.
1.186 + valarray<_Tp> operator+() const { return *this; }
1.187 +
1.188 + valarray<_Tp> operator-() const {
1.189 + valarray<_Tp> __tmp(this->size(), _NoInit());
1.190 + for (size_t __i = 0; __i < this->size(); ++__i)
1.191 + __tmp[__i] = -(*this)[__i];
1.192 + return __tmp;
1.193 + }
1.194 +
1.195 + valarray<_Tp> operator~() const {
1.196 + valarray<_Tp> __tmp(this->size(), _NoInit());
1.197 + for (size_t __i = 0; __i < this->size(); ++__i)
1.198 + __tmp[__i] = ~(*this)[__i];
1.199 + return __tmp;
1.200 + }
1.201 +
1.202 + _Valarray_bool operator!() const;
1.203 +
1.204 +public: // Scalar computed assignment.
1.205 + valarray<_Tp>& operator*= (const value_type& __x) {
1.206 + for (size_t __i = 0; __i < this->size(); ++__i)
1.207 + (*this)[__i] *= __x;
1.208 + return *this;
1.209 + }
1.210 +
1.211 + valarray<_Tp>& operator/= (const value_type& __x) {
1.212 + for (size_t __i = 0; __i < this->size(); ++__i)
1.213 + (*this)[__i] /= __x;
1.214 + return *this;
1.215 + }
1.216 +
1.217 + valarray<_Tp>& operator%= (const value_type& __x) {
1.218 + for (size_t __i = 0; __i < this->size(); ++__i)
1.219 + (*this)[__i] %= __x;
1.220 + return *this;
1.221 + }
1.222 +
1.223 + valarray<_Tp>& operator+= (const value_type& __x) {
1.224 + for (size_t __i = 0; __i < this->size(); ++__i)
1.225 + (*this)[__i] += __x;
1.226 + return *this;
1.227 + }
1.228 +
1.229 + valarray<_Tp>& operator-= (const value_type& __x) {
1.230 + for (size_t __i = 0; __i < this->size(); ++__i)
1.231 + (*this)[__i] -= __x;
1.232 + return *this;
1.233 + }
1.234 +
1.235 + valarray<_Tp>& operator^= (const value_type& __x) {
1.236 + for (size_t __i = 0; __i < this->size(); ++__i)
1.237 + (*this)[__i] ^= __x;
1.238 + return *this;
1.239 + }
1.240 +
1.241 + valarray<_Tp>& operator&= (const value_type& __x) {
1.242 + for (size_t __i = 0; __i < this->size(); ++__i)
1.243 + (*this)[__i] &= __x;
1.244 + return *this;
1.245 + }
1.246 +
1.247 + valarray<_Tp>& operator|= (const value_type& __x) {
1.248 + for (size_t __i = 0; __i < this->size(); ++__i)
1.249 + (*this)[__i] |= __x;
1.250 + return *this;
1.251 + }
1.252 +
1.253 + valarray<_Tp>& operator<<= (const value_type& __x) {
1.254 + for (size_t __i = 0; __i < this->size(); ++__i)
1.255 + (*this)[__i] <<= __x;
1.256 + return *this;
1.257 + }
1.258 +
1.259 + valarray<_Tp>& operator>>= (const value_type& __x) {
1.260 + for (size_t __i = 0; __i < this->size(); ++__i)
1.261 + (*this)[__i] >>= __x;
1.262 + return *this;
1.263 + }
1.264 +
1.265 +public: // Array computed assignment.
1.266 + valarray<_Tp>& operator*= (const valarray<_Tp>& __x) {
1.267 + for (size_t __i = 0; __i < this->size(); ++__i)
1.268 + (*this)[__i] *= __x[__i];
1.269 + return *this;
1.270 + }
1.271 +
1.272 + valarray<_Tp>& operator/= (const valarray<_Tp>& __x) {
1.273 + for (size_t __i = 0; __i < this->size(); ++__i)
1.274 + (*this)[__i] /= __x[__i];
1.275 + return *this;
1.276 + }
1.277 +
1.278 + valarray<_Tp>& operator%= (const valarray<_Tp>& __x) {
1.279 + for (size_t __i = 0; __i < this->size(); ++__i)
1.280 + (*this)[__i] %= __x[__i];
1.281 + return *this;
1.282 + }
1.283 +
1.284 + valarray<_Tp>& operator+= (const valarray<_Tp>& __x) {
1.285 + for (size_t __i = 0; __i < this->size(); ++__i)
1.286 + (*this)[__i] += __x[__i];
1.287 + return *this;
1.288 + }
1.289 +
1.290 + valarray<_Tp>& operator-= (const valarray<_Tp>& __x) {
1.291 + for (size_t __i = 0; __i < this->size(); ++__i)
1.292 + (*this)[__i] -= __x[__i];
1.293 + return *this;
1.294 + }
1.295 +
1.296 + valarray<_Tp>& operator^= (const valarray<_Tp>& __x) {
1.297 + for (size_t __i = 0; __i < this->size(); ++__i)
1.298 + (*this)[__i] ^= __x[__i];
1.299 + return *this;
1.300 + }
1.301 +
1.302 + valarray<_Tp>& operator&= (const valarray<_Tp>& __x) {
1.303 + for (size_t __i = 0; __i < this->size(); ++__i)
1.304 + (*this)[__i] &= __x[__i];
1.305 + return *this;
1.306 + }
1.307 +
1.308 + valarray<_Tp>& operator|= (const valarray<_Tp>& __x) {
1.309 + for (size_t __i = 0; __i < this->size(); ++__i)
1.310 + (*this)[__i] |= __x[__i];
1.311 + return *this;
1.312 + }
1.313 +
1.314 + valarray<_Tp>& operator<<= (const valarray<_Tp>& __x) {
1.315 + for (size_t __i = 0; __i < this->size(); ++__i)
1.316 + (*this)[__i] <<= __x[__i];
1.317 + return *this;
1.318 + }
1.319 +
1.320 + valarray<_Tp>& operator>>= (const valarray<_Tp>& __x) {
1.321 + for (size_t __i = 0; __i < this->size(); ++__i)
1.322 + (*this)[__i] >>= __x[__i];
1.323 + return *this;
1.324 + }
1.325 +
1.326 +public: // Other member functions.
1.327 +
1.328 + // The result is undefined for zero-length arrays
1.329 + value_type sum() const {
1.330 + return accumulate(this->_M_first + 1, this->_M_first + this->_M_size,
1.331 + (*this)[0]);
1.332 + }
1.333 +
1.334 + // The result is undefined for zero-length arrays
1.335 + value_type (min) () const {
1.336 + return *min_element(this->_M_first + 0, this->_M_first + this->_M_size);
1.337 + }
1.338 +
1.339 + value_type (max) () const {
1.340 + return *max_element(this->_M_first + 0, this->_M_first + this->_M_size);
1.341 + }
1.342 +
1.343 + valarray<_Tp> shift(int __n) const;
1.344 + valarray<_Tp> cshift(int __n) const;
1.345 +
1.346 + valarray<_Tp> apply(value_type __f(value_type)) const {
1.347 + valarray<_Tp> __tmp(this->size());
1.348 + transform(this->_M_first + 0, this->_M_first + this->_M_size, __tmp._M_first,
1.349 + __f);
1.350 + return __tmp;
1.351 + }
1.352 + valarray<_Tp> apply(value_type __f(const value_type&)) const {
1.353 + valarray<_Tp> __tmp(this->size());
1.354 + transform(this->_M_first + 0, this->_M_first + this->_M_size, __tmp._M_first,
1.355 + __f);
1.356 + return __tmp;
1.357 + }
1.358 +
1.359 + void resize(size_t __n, value_type __x = value_type()) {
1.360 + _STLP_STD::_Destroy_Range(this->_M_first, this->_M_first + this->_M_size);
1.361 + _Valarray_base<_Tp>::_M_deallocate();
1.362 + _Valarray_base<_Tp>::_M_allocate(__n);
1.363 + uninitialized_fill_n(this->_M_first, this->_M_size, __x);
1.364 + }
1.365 +};
1.366 +
1.367 +//----------------------------------------------------------------------
1.368 +// valarray non-member functions.
1.369 +
1.370 +// Binary arithmetic operations between two arrays. Behavior is
1.371 +// undefined if the two arrays do not have the same length.
1.372 +
1.373 +template <class _Tp>
1.374 +inline valarray<_Tp> _STLP_CALL operator*(const valarray<_Tp>& __x,
1.375 + const valarray<_Tp>& __y) {
1.376 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.377 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.378 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.379 + __tmp[__i] = __x[__i] * __y[__i];
1.380 + return __tmp;
1.381 +}
1.382 +
1.383 +template <class _Tp>
1.384 +inline valarray<_Tp> _STLP_CALL operator/(const valarray<_Tp>& __x,
1.385 + const valarray<_Tp>& __y) {
1.386 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.387 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.388 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.389 + __tmp[__i] = __x[__i] / __y[__i];
1.390 + return __tmp;
1.391 +}
1.392 +
1.393 +template <class _Tp>
1.394 +inline valarray<_Tp> _STLP_CALL operator%(const valarray<_Tp>& __x,
1.395 + const valarray<_Tp>& __y) {
1.396 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.397 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.398 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.399 + __tmp[__i] = __x[__i] % __y[__i];
1.400 + return __tmp;
1.401 +}
1.402 +
1.403 +template <class _Tp>
1.404 +inline valarray<_Tp> _STLP_CALL operator+(const valarray<_Tp>& __x,
1.405 + const valarray<_Tp>& __y) {
1.406 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.407 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.408 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.409 + __tmp[__i] = __x[__i] + __y[__i];
1.410 + return __tmp;
1.411 +}
1.412 +
1.413 +template <class _Tp>
1.414 +inline valarray<_Tp> _STLP_CALL operator-(const valarray<_Tp>& __x,
1.415 + const valarray<_Tp>& __y) {
1.416 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.417 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.418 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.419 + __tmp[__i] = __x[__i] - __y[__i];
1.420 + return __tmp;
1.421 +}
1.422 +
1.423 +template <class _Tp>
1.424 +inline valarray<_Tp> _STLP_CALL operator^(const valarray<_Tp>& __x,
1.425 + const valarray<_Tp>& __y) {
1.426 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.427 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.428 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.429 + __tmp[__i] = __x[__i] ^ __y[__i];
1.430 + return __tmp;
1.431 +}
1.432 +
1.433 +template <class _Tp>
1.434 +inline valarray<_Tp> _STLP_CALL operator&(const valarray<_Tp>& __x,
1.435 + const valarray<_Tp>& __y) {
1.436 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.437 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.438 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.439 + __tmp[__i] = __x[__i] & __y[__i];
1.440 + return __tmp;
1.441 +}
1.442 +
1.443 +template <class _Tp>
1.444 +inline valarray<_Tp> _STLP_CALL operator|(const valarray<_Tp>& __x,
1.445 + const valarray<_Tp>& __y) {
1.446 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.447 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.448 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.449 + __tmp[__i] = __x[__i] | __y[__i];
1.450 + return __tmp;
1.451 +}
1.452 +
1.453 +template <class _Tp>
1.454 +inline valarray<_Tp> _STLP_CALL operator<<(const valarray<_Tp>& __x,
1.455 + const valarray<_Tp>& __y) {
1.456 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.457 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.458 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.459 + __tmp[__i] = __x[__i] << __y[__i];
1.460 + return __tmp;
1.461 +}
1.462 +
1.463 +template <class _Tp>
1.464 +inline valarray<_Tp> _STLP_CALL operator>>(const valarray<_Tp>& __x,
1.465 + const valarray<_Tp>& __y) {
1.466 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.467 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.468 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.469 + __tmp[__i] = __x[__i] >> __y[__i];
1.470 + return __tmp;
1.471 +}
1.472 +
1.473 +// Binary arithmetic operations between an array and a scalar.
1.474 +
1.475 +template <class _Tp>
1.476 +inline valarray<_Tp> _STLP_CALL operator*(const valarray<_Tp>& __x, const _Tp& __c) {
1.477 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.478 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.479 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.480 + __tmp[__i] = __x[__i] * __c;
1.481 + return __tmp;
1.482 +}
1.483 +
1.484 +template <class _Tp>
1.485 +inline valarray<_Tp> _STLP_CALL operator*(const _Tp& __c, const valarray<_Tp>& __x) {
1.486 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.487 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.488 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.489 + __tmp[__i] = __c * __x[__i];
1.490 + return __tmp;
1.491 +}
1.492 +
1.493 +template <class _Tp>
1.494 +inline valarray<_Tp> _STLP_CALL operator/(const valarray<_Tp>& __x, const _Tp& __c) {
1.495 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.496 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.497 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.498 + __tmp[__i] = __x[__i] / __c;
1.499 + return __tmp;
1.500 +}
1.501 +
1.502 +template <class _Tp>
1.503 +inline valarray<_Tp> _STLP_CALL operator/(const _Tp& __c, const valarray<_Tp>& __x) {
1.504 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.505 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.506 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.507 + __tmp[__i] = __c / __x[__i];
1.508 + return __tmp;
1.509 +}
1.510 +
1.511 +template <class _Tp>
1.512 +inline valarray<_Tp> _STLP_CALL operator%(const valarray<_Tp>& __x, const _Tp& __c) {
1.513 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.514 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.515 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.516 + __tmp[__i] = __x[__i] % __c;
1.517 + return __tmp;
1.518 +}
1.519 +
1.520 +template <class _Tp>
1.521 +inline valarray<_Tp> _STLP_CALL operator%(const _Tp& __c, const valarray<_Tp>& __x) {
1.522 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.523 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.524 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.525 + __tmp[__i] = __c % __x[__i];
1.526 + return __tmp;
1.527 +}
1.528 +
1.529 +template <class _Tp>
1.530 +inline valarray<_Tp> _STLP_CALL operator+(const valarray<_Tp>& __x, const _Tp& __c) {
1.531 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.532 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.533 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.534 + __tmp[__i] = __x[__i] + __c;
1.535 + return __tmp;
1.536 +}
1.537 +
1.538 +template <class _Tp>
1.539 +inline valarray<_Tp> _STLP_CALL operator+(const _Tp& __c, const valarray<_Tp>& __x) {
1.540 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.541 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.542 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.543 + __tmp[__i] = __c + __x[__i];
1.544 + return __tmp;
1.545 +}
1.546 +
1.547 +template <class _Tp>
1.548 +inline valarray<_Tp> _STLP_CALL operator-(const valarray<_Tp>& __x, const _Tp& __c) {
1.549 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.550 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.551 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.552 + __tmp[__i] = __x[__i] - __c;
1.553 + return __tmp;
1.554 +}
1.555 +
1.556 +template <class _Tp>
1.557 +inline valarray<_Tp> _STLP_CALL operator-(const _Tp& __c, const valarray<_Tp>& __x) {
1.558 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.559 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.560 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.561 + __tmp[__i] = __c - __x[__i];
1.562 + return __tmp;
1.563 +}
1.564 +
1.565 +template <class _Tp>
1.566 +inline valarray<_Tp> _STLP_CALL operator^(const valarray<_Tp>& __x, const _Tp& __c) {
1.567 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.568 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.569 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.570 + __tmp[__i] = __x[__i] ^ __c;
1.571 + return __tmp;
1.572 +}
1.573 +
1.574 +template <class _Tp>
1.575 +inline valarray<_Tp> _STLP_CALL operator^(const _Tp& __c, const valarray<_Tp>& __x) {
1.576 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.577 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.578 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.579 + __tmp[__i] = __c ^ __x[__i];
1.580 + return __tmp;
1.581 +}
1.582 +
1.583 +template <class _Tp>
1.584 +inline valarray<_Tp> _STLP_CALL operator&(const valarray<_Tp>& __x, const _Tp& __c) {
1.585 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.586 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.587 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.588 + __tmp[__i] = __x[__i] & __c;
1.589 + return __tmp;
1.590 +}
1.591 +
1.592 +template <class _Tp>
1.593 +inline valarray<_Tp> _STLP_CALL operator&(const _Tp& __c, const valarray<_Tp>& __x) {
1.594 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.595 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.596 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.597 + __tmp[__i] = __c & __x[__i];
1.598 + return __tmp;
1.599 +}
1.600 +
1.601 +template <class _Tp>
1.602 +inline valarray<_Tp> _STLP_CALL operator|(const valarray<_Tp>& __x, const _Tp& __c) {
1.603 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.604 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.605 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.606 + __tmp[__i] = __x[__i] | __c;
1.607 + return __tmp;
1.608 +}
1.609 +
1.610 +template <class _Tp>
1.611 +inline valarray<_Tp> _STLP_CALL operator|(const _Tp& __c, const valarray<_Tp>& __x) {
1.612 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.613 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.614 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.615 + __tmp[__i] = __c | __x[__i];
1.616 + return __tmp;
1.617 +}
1.618 +
1.619 +template <class _Tp>
1.620 +inline valarray<_Tp> _STLP_CALL operator<<(const valarray<_Tp>& __x, const _Tp& __c) {
1.621 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.622 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.623 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.624 + __tmp[__i] = __x[__i] << __c;
1.625 + return __tmp;
1.626 +}
1.627 +
1.628 +template <class _Tp>
1.629 +inline valarray<_Tp> _STLP_CALL operator<<(const _Tp& __c, const valarray<_Tp>& __x) {
1.630 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.631 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.632 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.633 + __tmp[__i] = __c << __x[__i];
1.634 + return __tmp;
1.635 +}
1.636 +
1.637 +template <class _Tp>
1.638 +inline valarray<_Tp> _STLP_CALL operator>>(const valarray<_Tp>& __x, const _Tp& __c) {
1.639 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.640 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.641 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.642 + __tmp[__i] = __x[__i] >> __c;
1.643 + return __tmp;
1.644 +}
1.645 +
1.646 +template <class _Tp>
1.647 +inline valarray<_Tp> _STLP_CALL operator>>(const _Tp& __c, const valarray<_Tp>& __x) {
1.648 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.649 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.650 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.651 + __tmp[__i] = __c >> __x[__i];
1.652 + return __tmp;
1.653 +}
1.654 +
1.655 +// Binary logical operations between two arrays. Behavior is undefined
1.656 +// if the two arrays have different lengths. Note that operator== does
1.657 +// not do what you might at first expect.
1.658 +
1.659 +template <class _Tp>
1.660 +inline _Valarray_bool _STLP_CALL operator==(const valarray<_Tp>& __x,
1.661 + const valarray<_Tp>& __y)
1.662 +{
1.663 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.664 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.665 + __tmp[__i] = __x[__i] == __y[__i];
1.666 + return __tmp;
1.667 +}
1.668 +
1.669 +template <class _Tp>
1.670 +inline _Valarray_bool _STLP_CALL operator<(const valarray<_Tp>& __x,
1.671 + const valarray<_Tp>& __y)
1.672 +{
1.673 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.674 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.675 + __tmp[__i] = __x[__i] < __y[__i];
1.676 + return __tmp;
1.677 +}
1.678 +
1.679 +#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
1.680 +
1.681 +template <class _Tp>
1.682 +inline _Valarray_bool _STLP_CALL operator!=(const valarray<_Tp>& __x,
1.683 + const valarray<_Tp>& __y)
1.684 +{
1.685 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.686 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.687 + __tmp[__i] = __x[__i] != __y[__i];
1.688 + return __tmp;
1.689 +}
1.690 +
1.691 +template <class _Tp>
1.692 +inline _Valarray_bool _STLP_CALL operator>(const valarray<_Tp>& __x,
1.693 + const valarray<_Tp>& __y)
1.694 +{
1.695 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.696 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.697 + __tmp[__i] = __x[__i] > __y[__i];
1.698 + return __tmp;
1.699 +}
1.700 +
1.701 +template <class _Tp>
1.702 +inline _Valarray_bool _STLP_CALL operator<=(const valarray<_Tp>& __x,
1.703 + const valarray<_Tp>& __y)
1.704 +{
1.705 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.706 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.707 + __tmp[__i] = __x[__i] <= __y[__i];
1.708 + return __tmp;
1.709 +}
1.710 +
1.711 +template <class _Tp>
1.712 +inline _Valarray_bool _STLP_CALL operator>=(const valarray<_Tp>& __x,
1.713 + const valarray<_Tp>& __y)
1.714 +{
1.715 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.716 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.717 + __tmp[__i] = __x[__i] >= __y[__i];
1.718 + return __tmp;
1.719 +}
1.720 +
1.721 +#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
1.722 +// fbp : swap ?
1.723 +
1.724 +template <class _Tp>
1.725 +inline _Valarray_bool _STLP_CALL operator&&(const valarray<_Tp>& __x,
1.726 + const valarray<_Tp>& __y)
1.727 +{
1.728 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.729 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.730 + __tmp[__i] = __x[__i] && __y[__i];
1.731 + return __tmp;
1.732 +}
1.733 +
1.734 +template <class _Tp>
1.735 +inline _Valarray_bool _STLP_CALL operator||(const valarray<_Tp>& __x,
1.736 + const valarray<_Tp>& __y)
1.737 +{
1.738 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.739 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.740 + __tmp[__i] = __x[__i] || __y[__i];
1.741 + return __tmp;
1.742 +}
1.743 +
1.744 +// Logical operations between an array and a scalar.
1.745 +
1.746 +template <class _Tp>
1.747 +inline _Valarray_bool _STLP_CALL operator==(const valarray<_Tp>& __x, const _Tp& __c)
1.748 +{
1.749 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.750 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.751 + __tmp[__i] = __x[__i] == __c;
1.752 + return __tmp;
1.753 +}
1.754 +
1.755 +template <class _Tp>
1.756 +inline _Valarray_bool _STLP_CALL operator==(const _Tp& __c, const valarray<_Tp>& __x)
1.757 +{
1.758 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.759 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.760 + __tmp[__i] = __c == __x[__i];
1.761 + return __tmp;
1.762 +}
1.763 +
1.764 +template <class _Tp>
1.765 +inline _Valarray_bool _STLP_CALL operator!=(const valarray<_Tp>& __x, const _Tp& __c)
1.766 +{
1.767 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.768 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.769 + __tmp[__i] = __x[__i] != __c;
1.770 + return __tmp;
1.771 +}
1.772 +
1.773 +template <class _Tp>
1.774 +inline _Valarray_bool _STLP_CALL operator!=(const _Tp& __c, const valarray<_Tp>& __x)
1.775 +{
1.776 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.777 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.778 + __tmp[__i] = __c != __x[__i];
1.779 + return __tmp;
1.780 +}
1.781 +
1.782 +template <class _Tp>
1.783 +inline _Valarray_bool _STLP_CALL operator<(const valarray<_Tp>& __x, const _Tp& __c)
1.784 +{
1.785 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.786 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.787 + __tmp[__i] = __x[__i] < __c;
1.788 + return __tmp;
1.789 +}
1.790 +
1.791 +template <class _Tp>
1.792 +inline _Valarray_bool _STLP_CALL operator<(const _Tp& __c, const valarray<_Tp>& __x)
1.793 +{
1.794 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.795 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.796 + __tmp[__i] = __c < __x[__i];
1.797 + return __tmp;
1.798 +}
1.799 +
1.800 +template <class _Tp>
1.801 +inline _Valarray_bool _STLP_CALL operator>(const valarray<_Tp>& __x, const _Tp& __c)
1.802 +{
1.803 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.804 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.805 + __tmp[__i] = __x[__i] > __c;
1.806 + return __tmp;
1.807 +}
1.808 +
1.809 +template <class _Tp>
1.810 +inline _Valarray_bool _STLP_CALL operator>(const _Tp& __c, const valarray<_Tp>& __x)
1.811 +{
1.812 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.813 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.814 + __tmp[__i] = __c > __x[__i];
1.815 + return __tmp;
1.816 +}
1.817 +
1.818 +template <class _Tp>
1.819 +inline _Valarray_bool _STLP_CALL operator<=(const valarray<_Tp>& __x, const _Tp& __c)
1.820 +{
1.821 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.822 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.823 + __tmp[__i] = __x[__i] <= __c;
1.824 + return __tmp;
1.825 +}
1.826 +
1.827 +template <class _Tp>
1.828 +inline _Valarray_bool _STLP_CALL operator<=(const _Tp& __c, const valarray<_Tp>& __x)
1.829 +{
1.830 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.831 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.832 + __tmp[__i] = __c <= __x[__i];
1.833 + return __tmp;
1.834 +}
1.835 +
1.836 +template <class _Tp>
1.837 +inline _Valarray_bool _STLP_CALL operator>=(const valarray<_Tp>& __x, const _Tp& __c)
1.838 +{
1.839 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.840 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.841 + __tmp[__i] = __x[__i] >= __c;
1.842 + return __tmp;
1.843 +}
1.844 +
1.845 +template <class _Tp>
1.846 +inline _Valarray_bool _STLP_CALL operator>=(const _Tp& __c, const valarray<_Tp>& __x)
1.847 +{
1.848 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.849 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.850 + __tmp[__i] = __c >= __x[__i];
1.851 + return __tmp;
1.852 +}
1.853 +
1.854 +template <class _Tp>
1.855 +inline _Valarray_bool _STLP_CALL operator&&(const valarray<_Tp>& __x, const _Tp& __c)
1.856 +{
1.857 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.858 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.859 + __tmp[__i] = __x[__i] && __c;
1.860 + return __tmp;
1.861 +}
1.862 +
1.863 +template <class _Tp>
1.864 +inline _Valarray_bool _STLP_CALL operator&&(const _Tp& __c, const valarray<_Tp>& __x)
1.865 +{
1.866 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.867 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.868 + __tmp[__i] = __c && __x[__i];
1.869 + return __tmp;
1.870 +}
1.871 +
1.872 +template <class _Tp>
1.873 +inline _Valarray_bool _STLP_CALL operator||(const valarray<_Tp>& __x, const _Tp& __c)
1.874 +{
1.875 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.876 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.877 + __tmp[__i] = __x[__i] || __c;
1.878 + return __tmp;
1.879 +}
1.880 +
1.881 +template <class _Tp>
1.882 +inline _Valarray_bool _STLP_CALL operator||(const _Tp& __c, const valarray<_Tp>& __x)
1.883 +{
1.884 + _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
1.885 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.886 + __tmp[__i] = __c || __x[__i];
1.887 + return __tmp;
1.888 +}
1.889 +
1.890 +// valarray "transcendentals" (the list includes abs and sqrt, which,
1.891 +// of course, are not transcendental).
1.892 +
1.893 +template <class _Tp>
1.894 +inline valarray<_Tp> abs(const valarray<_Tp>& __x) {
1.895 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.896 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.897 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.898 + __tmp[__i] = ::abs(__x[__i]);
1.899 + return __tmp;
1.900 +}
1.901 +
1.902 +template <class _Tp>
1.903 +inline valarray<_Tp> acos(const valarray<_Tp>& __x) {
1.904 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.905 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.906 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.907 + __tmp[__i] = ::acos(__x[__i]);
1.908 + return __tmp;
1.909 +}
1.910 +
1.911 +template <class _Tp>
1.912 +inline valarray<_Tp> asin(const valarray<_Tp>& __x) {
1.913 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.914 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.915 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.916 + __tmp[__i] = ::asin(__x[__i]);
1.917 + return __tmp;
1.918 +}
1.919 +
1.920 +template <class _Tp>
1.921 +inline valarray<_Tp> atan(const valarray<_Tp>& __x) {
1.922 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.923 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.924 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.925 + __tmp[__i] = ::atan(__x[__i]);
1.926 + return __tmp;
1.927 +}
1.928 +
1.929 +template <class _Tp>
1.930 +inline valarray<_Tp> atan2(const valarray<_Tp>& __x,
1.931 + const valarray<_Tp>& __y) {
1.932 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.933 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.934 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.935 + __tmp[__i] = ::atan2(__x[__i], __y[__i]);
1.936 + return __tmp;
1.937 +}
1.938 +
1.939 +template <class _Tp>
1.940 +inline valarray<_Tp> atan2(const valarray<_Tp>& __x, const _Tp& __c) {
1.941 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.942 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.943 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.944 + __tmp[__i] = ::atan2(__x[__i], __c);
1.945 + return __tmp;
1.946 +}
1.947 +
1.948 +template <class _Tp>
1.949 +inline valarray<_Tp> atan2(const _Tp& __c, const valarray<_Tp>& __x) {
1.950 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.951 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.952 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.953 + __tmp[__i] = ::atan2(__c, __x[__i]);
1.954 + return __tmp;
1.955 +}
1.956 +
1.957 +template <class _Tp>
1.958 +inline valarray<_Tp> cos(const valarray<_Tp>& __x) {
1.959 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.960 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.961 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.962 + __tmp[__i] = ::cos(__x[__i]);
1.963 + return __tmp;
1.964 +}
1.965 +
1.966 +template <class _Tp>
1.967 +inline valarray<_Tp> cosh(const valarray<_Tp>& __x) {
1.968 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.969 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.970 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.971 + __tmp[__i] = ::cosh(__x[__i]);
1.972 + return __tmp;
1.973 +}
1.974 +
1.975 +template <class _Tp>
1.976 +inline valarray<_Tp> exp(const valarray<_Tp>& __x) {
1.977 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.978 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.979 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.980 + __tmp[__i] = ::exp(__x[__i]);
1.981 + return __tmp;
1.982 +}
1.983 +
1.984 +template <class _Tp>
1.985 +inline valarray<_Tp> log(const valarray<_Tp>& __x) {
1.986 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.987 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.988 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.989 + __tmp[__i] = ::log(__x[__i]);
1.990 + return __tmp;
1.991 +}
1.992 +
1.993 +template <class _Tp>
1.994 +inline valarray<_Tp> log10(const valarray<_Tp>& __x) {
1.995 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.996 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.997 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.998 + __tmp[__i] = ::log10(__x[__i]);
1.999 + return __tmp;
1.1000 +}
1.1001 +
1.1002 +template <class _Tp>
1.1003 +inline valarray<_Tp> pow(const valarray<_Tp>& __x,
1.1004 + const valarray<_Tp>& __y) {
1.1005 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.1006 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.1007 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.1008 + __tmp[__i] = ::pow(__x[__i], __y[__i]);
1.1009 + return __tmp;
1.1010 +}
1.1011 +
1.1012 +template <class _Tp>
1.1013 +inline valarray<_Tp> pow(const valarray<_Tp>& __x, const _Tp& __c) {
1.1014 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.1015 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.1016 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.1017 + __tmp[__i] = ::pow(__x[__i], __c);
1.1018 + return __tmp;
1.1019 +}
1.1020 +
1.1021 +template <class _Tp>
1.1022 +inline valarray<_Tp> pow(const _Tp& __c, const valarray<_Tp>& __x) {
1.1023 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.1024 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.1025 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.1026 + __tmp[__i] = ::pow(__c, __x[__i]);
1.1027 + return __tmp;
1.1028 +}
1.1029 +
1.1030 +template <class _Tp>
1.1031 +inline valarray<_Tp> sin(const valarray<_Tp>& __x) {
1.1032 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.1033 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.1034 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.1035 + __tmp[__i] = ::sin(__x[__i]);
1.1036 + return __tmp;
1.1037 +}
1.1038 +
1.1039 +template <class _Tp>
1.1040 +inline valarray<_Tp> sinh(const valarray<_Tp>& __x) {
1.1041 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.1042 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.1043 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.1044 + __tmp[__i] = ::sinh(__x[__i]);
1.1045 + return __tmp;
1.1046 +}
1.1047 +
1.1048 +template <class _Tp>
1.1049 +inline valarray<_Tp> sqrt(const valarray<_Tp>& __x) {
1.1050 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.1051 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.1052 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.1053 + __tmp[__i] = ::sqrt(__x[__i]);
1.1054 + return __tmp;
1.1055 +}
1.1056 +
1.1057 +template <class _Tp>
1.1058 +inline valarray<_Tp> tan(const valarray<_Tp>& __x) {
1.1059 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.1060 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.1061 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.1062 + __tmp[__i] = ::tan(__x[__i]);
1.1063 + return __tmp;
1.1064 +}
1.1065 +
1.1066 +template <class _Tp>
1.1067 +inline valarray<_Tp> tanh(const valarray<_Tp>& __x) {
1.1068 + typedef typename valarray<_Tp>::_NoInit _NoInit;
1.1069 + valarray<_Tp> __tmp(__x.size(), _NoInit());
1.1070 + for (size_t __i = 0; __i < __x.size(); ++__i)
1.1071 + __tmp[__i] = ::tanh(__x[__i]);
1.1072 + return __tmp;
1.1073 +}
1.1074 +
1.1075 +//----------------------------------------------------------------------
1.1076 +// slice and slice_array
1.1077 +
1.1078 +class slice {
1.1079 +public:
1.1080 + slice() : _M_start(0), _M_length(0), _M_stride(0) {}
1.1081 + slice(size_t __start, size_t __length, size_t __stride)
1.1082 + : _M_start(__start), _M_length(__length), _M_stride(__stride)
1.1083 + {}
1.1084 + __TRIVIAL_DESTRUCTOR(slice)
1.1085 +
1.1086 + size_t start() const { return _M_start; }
1.1087 + size_t size() const { return _M_length; }
1.1088 + size_t stride() const { return _M_stride; }
1.1089 +
1.1090 +private:
1.1091 + size_t _M_start;
1.1092 + size_t _M_length;
1.1093 + size_t _M_stride;
1.1094 +};
1.1095 +
1.1096 +template <class _Tp>
1.1097 +class slice_array {
1.1098 + friend class valarray<_Tp>;
1.1099 +public:
1.1100 + typedef _Tp value_type;
1.1101 +
1.1102 + void operator=(const valarray<value_type>& __x) const {
1.1103 + size_t __index = _M_slice.start();
1.1104 + for (size_t __i = 0;
1.1105 + __i < _M_slice.size();
1.1106 + ++__i, __index += _M_slice.stride())
1.1107 + _M_array[__index] = __x[__i];
1.1108 + }
1.1109 +
1.1110 + void operator*=(const valarray<value_type>& __x) const {
1.1111 + size_t __index = _M_slice.start();
1.1112 + for (size_t __i = 0;
1.1113 + __i < _M_slice.size();
1.1114 + ++__i, __index += _M_slice.stride())
1.1115 + _M_array[__index] *= __x[__i];
1.1116 + }
1.1117 +
1.1118 + void operator/=(const valarray<value_type>& __x) const {
1.1119 + size_t __index = _M_slice.start();
1.1120 + for (size_t __i = 0;
1.1121 + __i < _M_slice.size();
1.1122 + ++__i, __index += _M_slice.stride())
1.1123 + _M_array[__index] /= __x[__i];
1.1124 + }
1.1125 +
1.1126 + void operator%=(const valarray<value_type>& __x) const {
1.1127 + size_t __index = _M_slice.start();
1.1128 + for (size_t __i = 0;
1.1129 + __i < _M_slice.size();
1.1130 + ++__i, __index += _M_slice.stride())
1.1131 + _M_array[__index] %= __x[__i];
1.1132 + }
1.1133 +
1.1134 + void operator+=(const valarray<value_type>& __x) const {
1.1135 + size_t __index = _M_slice.start();
1.1136 + for (size_t __i = 0;
1.1137 + __i < _M_slice.size();
1.1138 + ++__i, __index += _M_slice.stride())
1.1139 + _M_array[__index] += __x[__i];
1.1140 + }
1.1141 +
1.1142 + void operator-=(const valarray<value_type>& __x) const {
1.1143 + size_t __index = _M_slice.start();
1.1144 + for (size_t __i = 0;
1.1145 + __i < _M_slice.size();
1.1146 + ++__i, __index += _M_slice.stride())
1.1147 + _M_array[__index] -= __x[__i];
1.1148 + }
1.1149 +
1.1150 + void operator^=(const valarray<value_type>& __x) const {
1.1151 + size_t __index = _M_slice.start();
1.1152 + for (size_t __i = 0;
1.1153 + __i < _M_slice.size();
1.1154 + ++__i, __index += _M_slice.stride())
1.1155 + _M_array[__index] ^= __x[__i];
1.1156 + }
1.1157 +
1.1158 + void operator&=(const valarray<value_type>& __x) const {
1.1159 + size_t __index = _M_slice.start();
1.1160 + for (size_t __i = 0;
1.1161 + __i < _M_slice.size();
1.1162 + ++__i, __index += _M_slice.stride())
1.1163 + _M_array[__index] &= __x[__i];
1.1164 + }
1.1165 +
1.1166 + void operator|=(const valarray<value_type>& __x) const {
1.1167 + size_t __index = _M_slice.start();
1.1168 + for (size_t __i = 0;
1.1169 + __i < _M_slice.size();
1.1170 + ++__i, __index += _M_slice.stride())
1.1171 + _M_array[__index] |= __x[__i];
1.1172 + }
1.1173 +
1.1174 + void operator<<=(const valarray<value_type>& __x) const {
1.1175 + size_t __index = _M_slice.start();
1.1176 + for (size_t __i = 0;
1.1177 + __i < _M_slice.size();
1.1178 + ++__i, __index += _M_slice.stride())
1.1179 + _M_array[__index] <<= __x[__i];
1.1180 + }
1.1181 +
1.1182 + void operator>>=(const valarray<value_type>& __x) const {
1.1183 + size_t __index = _M_slice.start();
1.1184 + for (size_t __i = 0;
1.1185 + __i < _M_slice.size();
1.1186 + ++__i, __index += _M_slice.stride())
1.1187 + _M_array[__index] >>= __x[__i];
1.1188 + }
1.1189 +
1.1190 + void operator=(const value_type& __c) /*const could be const but standard says NO (26.3.5.4-1)*/ {
1.1191 + size_t __index = _M_slice.start();
1.1192 + for (size_t __i = 0;
1.1193 + __i < _M_slice.size();
1.1194 + ++__i, __index += _M_slice.stride())
1.1195 + _M_array[__index] = __c;
1.1196 + }
1.1197 +
1.1198 + ~slice_array() {}
1.1199 +
1.1200 +private:
1.1201 + slice_array(const slice& __slice, valarray<_Tp>& __array)
1.1202 + : _M_slice(__slice), _M_array(__array)
1.1203 + {}
1.1204 +
1.1205 + slice _M_slice;
1.1206 + valarray<_Tp>& _M_array;
1.1207 +
1.1208 +private: // Disable assignment and default constructor
1.1209 + slice_array();
1.1210 + slice_array(const slice_array&);
1.1211 + slice_array& operator=(const slice_array&);
1.1212 +};
1.1213 +
1.1214 +// valarray member functions dealing with slice and slice_array
1.1215 +
1.1216 +template <class _Tp>
1.1217 +inline valarray<_Tp>::valarray(const slice_array<_Tp>& __x)
1.1218 + : _Valarray_base<_Tp>(__x._M_slice.size()) {
1.1219 + typedef typename __type_traits<_Tp>::has_trivial_default_constructor
1.1220 + _Is_Trivial;
1.1221 + _M_initialize(_Is_Trivial());
1.1222 + *this = __x;
1.1223 +}
1.1224 +
1.1225 +
1.1226 +template <class _Tp>
1.1227 +inline slice_array<_Tp> valarray<_Tp>::operator[](slice __slice) {
1.1228 + return slice_array<_Tp>(__slice, *this);
1.1229 +}
1.1230 +
1.1231 +//----------------------------------------------------------------------
1.1232 +// gslice and gslice_array
1.1233 +
1.1234 +template <class _Size>
1.1235 +struct _Gslice_Iter_tmpl;
1.1236 +
1.1237 +class gslice {
1.1238 + friend struct _Gslice_Iter_tmpl<size_t>;
1.1239 +public:
1.1240 + gslice() : _M_start(0), _M_lengths(0), _M_strides(0) {}
1.1241 + gslice(size_t __start,
1.1242 + const _Valarray_size_t& __lengths, const _Valarray_size_t& __strides)
1.1243 + : _M_start(__start), _M_lengths(__lengths), _M_strides(__strides)
1.1244 + {}
1.1245 + __TRIVIAL_DESTRUCTOR(gslice)
1.1246 +
1.1247 + size_t start() const { return _M_start; }
1.1248 + _Valarray_size_t size() const { return _M_lengths; }
1.1249 + _Valarray_size_t stride() const { return _M_strides; }
1.1250 +
1.1251 + // Extension: check for an empty gslice.
1.1252 + bool _M_empty() const { return _M_lengths.size() == 0; }
1.1253 +
1.1254 + // Extension: number of indices this gslice represents. (For a degenerate
1.1255 + // gslice, they're not necessarily all distinct.)
1.1256 + size_t _M_size() const {
1.1257 + return !this->_M_empty()
1.1258 + ? accumulate(_M_lengths._M_first + 1,
1.1259 + _M_lengths._M_first + _M_lengths._M_size,
1.1260 + _M_lengths[0],
1.1261 + multiplies<size_t>())
1.1262 + : 0;
1.1263 + }
1.1264 +
1.1265 +# ifndef __HP_aCC
1.1266 +private:
1.1267 +# endif
1.1268 +
1.1269 + size_t _M_start;
1.1270 + _Valarray_size_t _M_lengths;
1.1271 + _Valarray_size_t _M_strides;
1.1272 +};
1.1273 +
1.1274 +// This is not an STL iterator. It is constructed from a gslice, and it
1.1275 +// steps through the gslice indices in sequence. See 23.3.6 of the C++
1.1276 +// standard, paragraphs 2-3, for an explanation of the sequence. At
1.1277 +// each step we get two things: the ordinal (i.e. number of steps taken),
1.1278 +// and the one-dimensional index.
1.1279 +
1.1280 +template <class _Size>
1.1281 +struct _Gslice_Iter_tmpl {
1.1282 + _Gslice_Iter_tmpl(const gslice& __gslice)
1.1283 + : _M_step(0), _M_1d_idx(__gslice.start()),
1.1284 + _M_indices(size_t(0), __gslice._M_lengths.size()),
1.1285 + _M_gslice(__gslice)
1.1286 + {}
1.1287 +
1.1288 + bool _M_done() const { return _M_indices[0] == _M_gslice._M_lengths[0]; }
1.1289 +
1.1290 + bool _M_incr();
1.1291 +
1.1292 + _Size _M_step;
1.1293 + _Size _M_1d_idx;
1.1294 +
1.1295 + valarray<_Size> _M_indices;
1.1296 + const gslice& _M_gslice;
1.1297 +};
1.1298 +
1.1299 +typedef _Gslice_Iter_tmpl<size_t> _Gslice_Iter;
1.1300 +
1.1301 +template <class _Tp>
1.1302 +class gslice_array {
1.1303 + friend class valarray<_Tp>;
1.1304 +public:
1.1305 + typedef _Tp value_type;
1.1306 +
1.1307 + void operator= (const valarray<value_type>& __x) const {
1.1308 + if (!_M_gslice._M_empty()) {
1.1309 + _Gslice_Iter __i(_M_gslice);
1.1310 + do _M_array[__i._M_1d_idx] = __x[__i._M_step]; while(__i._M_incr());
1.1311 + }
1.1312 + }
1.1313 +
1.1314 + void operator*= (const valarray<value_type>& __x) const {
1.1315 + if (!_M_gslice._M_empty()) {
1.1316 + _Gslice_Iter __i(_M_gslice);
1.1317 + do _M_array[__i._M_1d_idx] *= __x[__i._M_step]; while(__i._M_incr());
1.1318 + }
1.1319 + }
1.1320 +
1.1321 + void operator/= (const valarray<value_type>& __x) const {
1.1322 + if (!_M_gslice._M_empty()) {
1.1323 + _Gslice_Iter __i(_M_gslice);
1.1324 + do _M_array[__i._M_1d_idx] /= __x[__i._M_step]; while(__i._M_incr());
1.1325 + }
1.1326 + }
1.1327 +
1.1328 + void operator%= (const valarray<value_type>& __x) const {
1.1329 + if (!_M_gslice._M_empty()) {
1.1330 + _Gslice_Iter __i(_M_gslice);
1.1331 + do _M_array[__i._M_1d_idx] %= __x[__i._M_step]; while(__i._M_incr());
1.1332 + }
1.1333 + }
1.1334 +
1.1335 + void operator+= (const valarray<value_type>& __x) const {
1.1336 + if (!_M_gslice._M_empty()) {
1.1337 + _Gslice_Iter __i(_M_gslice);
1.1338 + do _M_array[__i._M_1d_idx] += __x[__i._M_step]; while(__i._M_incr());
1.1339 + }
1.1340 + }
1.1341 +
1.1342 + void operator-= (const valarray<value_type>& __x) const {
1.1343 + if (!_M_gslice._M_empty()) {
1.1344 + _Gslice_Iter __i(_M_gslice);
1.1345 + do _M_array[__i._M_1d_idx] -= __x[__i._M_step]; while(__i._M_incr());
1.1346 + }
1.1347 + }
1.1348 +
1.1349 + void operator^= (const valarray<value_type>& __x) const {
1.1350 + if (!_M_gslice._M_empty()) {
1.1351 + _Gslice_Iter __i(_M_gslice);
1.1352 + do _M_array[__i._M_1d_idx] ^= __x[__i._M_step]; while(__i._M_incr());
1.1353 + }
1.1354 + }
1.1355 +
1.1356 + void operator&= (const valarray<value_type>& __x) const {
1.1357 + if (!_M_gslice._M_empty()) {
1.1358 + _Gslice_Iter __i(_M_gslice);
1.1359 + do _M_array[__i._M_1d_idx] &= __x[__i._M_step]; while(__i._M_incr());
1.1360 + }
1.1361 + }
1.1362 +
1.1363 + void operator|= (const valarray<value_type>& __x) const {
1.1364 + if (!_M_gslice._M_empty()) {
1.1365 + _Gslice_Iter __i(_M_gslice);
1.1366 + do _M_array[__i._M_1d_idx] |= __x[__i._M_step]; while(__i._M_incr());
1.1367 + }
1.1368 + }
1.1369 +
1.1370 + void operator<<= (const valarray<value_type>& __x) const {
1.1371 + if (!_M_gslice._M_empty()) {
1.1372 + _Gslice_Iter __i(_M_gslice);
1.1373 + do _M_array[__i._M_1d_idx] <<= __x[__i._M_step]; while(__i._M_incr());
1.1374 + }
1.1375 + }
1.1376 +
1.1377 + void operator>>= (const valarray<value_type>& __x) const {
1.1378 + if (!_M_gslice._M_empty()) {
1.1379 + _Gslice_Iter __i(_M_gslice);
1.1380 + do _M_array[__i._M_1d_idx] >>= __x[__i._M_step]; while(__i._M_incr());
1.1381 + }
1.1382 + }
1.1383 +
1.1384 + void operator= (const value_type& __c) /*const could be const but standard says NO (26.3.7.4-1)*/ {
1.1385 + if (!_M_gslice._M_empty()) {
1.1386 + _Gslice_Iter __i(_M_gslice);
1.1387 + do _M_array[__i._M_1d_idx] = __c; while(__i._M_incr());
1.1388 + }
1.1389 + }
1.1390 +
1.1391 + ~gslice_array() {}
1.1392 +
1.1393 +private:
1.1394 + gslice_array(const gslice& __gslice, valarray<_Tp>& __array)
1.1395 + : _M_gslice(__gslice), _M_array(__array)
1.1396 + {}
1.1397 +
1.1398 + gslice _M_gslice;
1.1399 + valarray<value_type>& _M_array;
1.1400 +
1.1401 +private: // Disable assignment
1.1402 + void operator=(const gslice_array<_Tp>&);
1.1403 +};
1.1404 +
1.1405 +// valarray member functions dealing with gslice and gslice_array. Note
1.1406 +// that it is illegal (behavior is undefined) to construct a gslice_array
1.1407 +// from a degenerate gslice.
1.1408 +
1.1409 +template <class _Tp>
1.1410 +inline valarray<_Tp>::valarray(const gslice_array<_Tp>& __x)
1.1411 + : _Valarray_base<_Tp>(__x._M_gslice._M_size()) {
1.1412 + typedef typename __type_traits<_Tp>::has_trivial_default_constructor
1.1413 + _Is_Trivial;
1.1414 + _M_initialize(_Is_Trivial());
1.1415 + *this = __x;
1.1416 +}
1.1417 +
1.1418 +template <class _Tp>
1.1419 +inline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __slice) {
1.1420 + return gslice_array<_Tp>(__slice, *this);
1.1421 +}
1.1422 +
1.1423 +
1.1424 +//----------------------------------------------------------------------
1.1425 +// mask_array
1.1426 +
1.1427 +template <class _Tp>
1.1428 +class mask_array {
1.1429 + friend class valarray<_Tp>;
1.1430 +public:
1.1431 + typedef _Tp value_type;
1.1432 +
1.1433 + void operator=(const valarray<value_type>& __x) const {
1.1434 + size_t __idx = 0;
1.1435 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1436 + if (_M_mask[__i]) _M_array[__i] = __x[__idx++];
1.1437 + }
1.1438 +
1.1439 + void operator*=(const valarray<value_type>& __x) const {
1.1440 + size_t __idx = 0;
1.1441 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1442 + if (_M_mask[__i]) _M_array[__i] *= __x[__idx++];
1.1443 + }
1.1444 +
1.1445 + void operator/=(const valarray<value_type>& __x) const {
1.1446 + size_t __idx = 0;
1.1447 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1448 + if (_M_mask[__i]) _M_array[__i] /= __x[__idx++];
1.1449 + }
1.1450 +
1.1451 + void operator%=(const valarray<value_type>& __x) const {
1.1452 + size_t __idx = 0;
1.1453 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1454 + if (_M_mask[__i]) _M_array[__i] %= __x[__idx++];
1.1455 + }
1.1456 +
1.1457 + void operator+=(const valarray<value_type>& __x) const {
1.1458 + size_t __idx = 0;
1.1459 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1460 + if (_M_mask[__i]) _M_array[__i] += __x[__idx++];
1.1461 + }
1.1462 +
1.1463 + void operator-=(const valarray<value_type>& __x) const {
1.1464 + size_t __idx = 0;
1.1465 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1466 + if (_M_mask[__i]) _M_array[__i] -= __x[__idx++];
1.1467 + }
1.1468 +
1.1469 + void operator^=(const valarray<value_type>& __x) const {
1.1470 + size_t __idx = 0;
1.1471 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1472 + if (_M_mask[__i]) _M_array[__i] ^= __x[__idx++];
1.1473 + }
1.1474 +
1.1475 + void operator&=(const valarray<value_type>& __x) const {
1.1476 + size_t __idx = 0;
1.1477 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1478 + if (_M_mask[__i]) _M_array[__i] &= __x[__idx++];
1.1479 + }
1.1480 +
1.1481 + void operator|=(const valarray<value_type>& __x) const {
1.1482 + size_t __idx = 0;
1.1483 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1484 + if (_M_mask[__i]) _M_array[__i] |= __x[__idx++];
1.1485 + }
1.1486 +
1.1487 + void operator<<=(const valarray<value_type>& __x) const {
1.1488 + size_t __idx = 0;
1.1489 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1490 + if (_M_mask[__i]) _M_array[__i] <<= __x[__idx++];
1.1491 + }
1.1492 +
1.1493 + void operator>>=(const valarray<value_type>& __x) const {
1.1494 + size_t __idx = 0;
1.1495 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1496 + if (_M_mask[__i]) _M_array[__i] >>= __x[__idx++];
1.1497 + }
1.1498 +
1.1499 + void operator=(const value_type& __c) const {
1.1500 + for (size_t __i = 0; __i < _M_array.size(); ++__i)
1.1501 + if (_M_mask[__i]) _M_array[__i] = __c;
1.1502 + }
1.1503 +
1.1504 + ~mask_array() {}
1.1505 +
1.1506 + // Extension: number of true values in the mask
1.1507 + size_t _M_num_true() const {
1.1508 + size_t __result = 0;
1.1509 + for (size_t __i = 0; __i < _M_mask.size(); ++__i)
1.1510 + if (_M_mask[__i]) ++__result;
1.1511 + return __result;
1.1512 + }
1.1513 +
1.1514 +private:
1.1515 + mask_array(const _Valarray_bool& __mask, valarray<_Tp>& __array)
1.1516 + : _M_mask(__mask), _M_array(__array)
1.1517 + {}
1.1518 +
1.1519 + _Valarray_bool _M_mask;
1.1520 + valarray<_Tp>& _M_array;
1.1521 +
1.1522 +private: // Disable assignment
1.1523 + void operator=(const mask_array<_Tp>&);
1.1524 +};
1.1525 +
1.1526 +// valarray member functions dealing with mask_array
1.1527 +
1.1528 +template <class _Tp>
1.1529 +inline valarray<_Tp>::valarray(const mask_array<_Tp>& __x)
1.1530 + : _Valarray_base<_Tp>(__x._M_num_true())
1.1531 +{
1.1532 + typedef typename __type_traits<_Tp>::has_trivial_default_constructor
1.1533 + _Is_Trivial;
1.1534 + _M_initialize(_Is_Trivial());
1.1535 + *this = __x;
1.1536 +}
1.1537 +
1.1538 +// Behavior is undefined if __x._M_num_true() != this->size()
1.1539 +template <class _Tp>
1.1540 +inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array<_Tp>& __x) {
1.1541 + size_t __idx = 0;
1.1542 + for (size_t __i = 0; __i < __x._M_array.size(); ++__i)
1.1543 + if (__x._M_mask[__i]) (*this)[__idx++] = __x._M_array[__i];
1.1544 + return *this;
1.1545 +}
1.1546 +
1.1547 +template <class _Tp>
1.1548 +inline mask_array<_Tp> valarray<_Tp>::operator[](const _Valarray_bool& __mask)
1.1549 +{
1.1550 + return mask_array<_Tp>(__mask, *this);
1.1551 +}
1.1552 +
1.1553 +
1.1554 +//----------------------------------------------------------------------
1.1555 +// indirect_array
1.1556 +
1.1557 +template <class _Tp>
1.1558 +class indirect_array {
1.1559 + friend class valarray<_Tp>;
1.1560 +public:
1.1561 + typedef _Tp value_type;
1.1562 +
1.1563 + void operator=(const valarray<value_type>& __x) const {
1.1564 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1565 + _M_array[_M_addr[__i]] = __x[__i];
1.1566 + }
1.1567 +
1.1568 + void operator*=(const valarray<value_type>& __x) const {
1.1569 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1570 + _M_array[_M_addr[__i]] *= __x[__i];
1.1571 + }
1.1572 +
1.1573 + void operator/=(const valarray<value_type>& __x) const {
1.1574 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1575 + _M_array[_M_addr[__i]] /= __x[__i];
1.1576 + }
1.1577 +
1.1578 + void operator%=(const valarray<value_type>& __x) const {
1.1579 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1580 + _M_array[_M_addr[__i]] %= __x[__i];
1.1581 + }
1.1582 +
1.1583 + void operator+=(const valarray<value_type>& __x) const {
1.1584 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1585 + _M_array[_M_addr[__i]] += __x[__i];
1.1586 + }
1.1587 +
1.1588 + void operator-=(const valarray<value_type>& __x) const {
1.1589 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1590 + _M_array[_M_addr[__i]] -= __x[__i];
1.1591 + }
1.1592 +
1.1593 + void operator^=(const valarray<value_type>& __x) const {
1.1594 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1595 + _M_array[_M_addr[__i]] ^= __x[__i];
1.1596 + }
1.1597 +
1.1598 + void operator&=(const valarray<value_type>& __x) const {
1.1599 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1600 + _M_array[_M_addr[__i]] &= __x[__i];
1.1601 + }
1.1602 +
1.1603 + void operator|=(const valarray<value_type>& __x) const {
1.1604 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1605 + _M_array[_M_addr[__i]] |= __x[__i];
1.1606 + }
1.1607 +
1.1608 + void operator<<=(const valarray<value_type>& __x) const {
1.1609 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1610 + _M_array[_M_addr[__i]] <<= __x[__i];
1.1611 + }
1.1612 +
1.1613 + void operator>>=(const valarray<value_type>& __x) const {
1.1614 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1615 + _M_array[_M_addr[__i]] >>= __x[__i];
1.1616 + }
1.1617 +
1.1618 + void operator=(const value_type& __c) const {
1.1619 + for (size_t __i = 0; __i < _M_addr.size(); ++__i)
1.1620 + _M_array[_M_addr[__i]] = __c;
1.1621 + }
1.1622 +
1.1623 + ~indirect_array() {}
1.1624 +
1.1625 +private:
1.1626 + indirect_array(const _Valarray_size_t& __addr, valarray<_Tp>& __array)
1.1627 + : _M_addr(__addr), _M_array(__array)
1.1628 + {}
1.1629 +
1.1630 + _Valarray_size_t _M_addr;
1.1631 + valarray<_Tp>& _M_array;
1.1632 +
1.1633 +private: // Disable assignment
1.1634 + void operator=(const indirect_array<_Tp>&);
1.1635 +};
1.1636 +
1.1637 +// valarray member functions dealing with indirect_array
1.1638 +
1.1639 +template <class _Tp>
1.1640 +inline valarray<_Tp>::valarray(const indirect_array<_Tp>& __x)
1.1641 + : _Valarray_base<_Tp>(__x._M_addr.size())
1.1642 +{
1.1643 + typedef typename __type_traits<_Tp>::has_trivial_default_constructor
1.1644 + _Is_Trivial;
1.1645 + _M_initialize(_Is_Trivial());
1.1646 + *this = __x;
1.1647 +}
1.1648 +
1.1649 +
1.1650 +template <class _Tp>
1.1651 +inline indirect_array<_Tp>
1.1652 +valarray<_Tp>::operator[](const _Valarray_size_t& __addr)
1.1653 +{
1.1654 + return indirect_array<_Tp>(__addr, *this);
1.1655 +}
1.1656 +
1.1657 +_STLP_END_NAMESPACE
1.1658 +
1.1659 +# if !defined (_STLP_LINK_TIME_INSTANTIATION)
1.1660 +# include <stl/_valarray.c>
1.1661 +# endif
1.1662 +
1.1663 +#endif /* _STLP_VALARRAY */
1.1664 +
1.1665 +
1.1666 +// Local Variables:
1.1667 +// mode:C++
1.1668 +// End: