111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Copyright (c) 1999 311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Silicon Graphics Computer Systems, Inc. 411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Copyright (c) 1999 611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Boris Fomitchev 711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * This material is provided "as is", with absolutely no warranty expressed 911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * or implied. Any use is at your own risk. 1011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 1111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Permission to use or copy this software for any purpose is hereby granted 1211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * without fee, provided the above notices are retained on all copies. 1311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Permission to modify the code and to distribute modified code is granted, 1411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * provided the above notices are retained, and a notice that the code was 1511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * modified is included with the above copyright notice. 1611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 1711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 1811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 1911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _STLP_VALARRAY_H 2011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define _STLP_VALARRAY_H 2111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _STLP_INTERNAL_CMATH 2311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <stl/_cmath.h> 2411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 2511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _STLP_INTERNAL_NEW 2711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <stl/_new.h> 2811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 2911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _STLP_INTERNAL_ALGO_H 3111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <stl/_algo.h> 3211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 3311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _STLP_INTERNAL_NUMERIC_H 3511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <stl/_numeric.h> 3611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 3711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _STLP_INTERNAL_LIMITS 3911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <stl/_limits.h> 4011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 4111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_BEGIN_NAMESPACE 4311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass slice; 4511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass gslice; 4611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> class valarray; 4811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef valarray<bool> _Valarray_bool; 4911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef valarray<size_t> _Valarray_size_t; 5011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> class slice_array; 5211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> class gslice_array; 5311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> class mask_array; 5411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> class indirect_array; 5511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//---------------------------------------------------------------------- 5711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// class valarray 5811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Base class to handle memory allocation and deallocation. We can't just 6011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// use vector<>, because vector<bool> would be unsuitable as an internal 6111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// representation for valarray<bool>. 6211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 6411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Valarray_base { 6511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Tp* _M_first; 6611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t _M_size; 6711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_base() : _M_first(0), _M_size(0) {} 6911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_base(size_t __n) : _M_first(0), _M_size(0) { _M_allocate(__n); } 7011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~_Valarray_base() { _M_deallocate(); } 7111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void _M_allocate(size_t __n) { 7311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__n != 0) { 7411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_first = __STATIC_CAST(_Tp*, __stl_new(__n * sizeof(_Tp))); 7511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_size = __n; 7611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 7711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else { 7811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_first = 0; 7911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_size = 0; 8011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 8111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 8211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void _M_deallocate() { 8411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __stl_delete(_M_first); 8511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_first = 0; 8611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_size = 0; 8711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 8811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 8911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 9111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass valarray : private _Valarray_base<_Tp> 9211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 9311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert friend class gslice; 9411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: 9611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef _Tp value_type; 9711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Basic constructors 9911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray() : _Valarray_base<_Tp>() {} 10011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert explicit valarray(size_t __n) : _Valarray_base<_Tp>(__n) 10111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { uninitialized_fill_n(this->_M_first, this->_M_size, _STLP_DEFAULT_CONSTRUCTED(value_type)); } 10211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray(const value_type& __x, size_t __n) : _Valarray_base<_Tp>(__n) 10311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { uninitialized_fill_n(this->_M_first, this->_M_size, __x); } 10411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray(const value_type* __p, size_t __n) : _Valarray_base<_Tp>(__n) 10511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { uninitialized_copy(__p, __p + __n, this->_M_first); } 10611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray(const valarray<_Tp>& __x) : _Valarray_base<_Tp>(__x._M_size) { 10711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert uninitialized_copy(__x._M_first, __x._M_first + __x._M_size, 10811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_first); 10911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 11011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Constructors from auxiliary array types 11211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray(const slice_array<_Tp>&); 11311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray(const gslice_array<_Tp>&); 11411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray(const mask_array<_Tp>&); 11511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray(const indirect_array<_Tp>&); 11611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Destructor 11811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~valarray() { _STLP_STD::_Destroy_Range(this->_M_first, this->_M_first + this->_M_size); } 11911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Extension: constructor that doesn't initialize valarray elements to a 12111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // specific value. This is faster for types such as int and double. 12211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 12311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void _M_initialize(const __true_type&) {} 12411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void _M_initialize(const __false_type&) 12511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { uninitialized_fill_n(this->_M_first, this->_M_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); } 12611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: 12811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert struct _NoInit {}; 12911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray(size_t __n, _NoInit) : _Valarray_base<_Tp>(__n) { 13011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename __type_traits<_Tp>::has_trivial_default_constructor _Is_Trivial; 13111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_initialize(_Is_Trivial()); 13211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 13311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: // Assignment 13511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Basic assignment. Note that 'x = y' is undefined if x.size() != y.size() 13611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator=(const valarray<_Tp>& __x) { 13711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == this->size()) 13811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (this != &__x) 13911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert copy(__x._M_first, __x._M_first + __x._M_size, this->_M_first); 14011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 14111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 14211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Scalar assignment 14411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator=(const value_type& __x) { 14511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert fill_n(this->_M_first, this->_M_size, __x); 14611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 14711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 14811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Assignment of auxiliary array types 15011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator=(const slice_array<_Tp>&); 15111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator=(const gslice_array<_Tp>&); 15211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator=(const mask_array<_Tp>&); 15311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator=(const indirect_array<_Tp>&); 15411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: // Element access 15611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert value_type operator[](size_t __n) const { 15711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__n < this->size()) 15811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return this->_M_first[__n]; 15911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 16011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert value_type& operator[](size_t __n) { 16111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__n < this->size()) 16211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return this->_M_first[__n]; 16311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 16411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t size() const { return this->_M_size; } 16511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 16611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: // Subsetting operations with auxiliary type 16711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> operator[](slice) const; 16811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert slice_array<_Tp> operator[](slice); 16911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> operator[](const gslice&) const; 17011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gslice_array<_Tp> operator[](const gslice&); 17111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> operator[](const _Valarray_bool&) const; 17211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert mask_array<_Tp> operator[](const _Valarray_bool&); 17311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> operator[](const _Valarray_size_t&) const; 17411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert indirect_array<_Tp> operator[](const _Valarray_size_t&); 17511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 17611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: // Unary operators. 17711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> operator+() const { return *this; } 17811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 17911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> operator-() const { 18011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(this->size(), _NoInit()); 18111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 18211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = -(*this)[__i]; 18311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 18411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 18511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 18611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> operator~() const { 18711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(this->size(), _NoInit()); 18811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 18911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ~(*this)[__i]; 19011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 19111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 19211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool operator!() const; 19411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 19511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: // Scalar computed assignment. 19611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator*= (const value_type& __x) { 19711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 19811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] *= __x; 19911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 20011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 20111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator/= (const value_type& __x) { 20311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 20411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] /= __x; 20511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 20611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 20711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator%= (const value_type& __x) { 20911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 21011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] %= __x; 21111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 21211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 21311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 21411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator+= (const value_type& __x) { 21511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 21611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] += __x; 21711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 21811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 21911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 22011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator-= (const value_type& __x) { 22111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 22211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] -= __x; 22311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 22411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 22511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 22611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator^= (const value_type& __x) { 22711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 22811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] ^= __x; 22911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 23011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 23111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 23211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator&= (const value_type& __x) { 23311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 23411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] &= __x; 23511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 23611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 23711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 23811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator|= (const value_type& __x) { 23911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 24011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] |= __x; 24111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 24211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 24311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 24411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator<<= (const value_type& __x) { 24511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 24611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] <<= __x; 24711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 24811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 24911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 25011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator>>= (const value_type& __x) { 25111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 25211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] >>= __x; 25311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 25411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 25511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 25611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: // Array computed assignment. 25711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator*= (const valarray<_Tp>& __x) { 25811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == this->size()) 25911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 26011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] *= __x[__i]; 26111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 26211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 26311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 26411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator/= (const valarray<_Tp>& __x) { 26511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == this->size()) 26611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 26711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] /= __x[__i]; 26811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 26911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 27011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 27111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator%= (const valarray<_Tp>& __x) { 27211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == this->size()) 27311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 27411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] %= __x[__i]; 27511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 27611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 27711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 27811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator+= (const valarray<_Tp>& __x) { 27911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == this->size()) 28011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 28111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] += __x[__i]; 28211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 28311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 28411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 28511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator-= (const valarray<_Tp>& __x) { 28611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == this->size()) 28711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 28811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] -= __x[__i]; 28911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 29011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 29111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 29211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator^= (const valarray<_Tp>& __x) { 29311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == this->size()) 29411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 29511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] ^= __x[__i]; 29611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 29711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 29811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 29911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator&= (const valarray<_Tp>& __x) { 30011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == this->size()) 30111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 30211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] &= __x[__i]; 30311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 30411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 30511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 30611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator|= (const valarray<_Tp>& __x) { 30711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == this->size()) 30811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 30911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] |= __x[__i]; 31011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 31111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 31211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator<<= (const valarray<_Tp>& __x) { 31411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == this->size()) 31511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 31611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] <<= __x[__i]; 31711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 31811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 31911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& operator>>= (const valarray<_Tp>& __x) { 32111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == this->size()) 32211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < this->size(); ++__i) 32311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[__i] >>= __x[__i]; 32411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 32511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 32611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: // Other member functions. 32811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The result is undefined for zero-length arrays 33011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert value_type sum() const { 33111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(this->size() != 0) 33211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return accumulate(this->_M_first + 1, this->_M_first + this->_M_size, 33311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (*this)[0]); 33411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 33511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The result is undefined for zero-length arrays 33711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert value_type (min) () const { 33811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(this->size() != 0) 33911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *min_element(this->_M_first + 0, this->_M_first + this->_M_size); 34011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 34111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 34211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert value_type (max) () const { 34311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(this->size() != 0) 34411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *max_element(this->_M_first + 0, this->_M_first + this->_M_size); 34511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 34611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 34711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> shift(int __n) const; 34811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> cshift(int __n) const; 34911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> apply(value_type __f(value_type)) const { 35111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(this->size()); 35211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert transform(this->_M_first + 0, this->_M_first + this->_M_size, __tmp._M_first, 35311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __f); 35411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 35511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 35611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> apply(value_type __f(const value_type&)) const { 35711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(this->size()); 35811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert transform(this->_M_first + 0, this->_M_first + this->_M_size, __tmp._M_first, 35911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __f); 36011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 36111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 36211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 36311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void resize(size_t __n, value_type __x = value_type()) { 36411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_STD::_Destroy_Range(this->_M_first, this->_M_first + this->_M_size); 36511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_base<_Tp>::_M_deallocate(); 36611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_base<_Tp>::_M_allocate(__n); 36711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert uninitialized_fill_n(this->_M_first, this->_M_size, __x); 36811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 36911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 37011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 37111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//---------------------------------------------------------------------- 37211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// valarray non-member functions. 37311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 37411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Binary arithmetic operations between two arrays. Behavior is 37511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// undefined if the two arrays do not have the same length. 37611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 37711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 37811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator*(const valarray<_Tp>& __x, 37911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 38011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 38111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 38211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 38311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 38411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] * __y[__i]; 38511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 38611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 38711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 38911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator/(const valarray<_Tp>& __x, 39011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 39111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 39211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 39311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 39411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 39511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] / __y[__i]; 39611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 39711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 39811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 39911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 40011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator%(const valarray<_Tp>& __x, 40111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 40211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 40311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 40411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 40511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 40611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] % __y[__i]; 40711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 40811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 40911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 41011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 41111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator+(const valarray<_Tp>& __x, 41211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 41311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 41411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 41511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 41611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 41711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] + __y[__i]; 41811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 41911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 42011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 42111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 42211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator-(const valarray<_Tp>& __x, 42311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 42411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 42511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 42611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 42711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 42811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] - __y[__i]; 42911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 43011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 43111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 43211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 43311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator^(const valarray<_Tp>& __x, 43411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 43511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 43611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 43711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 43811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 43911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] ^ __y[__i]; 44011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 44111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 44211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 44411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator&(const valarray<_Tp>& __x, 44511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 44611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 44711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 44811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 44911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 45011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] & __y[__i]; 45111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 45211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 45311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 45511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator|(const valarray<_Tp>& __x, 45611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 45711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 45811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 45911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 46011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 46111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] | __y[__i]; 46211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 46311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 46411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 46511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 46611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator<<(const valarray<_Tp>& __x, 46711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 46811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 46911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 47011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 47111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 47211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] << __y[__i]; 47311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 47411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 47511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 47711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator>>(const valarray<_Tp>& __x, 47811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 47911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 48011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 48111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 48211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 48311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] >> __y[__i]; 48411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 48511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 48611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Binary arithmetic operations between an array and a scalar. 48811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 48911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 49011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator*(const valarray<_Tp>& __x, const _Tp& __c) { 49111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 49211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 49311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 49411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] * __c; 49511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 49611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 49711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 49911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator*(const _Tp& __c, const valarray<_Tp>& __x) { 50011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 50111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 50211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 50311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c * __x[__i]; 50411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 50511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 50611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 50811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator/(const valarray<_Tp>& __x, const _Tp& __c) { 50911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 51011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 51111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 51211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] / __c; 51311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 51411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 51511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 51711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator/(const _Tp& __c, const valarray<_Tp>& __x) { 51811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 51911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 52011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 52111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c / __x[__i]; 52211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 52311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 52411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 52611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator%(const valarray<_Tp>& __x, const _Tp& __c) { 52711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 52811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 52911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 53011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] % __c; 53111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 53211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 53311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 53511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator%(const _Tp& __c, const valarray<_Tp>& __x) { 53611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 53711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 53811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 53911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c % __x[__i]; 54011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 54111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 54211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 54411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator+(const valarray<_Tp>& __x, const _Tp& __c) { 54511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 54611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 54711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 54811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] + __c; 54911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 55011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 55111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 55311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator+(const _Tp& __c, const valarray<_Tp>& __x) { 55411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 55511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 55611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 55711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c + __x[__i]; 55811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 55911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 56011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 56111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 56211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator-(const valarray<_Tp>& __x, const _Tp& __c) { 56311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 56411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 56511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 56611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] - __c; 56711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 56811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 56911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 57111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator-(const _Tp& __c, const valarray<_Tp>& __x) { 57211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 57311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 57411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 57511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c - __x[__i]; 57611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 57711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 57811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 58011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator^(const valarray<_Tp>& __x, const _Tp& __c) { 58111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 58211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 58311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 58411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] ^ __c; 58511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 58611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 58711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 58811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 58911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator^(const _Tp& __c, const valarray<_Tp>& __x) { 59011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 59111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 59211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 59311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c ^ __x[__i]; 59411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 59511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 59611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 59711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 59811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator&(const valarray<_Tp>& __x, const _Tp& __c) { 59911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 60011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 60111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 60211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] & __c; 60311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 60411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 60511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 60611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 60711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator&(const _Tp& __c, const valarray<_Tp>& __x) { 60811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 60911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 61011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 61111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c & __x[__i]; 61211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 61311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 61411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 61511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 61611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator|(const valarray<_Tp>& __x, const _Tp& __c) { 61711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 61811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 61911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 62011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] | __c; 62111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 62211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 62311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 62411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 62511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator|(const _Tp& __c, const valarray<_Tp>& __x) { 62611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 62711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 62811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 62911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c | __x[__i]; 63011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 63111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 63211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 63311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 63411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator<<(const valarray<_Tp>& __x, const _Tp& __c) { 63511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 63611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 63711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 63811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] << __c; 63911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 64011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 64111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 64211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 64311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator<<(const _Tp& __c, const valarray<_Tp>& __x) { 64411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 64511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 64611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 64711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c << __x[__i]; 64811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 64911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 65011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 65111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 65211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator>>(const valarray<_Tp>& __x, const _Tp& __c) { 65311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 65411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 65511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 65611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] >> __c; 65711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 65811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 65911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 66111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> _STLP_CALL operator>>(const _Tp& __c, const valarray<_Tp>& __x) { 66211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 66311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 66411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 66511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c >> __x[__i]; 66611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 66711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 66811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Binary logical operations between two arrays. Behavior is undefined 67011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// if the two arrays have different lengths. Note that operator== does 67111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// not do what you might at first expect. 67211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 67411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator==(const valarray<_Tp>& __x, 67511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 67611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 67711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 67811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 67911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] == __y[__i]; 68011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 68111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 68211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 68311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 68411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator<(const valarray<_Tp>& __x, 68511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 68611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 68711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 68811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 68911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] < __y[__i]; 69011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 69111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 69211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 69311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE 69411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 69511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 69611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator!=(const valarray<_Tp>& __x, 69711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 69811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 69911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 70011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 70111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] != __y[__i]; 70211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 70311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 70411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 70511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 70611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator>(const valarray<_Tp>& __x, 70711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 70811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 70911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 71011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 71111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] > __y[__i]; 71211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 71311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 71411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 71511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 71611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator<=(const valarray<_Tp>& __x, 71711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 71811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 71911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 72011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 72111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] <= __y[__i]; 72211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 72311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 72411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 72611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator>=(const valarray<_Tp>& __x, 72711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 72811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 72911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 73011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 73111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] >= __y[__i]; 73211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 73311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 73411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 73511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */ 73611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// fbp : swap ? 73711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 73811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 73911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator&&(const valarray<_Tp>& __x, 74011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 74111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 74211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 74311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 74411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] && __y[__i]; 74511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 74611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 74711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 74911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator||(const valarray<_Tp>& __x, 75011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 75111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__x.size() == __y.size()) 75211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 75311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 75411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] || __y[__i]; 75511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 75611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 75711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Logical operations between an array and a scalar. 75911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 76011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 76111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator==(const valarray<_Tp>& __x, const _Tp& __c) { 76211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 76311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 76411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] == __c; 76511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 76611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 76711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 76811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 76911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator==(const _Tp& __c, const valarray<_Tp>& __x) { 77011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 77111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 77211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c == __x[__i]; 77311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 77411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 77511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 77711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator!=(const valarray<_Tp>& __x, const _Tp& __c) { 77811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 77911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 78011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] != __c; 78111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 78211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 78311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 78411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 78511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator!=(const _Tp& __c, const valarray<_Tp>& __x) { 78611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 78711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 78811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c != __x[__i]; 78911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 79011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 79111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 79211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 79311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator<(const valarray<_Tp>& __x, const _Tp& __c) { 79411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 79511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 79611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] < __c; 79711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 79811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 79911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 80011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 80111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator<(const _Tp& __c, const valarray<_Tp>& __x) { 80211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 80311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 80411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c < __x[__i]; 80511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 80611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 80711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 80811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 80911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator>(const valarray<_Tp>& __x, const _Tp& __c) { 81011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 81111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 81211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] > __c; 81311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 81411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 81511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 81711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator>(const _Tp& __c, const valarray<_Tp>& __x) { 81811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 81911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 82011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c > __x[__i]; 82111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 82211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 82311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 82411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 82511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator<=(const valarray<_Tp>& __x, const _Tp& __c) { 82611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 82711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 82811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] <= __c; 82911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 83011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 83111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 83211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 83311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator<=(const _Tp& __c, const valarray<_Tp>& __x) { 83411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 83511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 83611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c <= __x[__i]; 83711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 83811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 83911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 84011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 84111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator>=(const valarray<_Tp>& __x, const _Tp& __c) { 84211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 84311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 84411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] >= __c; 84511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 84611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 84711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 84811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 84911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator>=(const _Tp& __c, const valarray<_Tp>& __x) { 85011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 85111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 85211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c >= __x[__i]; 85311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 85411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 85511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 85611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 85711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator&&(const valarray<_Tp>& __x, const _Tp& __c) { 85811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 85911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 86011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] && __c; 86111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 86211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 86311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 86511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator&&(const _Tp& __c, const valarray<_Tp>& __x) { 86611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 86711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 86811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c && __x[__i]; 86911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 87011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 87111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 87211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 87311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator||(const valarray<_Tp>& __x, const _Tp& __c) { 87411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 87511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 87611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __x[__i] || __c; 87711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 87811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 87911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 88011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 88111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline _Valarray_bool _STLP_CALL operator||(const _Tp& __c, const valarray<_Tp>& __x) { 88211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit()); 88311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 88411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = __c || __x[__i]; 88511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 88611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 88711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 88811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// valarray "transcendentals" (the list includes abs and sqrt, which, 88911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// of course, are not transcendental). 89011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 89111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 89211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> abs(const valarray<_Tp>& __x) { 89311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 89411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 89511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 89611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::abs(__x[__i]); 89711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 89811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 89911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 90111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> acos(const valarray<_Tp>& __x) { 90211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 90311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 90411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 90511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::acos(__x[__i]); 90611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 90711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 90811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 91011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> asin(const valarray<_Tp>& __x) { 91111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 91211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 91311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 91411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::asin(__x[__i]); 91511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 91611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 91711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 91911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> atan(const valarray<_Tp>& __x) { 92011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 92111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 92211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 92311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::atan(__x[__i]); 92411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 92511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 92611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 92711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 92811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> atan2(const valarray<_Tp>& __x, 92911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 93011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 93111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 93211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 93311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::atan2(__x[__i], __y[__i]); 93411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 93511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 93611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 93711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 93811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> atan2(const valarray<_Tp>& __x, const _Tp& __c) { 93911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 94011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 94111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 94211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::atan2(__x[__i], __c); 94311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 94411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 94511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 94611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 94711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> atan2(const _Tp& __c, const valarray<_Tp>& __x) { 94811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 94911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 95011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 95111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::atan2(__c, __x[__i]); 95211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 95311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 95411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 95511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 95611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> cos(const valarray<_Tp>& __x) { 95711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 95811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 95911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 96011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::cos(__x[__i]); 96111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 96211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 96311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 96411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 96511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> cosh(const valarray<_Tp>& __x) { 96611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 96711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 96811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 96911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::cosh(__x[__i]); 97011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 97111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 97211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 97311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 97411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> exp(const valarray<_Tp>& __x) { 97511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 97611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 97711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 97811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::exp(__x[__i]); 97911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 98011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 98111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 98311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> log(const valarray<_Tp>& __x) { 98411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 98511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 98611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 98711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::log(__x[__i]); 98811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 98911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 99011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 99111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 99211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> log10(const valarray<_Tp>& __x) { 99311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 99411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 99511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 99611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::log10(__x[__i]); 99711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 99811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 99911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 100011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 100111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> pow(const valarray<_Tp>& __x, 100211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const valarray<_Tp>& __y) { 100311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 100411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 100511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 100611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::pow(__x[__i], __y[__i]); 100711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 100811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 100911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 101011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 101111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> pow(const valarray<_Tp>& __x, const _Tp& __c) { 101211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 101311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 101411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 101511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::pow(__x[__i], __c); 101611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 101711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 101811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 101911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 102011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> pow(const _Tp& __c, const valarray<_Tp>& __x) { 102111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 102211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 102311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 102411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::pow(__c, __x[__i]); 102511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 102611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 102711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 102811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 102911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> sin(const valarray<_Tp>& __x) { 103011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 103111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 103211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 103311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::sin(__x[__i]); 103411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 103511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 103611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 103711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 103811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> sinh(const valarray<_Tp>& __x) { 103911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 104011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 104111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 104211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::sinh(__x[__i]); 104311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 104411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 104511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 104611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 104711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> sqrt(const valarray<_Tp>& __x) { 104811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 104911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 105011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 105111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::sqrt(__x[__i]); 105211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 105311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 105411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 105511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 105611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> tan(const valarray<_Tp>& __x) { 105711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 105811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 105911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 106011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::tan(__x[__i]); 106111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 106211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 106311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 106411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 106511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp> tanh(const valarray<_Tp>& __x) { 106611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename valarray<_Tp>::_NoInit _NoInit; 106711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp> __tmp(__x.size(), _NoInit()); 106811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x.size(); ++__i) 106911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp[__i] = ::tanh(__x[__i]); 107011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 107111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 107211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 107311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//---------------------------------------------------------------------- 107411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// slice and slice_array 107511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 107611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass slice { 107711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: 107811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert slice() : _M_start(0), _M_length(0), _M_stride(0) {} 107911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert slice(size_t __start, size_t __length, size_t __stride) 108011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _M_start(__start), _M_length(__length), _M_stride(__stride) 108111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} 108211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __TRIVIAL_DESTRUCTOR(slice) 108311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 108411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t start() const { return _M_start; } 108511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t size() const { return _M_length; } 108611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t stride() const { return _M_stride; } 108711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 108811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 108911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t _M_start; 109011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t _M_length; 109111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t _M_stride; 109211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 109311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 109411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 109511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass slice_array { 109611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert friend class valarray<_Tp>; 109711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: 109811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef _Tp value_type; 109911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 110011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator=(const valarray<value_type>& __x) const { 110111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 110211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 110311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 110411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 110511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] = __x[__i]; 110611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 110711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 110811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator*=(const valarray<value_type>& __x) const { 110911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 111011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 111111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 111211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 111311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] *= __x[__i]; 111411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 111511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 111611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator/=(const valarray<value_type>& __x) const { 111711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 111811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 111911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 112011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 112111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] /= __x[__i]; 112211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 112311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 112411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator%=(const valarray<value_type>& __x) const { 112511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 112611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 112711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 112811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 112911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] %= __x[__i]; 113011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 113111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 113211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator+=(const valarray<value_type>& __x) const { 113311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 113411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 113511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 113611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 113711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] += __x[__i]; 113811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 113911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 114011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator-=(const valarray<value_type>& __x) const { 114111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 114211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 114311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 114411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 114511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] -= __x[__i]; 114611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 114711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 114811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator^=(const valarray<value_type>& __x) const { 114911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 115011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 115111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 115211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 115311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] ^= __x[__i]; 115411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 115511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 115611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator&=(const valarray<value_type>& __x) const { 115711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 115811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 115911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 116011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 116111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] &= __x[__i]; 116211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 116311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 116411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator|=(const valarray<value_type>& __x) const { 116511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 116611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 116711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 116811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 116911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] |= __x[__i]; 117011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 117111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 117211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator<<=(const valarray<value_type>& __x) const { 117311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 117411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 117511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 117611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 117711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] <<= __x[__i]; 117811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 117911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator>>=(const valarray<value_type>& __x) const { 118111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 118211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 118311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 118411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 118511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] >>= __x[__i]; 118611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 118711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator=(const value_type& __c) /*const could be const but standard says NO (26.3.5.4-1)*/ { 118911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __index = _M_slice.start(); 119011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; 119111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __i < _M_slice.size(); 119211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__i, __index += _M_slice.stride()) 119311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[__index] = __c; 119411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 119511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 119611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // C++ Standard defect 253, copy constructor must be public. 119711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert slice_array(const slice_array &__x) 119811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _M_slice(__x._M_slice), _M_array(__x._M_array) 119911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} 120011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~slice_array() {} 120211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 120411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert slice_array(const slice& __slice, valarray<_Tp> &__array) 120511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _M_slice(__slice), _M_array(__array) 120611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} 120711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert slice _M_slice; 120911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& _M_array; 121011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 121211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Disable default constructor and assignment 121311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert slice_array(); 121411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert slice_array& operator=(const slice_array&); 121511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 121611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// valarray member functions dealing with slice and slice_array 121811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 122011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp>::valarray(const slice_array<_Tp>& __x) 122111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _Valarray_base<_Tp>(__x._M_slice.size()) { 122211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename __type_traits<_Tp>::has_trivial_default_constructor 122311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_Trivial; 122411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_initialize(_Is_Trivial()); 122511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *this = __x; 122611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 122711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 122811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 122911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 123011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline slice_array<_Tp> valarray<_Tp>::operator[](slice __slice) 123111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return slice_array<_Tp>(__slice, *this); } 123211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 123311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//---------------------------------------------------------------------- 123411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// gslice and gslice_array 123511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 123611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Size> 123711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Gslice_Iter_tmpl; 123811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 123911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass gslice { 124011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert friend struct _Gslice_Iter_tmpl<size_t>; 124111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: 124211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gslice() : _M_start(0), _M_lengths(), _M_strides() {} 124311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gslice(size_t __start, 124411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const _Valarray_size_t& __lengths, const _Valarray_size_t& __strides) 124511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _M_start(__start), _M_lengths(__lengths), _M_strides(__strides) 124611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} 124711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __TRIVIAL_DESTRUCTOR(gslice) 124811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 124911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t start() const { return _M_start; } 125011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_size_t size() const { return _M_lengths; } 125111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_size_t stride() const { return _M_strides; } 125211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 125311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Extension: check for an empty gslice. 125411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool _M_empty() const { return _M_lengths.size() == 0; } 125511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 125611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Extension: number of indices this gslice represents. (For a degenerate 125711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // gslice, they're not necessarily all distinct.) 125811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t _M_size() const { 125911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return !this->_M_empty() 126011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ? accumulate(_M_lengths._M_first + 1, 126111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_lengths._M_first + _M_lengths._M_size, 126211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_lengths[0], 126311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert multiplies<size_t>()) 126411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : 0; 126511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 126611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 126711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# ifndef __HP_aCC 126811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 126911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 127011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 127111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t _M_start; 127211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_size_t _M_lengths; 127311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_size_t _M_strides; 127411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 127511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 127611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This is not an STL iterator. It is constructed from a gslice, and it 127711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// steps through the gslice indices in sequence. See 23.3.6 of the C++ 127811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// standard, paragraphs 2-3, for an explanation of the sequence. At 127911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// each step we get two things: the ordinal (i.e. number of steps taken), 128011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and the one-dimensional index. 128111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 128211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Size> 128311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Gslice_Iter_tmpl { 128411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter_tmpl(const gslice& __gslice) 128511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _M_step(0), _M_1d_idx(__gslice.start()), 128611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_indices(size_t(0), __gslice._M_lengths.size()), 128711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gslice(__gslice) 128811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} 128911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 129011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool _M_done() const { return _M_indices[0] == _M_gslice._M_lengths[0]; } 129111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 129211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool _M_incr(); 129311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 129411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Size _M_step; 129511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Size _M_1d_idx; 129611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 129711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Size> _M_indices; 129811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const gslice& _M_gslice; 129911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 130011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 130111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttypedef _Gslice_Iter_tmpl<size_t> _Gslice_Iter; 130211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 130311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 130411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass gslice_array { 130511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert friend class valarray<_Tp>; 130611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: 130711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef _Tp value_type; 130811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 130911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator= (const valarray<value_type>& __x) const { 131011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 131111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 131211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] = __x[__i._M_step]; while(__i._M_incr()); 131311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 131411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 131511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 131611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator*= (const valarray<value_type>& __x) const { 131711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 131811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 131911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] *= __x[__i._M_step]; while(__i._M_incr()); 132011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 132111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 132211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 132311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator/= (const valarray<value_type>& __x) const { 132411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 132511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 132611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] /= __x[__i._M_step]; while(__i._M_incr()); 132711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 132811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 132911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 133011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator%= (const valarray<value_type>& __x) const { 133111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 133211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 133311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] %= __x[__i._M_step]; while(__i._M_incr()); 133411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 133511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 133611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 133711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator+= (const valarray<value_type>& __x) const { 133811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 133911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 134011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] += __x[__i._M_step]; while(__i._M_incr()); 134111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 134211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 134311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 134411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator-= (const valarray<value_type>& __x) const { 134511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 134611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 134711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] -= __x[__i._M_step]; while(__i._M_incr()); 134811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 134911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 135011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 135111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator^= (const valarray<value_type>& __x) const { 135211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 135311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 135411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] ^= __x[__i._M_step]; while(__i._M_incr()); 135511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 135611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 135711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 135811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator&= (const valarray<value_type>& __x) const { 135911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 136011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 136111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] &= __x[__i._M_step]; while(__i._M_incr()); 136211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 136311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 136411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 136511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator|= (const valarray<value_type>& __x) const { 136611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 136711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 136811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] |= __x[__i._M_step]; while(__i._M_incr()); 136911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 137011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 137111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 137211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator<<= (const valarray<value_type>& __x) const { 137311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 137411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 137511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] <<= __x[__i._M_step]; while(__i._M_incr()); 137611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 137711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 137811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 137911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator>>= (const valarray<value_type>& __x) const { 138011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 138111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 138211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] >>= __x[__i._M_step]; while(__i._M_incr()); 138311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 138411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 138511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 138611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator= (const value_type& __c) /*const could be const but standard says NO (26.3.7.4-1)*/ { 138711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!_M_gslice._M_empty()) { 138811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Gslice_Iter __i(_M_gslice); 138911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert do _M_array[__i._M_1d_idx] = __c; while(__i._M_incr()); 139011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 139111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 139211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 139311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // C++ Standard defect 253, copy constructor must be public. 139411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gslice_array(const gslice_array& __x) 139511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _M_gslice(__x._M_gslice), _M_array(__x._M_array) 139611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} 139711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 139811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~gslice_array() {} 139911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 140011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 140111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gslice_array(const gslice &__gslice, valarray<_Tp> &__array) 140211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _M_gslice(__gslice), _M_array(__array) 140311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} 140411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 140511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gslice _M_gslice; 140611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<value_type>& _M_array; 140711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 140811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 140911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Disable default constructor and assignment 141011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert gslice_array(); 141111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator=(const gslice_array<_Tp>&); 141211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 141311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 141411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// valarray member functions dealing with gslice and gslice_array. Note 141511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// that it is illegal (behavior is undefined) to construct a gslice_array 141611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// from a degenerate gslice. 141711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 141811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 141911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp>::valarray(const gslice_array<_Tp>& __x) 142011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _Valarray_base<_Tp>(__x._M_gslice._M_size()) { 142111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename __type_traits<_Tp>::has_trivial_default_constructor 142211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_Trivial; 142311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_initialize(_Is_Trivial()); 142411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *this = __x; 142511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 142611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 142711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 142811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __slice) 142911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return gslice_array<_Tp>(__slice, *this); } 143011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 143111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 143211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//---------------------------------------------------------------------- 143311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// mask_array 143411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 143511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 143611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass mask_array { 143711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert friend class valarray<_Tp>; 143811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: 143911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef _Tp value_type; 144011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 144111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator=(const valarray<value_type>& __x) const { 144211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 144311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 144411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] = __x[__idx++]; 144511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 144611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 144711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator*=(const valarray<value_type>& __x) const { 144811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 144911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 145011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] *= __x[__idx++]; 145111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 145211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 145311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator/=(const valarray<value_type>& __x) const { 145411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 145511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 145611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] /= __x[__idx++]; 145711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 145811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 145911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator%=(const valarray<value_type>& __x) const { 146011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 146111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 146211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] %= __x[__idx++]; 146311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 146411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 146511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator+=(const valarray<value_type>& __x) const { 146611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 146711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 146811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] += __x[__idx++]; 146911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 147011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 147111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator-=(const valarray<value_type>& __x) const { 147211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 147311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 147411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] -= __x[__idx++]; 147511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 147611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 147711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator^=(const valarray<value_type>& __x) const { 147811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 147911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 148011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] ^= __x[__idx++]; 148111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 148211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 148311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator&=(const valarray<value_type>& __x) const { 148411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 148511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 148611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] &= __x[__idx++]; 148711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 148811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 148911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator|=(const valarray<value_type>& __x) const { 149011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 149111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 149211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] |= __x[__idx++]; 149311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 149411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 149511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator<<=(const valarray<value_type>& __x) const { 149611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 149711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 149811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] <<= __x[__idx++]; 149911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 150011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 150111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator>>=(const valarray<value_type>& __x) const { 150211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 150311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 150411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] >>= __x[__idx++]; 150511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 150611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 150711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator=(const value_type& __c) const { 150811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_array.size(); ++__i) 150911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) _M_array[__i] = __c; 151011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 151111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 151211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Extension: number of true values in the mask 151311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t _M_num_true() const { 151411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __result = 0; 151511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_mask.size(); ++__i) 151611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_mask[__i]) ++__result; 151711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __result; 151811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 151911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 152011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // C++ Standard defect 253, copy constructor must be public. 152111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert mask_array(const mask_array& __x) 152211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _M_mask(__x._M_mask), _M_array(__x._M_array) 152311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} 152411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 152511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~mask_array() {} 152611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 152711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 152811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert mask_array(const _Valarray_bool& __mask, valarray<_Tp>& __array) 152911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _M_mask(__mask), _M_array(__array) 153011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} 153111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_bool _M_mask; 153211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& _M_array; 153311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 153411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 153511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Disable default constructor and assignment 153611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert mask_array(); 153711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator=(const mask_array<_Tp>&); 153811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 153911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 154011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// valarray member functions dealing with mask_array 154111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 154211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 154311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp>::valarray(const mask_array<_Tp>& __x) 154411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _Valarray_base<_Tp>(__x._M_num_true()) { 154511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename __type_traits<_Tp>::has_trivial_default_constructor 154611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_Trivial; 154711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_initialize(_Is_Trivial()); 154811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *this = __x; 154911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 155011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 155111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Behavior is undefined if __x._M_num_true() != this->size() 155211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 155311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array<_Tp>& __x) { 155411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert size_t __idx = 0; 155511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < __x._M_array.size(); ++__i) 155611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__x._M_mask[__i]) (*this)[__idx++] = __x._M_array[__i]; 155711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 155811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 155911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 156011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 156111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline mask_array<_Tp> valarray<_Tp>::operator[](const _Valarray_bool& __mask) { 156211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_ASSERT(__mask.size() == this->size()) 156311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return mask_array<_Tp>(__mask, *this); 156411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 156511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 156611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//---------------------------------------------------------------------- 156711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// indirect_array 156811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 156911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 157011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertclass indirect_array { 157111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert friend class valarray<_Tp>; 157211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertpublic: 157311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef _Tp value_type; 157411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 157511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator=(const valarray<value_type>& __x) const { 157611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 157711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] = __x[__i]; 157811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 157911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 158011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator*=(const valarray<value_type>& __x) const { 158111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 158211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] *= __x[__i]; 158311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 158411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 158511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator/=(const valarray<value_type>& __x) const { 158611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 158711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] /= __x[__i]; 158811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 158911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 159011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator%=(const valarray<value_type>& __x) const { 159111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 159211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] %= __x[__i]; 159311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 159411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 159511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator+=(const valarray<value_type>& __x) const { 159611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 159711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] += __x[__i]; 159811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 159911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 160011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator-=(const valarray<value_type>& __x) const { 160111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 160211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] -= __x[__i]; 160311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 160411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 160511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator^=(const valarray<value_type>& __x) const { 160611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 160711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] ^= __x[__i]; 160811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 160911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 161011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator&=(const valarray<value_type>& __x) const { 161111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 161211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] &= __x[__i]; 161311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 161411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 161511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator|=(const valarray<value_type>& __x) const { 161611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 161711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] |= __x[__i]; 161811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 161911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 162011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator<<=(const valarray<value_type>& __x) const { 162111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 162211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] <<= __x[__i]; 162311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 162411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 162511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator>>=(const valarray<value_type>& __x) const { 162611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 162711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] >>= __x[__i]; 162811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 162911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 163011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator=(const value_type& __c) const { 163111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (size_t __i = 0; __i < _M_addr.size(); ++__i) 163211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_array[_M_addr[__i]] = __c; 163311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 163411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 163511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // C++ Standard defect 253, copy constructor must be public. 163611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert indirect_array(const indirect_array& __x) 163711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _M_addr(__x._M_addr), _M_array(__x._M_array) 163811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} 163911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 164011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ~indirect_array() {} 164111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 164211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 164311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert indirect_array(const _Valarray_size_t& __addr, valarray<_Tp>& __array) 164411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _M_addr(__addr), _M_array(__array) 164511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} 164611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 164711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Valarray_size_t _M_addr; 164811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert valarray<_Tp>& _M_array; 164911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 165011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertprivate: 165111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Disable default constructor and assignment 165211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert indirect_array(); 165311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert void operator=(const indirect_array<_Tp>&); 165411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 165511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 165611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// valarray member functions dealing with indirect_array 165711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 165811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 165911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline valarray<_Tp>::valarray(const indirect_array<_Tp>& __x) 166011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _Valarray_base<_Tp>(__x._M_addr.size()) { 166111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename __type_traits<_Tp>::has_trivial_default_constructor 166211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_Trivial; 166311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_initialize(_Is_Trivial()); 166411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *this = __x; 166511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 166611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 166711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 166811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Tp> 166911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertinline indirect_array<_Tp> 167011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvalarray<_Tp>::operator[](const _Valarray_size_t& __addr) 167111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ return indirect_array<_Tp>(__addr, *this); } 167211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 167311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_END_NAMESPACE 167411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 167511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# if !defined (_STLP_LINK_TIME_INSTANTIATION) 167611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <stl/_valarray.c> 167711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# endif 167811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 167911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif /* _STLP_VALARRAY */ 168011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 168111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 168211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Local Variables: 168311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// mode:C++ 168411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// End: 1685