diff options
Diffstat (limited to 'misc/uClibc++/include/cxx/valarray')
-rw-r--r-- | misc/uClibc++/include/cxx/valarray | 1042 |
1 files changed, 1042 insertions, 0 deletions
diff --git a/misc/uClibc++/include/cxx/valarray b/misc/uClibc++/include/cxx/valarray new file mode 100644 index 000000000..09d929c49 --- /dev/null +++ b/misc/uClibc++/include/cxx/valarray @@ -0,0 +1,1042 @@ +/* Copyright (C) 2004 Garrett A. Kajmowicz + + This file is part of the uClibc++ Library. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +#include <basic_definitions> + +#ifndef __HEADER_STD_VALARRAY +#define __HEADER_STD_VALARRAY 1 + +#include <cstddef> +#include <cmath> + +#pragma GCC visibility push(default) + +namespace std{ + + template<class T> class valarray; + class slice; + template<class T> class slice_array; + class gslice; + template<class T> class gslice_array; + template<class T> class mask_array; + template<class T> class indirect_array; + + //Actual class definitions + + + class _UCXXEXPORT slice { + protected: + size_t sta; + size_t siz; + size_t str; + + public: + slice() : sta(0), siz(0), str(0){ } + slice(size_t a, size_t b, size_t c) : sta(a), siz(b), str(c) { } + slice(const slice& s) : sta(s.sta), siz(s.siz), str(s.str) { } + ~slice() { } + size_t start() const{ + return sta; + } + size_t size() const{ + return siz; + } + size_t stride() const{ + return str; + } + }; + + + + template<class T> class _UCXXEXPORT valarray { + friend class slice_array<T>; + protected: + T * data; + size_t length; + + public: + typedef T value_type; + + valarray() : data(0), length(0) { } + + explicit valarray(size_t t) : data(0), length(t){ + data = new T[length]; + } + + valarray(const T& v, size_t t) : data(0), length(t){ + data = new T[length]; + for(size_t i = 0; i < length; ++i){ + data[i] = v; + } + } + valarray(const T* p, size_t t) : data(0), length(t) { + data = new T[length]; + for(size_t i = 0; i < length; ++i){ + data[i] = p[i]; + } + } + valarray(const valarray& v) : data(0), length(v.length){ + data = new T[length]; + for(size_t i = 0; i < length; ++i){ + data[i] = v.data[i]; + } + } + valarray(const slice_array<T> & sa) : data(0), length(sa.s.size()){ + data = new T[length]; + for(unsigned int i = 0; i < length; ++i){ + data[i] = sa.array->data[sa.s.start() + i * sa.s.stride()]; + } + } + valarray(const gslice_array<T>&); + valarray(const mask_array<T>&); + valarray(const indirect_array<T>&); + ~valarray(){ + delete [] data; + data = 0; + length = 0; + } + + valarray<T>& operator=(const valarray<T>& v){ + if (length != v.length) { // DR 630 + delete [] data; + length = v.length; + data = new T[length]; + } + for (size_t i = 0; i < length; ++i) { + data[i] = v.data[i]; + } + return *this; + } + valarray<T>& operator=(const T& t){ + for(size_t i = 0; i < length; ++i){ + data[i] = t; + } + return *this; + } + valarray<T>& operator=(const slice_array<T>& sa){ + for(size_t i =0; i < length; ++i){ + data[i] = sa.data[sa.s.start() + i * sa.s.stride()]; + } + return *this; + } + valarray<T>& operator=(const gslice_array<T>&); + valarray<T>& operator=(const mask_array<T>&); + valarray<T>& operator=(const indirect_array<T>&); + + const T& operator[](size_t t) const{ + return data[t]; + } + T& operator[](size_t t){ + return data[t]; + } + + valarray<T> operator[](slice s) const{ + valarray<T> retval(s.size()); + for(unsigned int i = 0; i< s.size(); ++i){ + retval.data[i] = data[s.start() + i * s.stride()]; + } + return retval; + } + + slice_array<T> operator[](slice sl){ + slice_array<T> retval; + retval.s = sl; + retval.array = this; + return retval; + } + + valarray<T> operator[](const gslice&) const; + gslice_array<T> operator[](const gslice&); + valarray<T> operator[](const valarray<bool>&) const; + mask_array<T> operator[](const valarray<bool>&); + valarray<T> operator[](const valarray<size_t>&) const; + indirect_array<T> operator[](const valarray<size_t>&); + + valarray<T> operator+() const{ + valarray<T> retval(length); + for(size_t i = 0; i< length ; ++i){ + retval.data[i] = +data[i]; + } + return retval; + } + valarray<T> operator-() const{ + valarray<T> retval(length); + for(size_t i = 0; i< length; ++i){ + retval.data[i] = -data[i]; + } + return retval; + } + valarray<T> operator~() const{ + valarray<T> retval(length); + for(size_t i = 0; i< length ; ++i){ + retval.data[i] = ~data[i]; + } + return retval; + } + valarray<bool> operator!() const{ + valarray<bool> retval(length); + for (size_t i = 0; i < length ; ++i){ + retval[i] = !data[i]; + } + return retval; + } + valarray<T>& operator*= (const T& t){ + for(size_t i=0;i<length;++i){ + data[i] *= t; + } + return *this; + } + valarray<T>& operator/= (const T& t){ + for(size_t i=0;i<length;++i){ + data[i] /= t; + } + return *this; + } + valarray<T>& operator%= (const T& t){ + for(size_t i=0;i<length;++i){ + data[i] %= t; + } + return *this; + } + valarray<T>& operator+= (const T& t){ + for(size_t i=0;i<length;++i){ + data[i] += t; + } + return *this; + } + valarray<T>& operator-= (const T& t){ + for(size_t i=0;i<length;++i){ + data[i] -= t; + } + return *this; + } + valarray<T>& operator^= (const T& t){ + for(size_t i=0;i<length;++i){ + data[i] ^= t; + } + return *this; + } + valarray<T>& operator&= (const T& t){ + for(size_t i=0;i<length;++i){ + data[i] &= t; + } + return *this; + } + valarray<T>& operator|= (const T& t){ + for(size_t i=0;i<length; ++i){ + data[i] |= t; + } + return *this; + } + valarray<T>& operator<<=(const T& t){ + for(size_t i=0;i<length;++i){ + data[i] <<= t; + } + return *this; + } + valarray<T>& operator>>=(const T& t){ + for(size_t i=0;i<length;++i){ + data[i] >>= t; + } + return *this; + } + valarray<T>& operator*= (const valarray<T>& a){ + for(size_t i=0;i<length;++i){ + data[i] *= a.data[i]; + } + return *this; + } + valarray<T>& operator/= (const valarray<T>& a){ + for(size_t i=0;i<length;++i){ + data[i] /= a.data[i]; + } + return *this; + } + valarray<T>& operator%= (const valarray<T>& a){ + for(size_t i=0;i<length;++i){ + data[i] %= a.data[i]; + } + return *this; + } + valarray<T>& operator+= (const valarray<T>& a){ + for(size_t i=0;i<length;++i){ + data[i] += a.data[i]; + } + return *this; + } + valarray<T>& operator-= (const valarray<T>& a){ + for(size_t i=0;i<length ;++i){ + data[i] -= a.data[i]; + } + return *this; + } + valarray<T>& operator^= (const valarray<T>& a){ + for(size_t i=0;i<length;++i){ + data[i] ^= a.data[i]; + } + return *this; + } + valarray<T>& operator|= (const valarray<T>& a){ + for(size_t i=0;i<length ;++i){ + data[i] |= a.data[i]; + } + return *this; + } + valarray<T>& operator&= (const valarray<T>& a){ + for(size_t i=0;i<length;++i){ + data[i] &= a.data[i]; + } + return *this; + } + valarray<T>& operator<<=(const valarray<T>& a){ + for(size_t i=0;i<length;++i){ + data[i] <<= a.data[i]; + } + return *this; + } + valarray<T>& operator>>=(const valarray<T>& a){ + for(size_t i=0;i<length;++i){ + data[i] >>= a.data[i]; + } + return *this; + } +#if 0 + void swap(valarray& other) noexcept { + std::swap(length, other.length); + std::swap(data, other.data); + } +#endif + size_t size() const{ + return length; + } + + T sum() const{ + T retval(data[0]); + for(size_t i = 1; i< length; ++i){ + retval += data[i]; + } + return retval; + } + + T min() const{ + T retval(data[0]); + for(size_t i = 1; i< length; ++i){ + if(data[i] < retval){ + retval = data[i]; + } + } + return retval; + } + + T max() const{ + T retval(data[0]); + for(size_t i = 1; i< length; ++i){ + if(retval < data[i]){ + retval = data[i]; + } + } + return retval; + } + + valarray<T> shift (int n) const{ + valarray<T> retval(length); + if (n < 0) { + if (-size_t(n) > length) + n = -int(length); + } else { + if (size_t(n) > length) + n = int(length); + } + for (size_t i = 0; i < length ; ++i) { + if ((n + i) < length) + retval.data[i] = data[n + i]; + } + return retval; + } + valarray<T> cshift(int n) const{ + valarray<T> retval(length); + if (length == 0) + return retval; + if (n < 0) { + if (-size_t(n) > length) + n = -int(-size_t(n) % length); + n = length + n; + } else { + if (size_t(n) > length) + n = int(size_t(n) % length); + } + for (size_t i = 0; i < length ; ++i){ + retval.data[i] = data[(n + i) % length]; + } + return retval; + } + valarray<T> apply(T func(T) ) const{ + valarray<T> retval(length); + for(size_t i = 0; i< length; ++i){ + retval.data[i] = func(data[i]); + } + return retval; + } + valarray<T> apply(T func(const T&)) const{ + valarray<T> retval(length); + for(size_t i = 0; i< length; ++i){ + retval.data[i] = func(data[i]); + } + return retval; + } + void resize(size_t sz, T c = T()){ + delete [] data; + data = 0; + if(sz > 0){ + data = new T[sz]; + for(size_t i = 0; i < sz; ++i){ + data[i] = c; + } + } + length = sz; + } + }; + + + + template <class T> class _UCXXEXPORT slice_array { + friend class valarray<T>; + public: + typedef T value_type; + + void operator= (const valarray<T>& v) const{ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] = v[i]; + } + } + void operator= (const T & v){ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] = v; + } + } + void fill(const T & v){ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] = v; + } + } + void operator*= (const valarray<T>& v) const{ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] *= v[i]; + } + } + void operator/= (const valarray<T>& v) const{ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] /= v[i]; + } + } + void operator%= (const valarray<T>& v) const{ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] %= v[i]; + } + } + void operator+= (const valarray<T>& v) const{ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] += v[i]; + } + } + void operator-= (const valarray<T>& v) const{ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] -= v[i]; + } + } + void operator^= (const valarray<T>& v) const{ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] ^= v[i]; + } + } + void operator&= (const valarray<T>& v) const{ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] &= v[i]; + } + } + void operator|= (const valarray<T>& v) const{ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] |= v[i]; + } + } + void operator<<=(const valarray<T>& v) const{ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] <<= v[i]; + } + } + void operator>>=(const valarray<T>& v) const{ + for(unsigned int i = 0; i < s.size(); ++i){ + array->data[s.start() + i * s.stride()] >>= v[i]; + } + } + ~slice_array(){ + array = 0; + } + + private: + slice_array() : array(0){ } + + public: + slice_array(const slice_array& sa) : array(sa.array), s(sa.s){ } + slice_array& operator=(const slice_array& sa){ + array = sa.array; + s = sa.s; + return *this; + } + + private: + valarray<T> * array; + slice s; + }; + + + class _UCXXEXPORT gslice { + private: + size_t sta; + valarray<size_t> siz; + valarray<size_t> str; + + public: + gslice() : sta(0), siz(), str() { } // DR 543 + gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d) + : sta(s), siz(l), str(d) { } + + size_t start() const{ + return sta; + } + valarray<size_t> size() const{ + return siz; + } + valarray<size_t> stride() const{ + return str; + } + }; + + template <class T> class gslice_array { + private: + friend class valarray<T>; + + public: + ~gslice_array(); + + void operator=(const valarray<T>& array) const; + void operator*=(const valarray<T>& array) const; + void operator/=(const valarray<T>& array) const; + void operator%=(const valarray<T>& array) const; + void operator+=(const valarray<T>& array) const; + void operator-=(const valarray<T>& array) const; + void operator^=(const valarray<T>& array) const; + void operator&=(const valarray<T>& array) const; + void operator|=(const valarray<T>& array) const; + void operator<<=(const valarray<T>& array) const; + void operator>>=(const valarray<T>& array) const; + + void operator=(const T&); + + private: + gslice_array(); + gslice_array(const gslice_array<T>&); + gslice_array<T>& operator= (const gslice_array<T>& array); + }; + + + + template<class T> valarray<T> operator* (const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs); + retval *= rhs; + return retval; + } + + template<class T> valarray<T> operator* (const valarray<T>& lhs, const T& rhs){ + valarray<T> retval(lhs); + retval *= rhs; + return retval; + } + template<class T> valarray<T> operator* (const T& lhs, const valarray<T>& rhs){ + valarray<T> retval(rhs); + retval *= lhs; + return retval; + } + template<class T> valarray<T> operator/ (const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs); + retval /= rhs; + return retval; + } + template<class T> valarray<T> operator/ (const valarray<T>& lhs, const T& rhs){ + valarray<T> retval(lhs); + retval /= rhs; + return retval; + } + template<class T> valarray<T> operator/ (const T& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs, rhs.size()); + retval /= rhs; + return retval; + } + template<class T> valarray<T> operator% (const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs); + retval %= rhs; + return retval; + } + template<class T> valarray<T> operator% (const valarray<T>& lhs, const T& rhs){ + valarray<T> retval(lhs); + retval %= rhs; + return retval; + } + template<class T> valarray<T> operator% (const T& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs, rhs.size()); + retval %= rhs; + return retval; + } + template<class T> valarray<T> operator+ (const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs); + retval += rhs; + return retval; + } + template<class T> valarray<T> operator+ (const valarray<T>& lhs, const T& rhs){ + valarray<T> retval(lhs); + retval += rhs; + return retval; + } + template<class T> valarray<T> operator+ (const T& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs, rhs.size()); + retval += rhs; + return retval; + } + template<class T> valarray<T> operator- (const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs); + retval -= rhs; + return retval; + } + template<class T> valarray<T> operator- (const valarray<T>& lhs, const T& rhs){ + valarray<T> retval(lhs); + retval -= rhs; + return retval; + } + template<class T> valarray<T> operator- (const T& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs, rhs.size()); + retval -= rhs; + return retval; + } + template<class T> valarray<T> operator^ (const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs); + retval ^= rhs; + return retval; + } + template<class T> valarray<T> operator^ (const valarray<T>& lhs, const T& rhs){ + valarray<T> retval(lhs); + retval ^= rhs; + return retval; + } + template<class T> valarray<T> operator^ (const T& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs, rhs.size()); + retval ^= rhs; + return retval; + } + template<class T> valarray<T> operator& (const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs); + retval &= rhs; + return retval; + } + template<class T> valarray<T> operator& (const valarray<T>& lhs, const T& rhs){ + valarray<T> retval(lhs); + retval &= rhs; + return retval; + } + template<class T> valarray<T> operator& (const T& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs, rhs.size()); + retval &= rhs; + return retval; + } + template<class T> valarray<T> operator| (const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs); + retval |= rhs; + return retval; + } + template<class T> valarray<T> operator| (const valarray<T>& lhs, const T& rhs){ + valarray<T> retval(lhs); + retval |= rhs; + return retval; + } + template<class T> valarray<T> operator| (const T& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs, rhs.size()); + retval |= rhs; + return retval; + } + template<class T> valarray<T> operator<<(const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs); + retval <<= rhs; + return retval; + } + template<class T> valarray<T> operator<<(const valarray<T>& lhs, const T& rhs){ + valarray<T> retval(lhs); + retval <<= rhs; + return retval; + } + template<class T> valarray<T> operator<<(const T& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs, rhs.size()); + retval <<= rhs; + return retval; + } + template<class T> valarray<T> operator>>(const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs); + retval >>= rhs; + return retval; + } + template<class T> valarray<T> operator>>(const valarray<T>& lhs, const T& rhs){ + valarray<T> retval(lhs); + retval >>= rhs; + return retval; + } + template<class T> valarray<T> operator>>(const T& lhs, const valarray<T>& rhs){ + valarray<T> retval(lhs, rhs.size()); + retval >>= rhs; + return retval; + } + + template<class T> valarray<bool> operator&&(const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = lhs[i] && rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator&&(const valarray<T>& lhs, const T& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] && rhs; + } + return retval; + } + template<class T> valarray<bool> operator&&(const T& lhs, const valarray<T>& rhs){ + valarray<bool> retval(rhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs && rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator||(const valarray<T>&lhs, const valarray<T>& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] || rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator||(const valarray<T>& lhs, const T& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] || rhs; + } + return retval; + } + template<class T> valarray<bool> operator||(const T& lhs, const valarray<T>& rhs){ + valarray<bool> retval(rhs.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = lhs || rhs[i]; + } + return retval; + } + + template<class T> valarray<bool> operator==(const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] == rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator==(const valarray<T>& lhs, const T& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = lhs[i] == rhs; + } + return retval; + } + template<class T> valarray<bool> operator==(const T& lhs, const valarray<T>& rhs){ + valarray<bool> retval(rhs.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = lhs == rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator!=(const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] != rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator!=(const valarray<T>& lhs, const T& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] != rhs; + } + return retval; + } + template<class T> valarray<bool> operator!=(const T& lhs, const valarray<T>& rhs){ + valarray<bool> retval(rhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs != rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator< (const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] < rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator< (const valarray<T>& lhs, const T& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] < rhs; + } + return retval; + } + template<class T> valarray<bool> operator< (const T& lhs, const valarray<T>& rhs){ + valarray<bool> retval(rhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs < rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator> (const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] > rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator> (const valarray<T>& lhs, const T& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] > rhs; + } + return retval; + } + template<class T> valarray<bool> operator> (const T& lhs, const valarray<T>& rhs){ + valarray<bool> retval(rhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs > rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator<=(const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] <= rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator<=(const valarray<T>& lhs, const T& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] <= rhs; + } + return retval; + } + template<class T> valarray<bool> operator<=(const T& lhs, const valarray<T>& rhs){ + valarray<bool> retval(rhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs <= rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator>=(const valarray<T>& lhs, const valarray<T>& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] >= rhs[i]; + } + return retval; + } + template<class T> valarray<bool> operator>=(const valarray<T>& lhs, const T& rhs){ + valarray<bool> retval(lhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs[i] >= rhs; + } + return retval; + } + template<class T> valarray<bool> operator>=(const T& lhs, const valarray<T>& rhs){ + valarray<bool> retval(rhs.size()); + for(size_t i = 0; i <retval.size(); ++i){ + retval[i] = lhs >= rhs[i]; + } + return retval; + } + template<class T> T min(const valarray<T>& x){ + T retval(x[0]); + for(size_t i = 1; i < x.size(); ++i){ + if(x[i] < retval){ + retval = x[i]; + } + } + } + template<class T> T max(const valarray<T>& x){ + T retval(x[0]); + for(size_t i = 1; i < x.size(); ++i){ + if(x[i] > retval){ + retval = x[i]; + } + } + } + + template<class T> valarray<T> abs (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = abs(x[i]); + } + return retval; + } + template<class T> valarray<T> acos (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = acos(x[i]); + } + return retval; + } + template<class T> valarray<T> asin (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = asin(x[i]); + } + return retval; + } + template<class T> valarray<T> atan (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = atan(x[i]); + } + return retval; + } + template<class T> valarray<T> atan2(const valarray<T>& y, const valarray<T>& x){ + valarray<T> retval(y.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = atan2(y[i], x[i]); + } + return retval; + } + template<class T> valarray<T> atan2(const valarray<T>& y, const T& x){ + valarray<T> retval(y.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = atan2(y[i], x); + } + return retval; + } + template<class T> valarray<T> atan2(const T& y, const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = atan2(y, x[i]); + } + return retval; + } + template<class T> valarray<T> cos (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = cos(x[i]); + } + return retval; + } + template<class T> valarray<T> cosh (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = cosh(x[i]); + } + return retval; + } + template<class T> valarray<T> exp (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = exp(x[i]); + } + return retval; + } + template<class T> valarray<T> log (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = log(x[i]); + } + return retval; + } + template<class T> valarray<T> log10(const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = log10(x[i]); + } + return retval; + } + template<class T> valarray<T> pow (const valarray<T>& x, const valarray<T>& y){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = pow(x[i], y[i]); + } + return retval; + } + template<class T> valarray<T> pow (const valarray<T>& x, const T& y){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = pow(x[i], y); + } + return retval; + } + template<class T> valarray<T> pow (const T& x, const valarray<T>& y){ + valarray<T> retval(y.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = pow(x, y[i]); + } + return retval; + } + template<class T> valarray<T> sin (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = sin(x[i]); + } + return retval; + } + template<class T> valarray<T> sinh (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = sinh(x[i]); + } + return retval; + } + template<class T> valarray<T> sqrt (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = sqrt(x[i]); + } + return retval; + } + template<class T> valarray<T> tan (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = tan(x[i]); + } + return retval; + } + template<class T> valarray<T> tanh (const valarray<T>& x){ + valarray<T> retval(x.size()); + for(size_t i = 0; i < retval.size(); ++i){ + retval[i] = tanh(x[i]); + } + return retval; + } +} + +#pragma GCC visibility pop + +#endif |