MichaelAgarkov/CodeBlocksPortable
MichaelAgarkov/CodeBlocksPortable
Archived
1
1
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
This repository has been archived on 2024-12-16. You can view files and clone it, but cannot push or open issues or pull requests.
CodeBlocksPortable/Borland/BCC55/Include/valarray.h

787 lines
21 KiB
C
Raw Normal View History

My portable distribution of Code::Blocks
2024-07-04 16:52:56 +00:00
#ifndef __VALARRAY_H
#define __VALARRAY_H
#pragma option push -b -a8 -pc -Vx- -Ve- -w-inl -w-aus -w-sig
// -*- C++ -*-
#ifndef __RW_VALARRAY__
#define __RW_VALARRAY__
/***************************************************************************
*
* valaray - Declarations for the Standard Library valarray
*
***************************************************************************
*
* Copyright (c) 1994-1999 Rogue Wave Software, Inc. All Rights Reserved.
*
* This computer software is owned by Rogue Wave Software, Inc. and is
* protected by U.S. copyright laws and other laws and by international
* treaties. This computer software is furnished by Rogue Wave Software,
* Inc. pursuant to a written license agreement and may be used, copied,
* transmitted, and stored only in accordance with the terms of such
* license and with the inclusion of the above copyright notice. This
* computer software or any other copies thereof may not be provided or
* otherwise made available to any other person.
*
* U.S. Government Restricted Rights. This computer software is provided
* with Restricted Rights. Use, duplication, or disclosure by the
* Government is subject to restrictions as set forth in subparagraph (c)
* (1) (ii) of The Rights in Technical Data and Computer Software clause
* at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
* Commercial Computer Software <EFBFBD> Restricted Rights at 48 CFR 52.227-19,
* as applicable. Manufacturer is Rogue Wave Software, Inc., 5500
* Flatiron Parkway, Boulder, Colorado 80301 USA.
*
**************************************************************************/
#include <rw/valimp>
#ifndef _RWSTD_NO_NAMESPACE
namespace std {
#endif
// forward declarations
class _RWSTDExport slice;
template <class T> class slice_array;
class _RWSTDExport gslice;
template <class T> class gslice_array;
template <class T> class mask_array;
template <class T> class indirect_array;
/*************************************************************
* CLASS VALARRAY *
*************************************************************/
template <class T> class valarray {
public:
typedef T value_type;
// constructors
valarray( ) {;}
_EXPLICIT valarray(size_t size)
{ memory_array._initial_size(size); }
valarray(const T& value, size_t size)
{ memory_array._initialize_with_value(value,size); }
valarray(const T* pointer, size_t size)
{ memory_array._initialize_with_array(pointer,size); }
valarray(const valarray<T>& array)
{ memory_array._copy_memory_array(array._RW_get_memory_array()); }
valarray(const slice_array<T>&);
valarray(const gslice_array<T>&);
valarray(const mask_array<T>&);
valarray(const indirect_array<T>&);
// operator =
valarray<T>& operator= (const valarray<T>& array)
{
if ( this != &array )
memory_array._copy_memory_array(array._RW_get_memory_array());
return *this;
}
valarray<T>& operator= (const T&);
valarray<T>& operator= (const slice_array<T>&);
valarray<T>& operator= (const gslice_array<T>&);
valarray<T>& operator= (const mask_array<T>&);
valarray<T>& operator= (const indirect_array<T>&);
// operator[]
T operator[] (size_t ind) const
{ return memory_array[ind]; }
T& operator[] (size_t ind)
{ return memory_array[ind]; }
valarray<T> operator[](slice) const;
inline slice_array<T> operator[](slice);
valarray<T> operator[](const gslice&) const;
inline gslice_array<T> operator[](const gslice&);
valarray<T> operator[](const valarray<bool>&) const;
inline mask_array<T> operator[](const valarray<bool>&);
valarray<T> operator[](const valarray<size_t>&) const;
inline indirect_array<T> operator[](const valarray<size_t>&);
// unary operators
valarray<T> operator+() const;
valarray<T> operator-() const;
#ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
valarray<T> operator~() const;
valarray<bool> operator!() const;
#endif
// computed assignment
valarray<T>& operator*= (const valarray<T>& array);
valarray<T>& operator/= (const valarray<T>& array);
valarray<T>& operator+= (const valarray<T>& array);
valarray<T>& operator-= (const valarray<T>& array);
#ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
valarray<T>& operator%= (const valarray<T>& array);
valarray<T>& operator^= (const valarray<T>& array);
valarray<T>& operator&= (const valarray<T>& array);
valarray<T>& operator|= (const valarray<T>& array);
valarray<T>& operator<<= (const valarray<T>& array);
valarray<T>& operator>>= (const valarray<T>& array);
#endif
valarray<T>& operator*= (const T& val);
valarray<T>& operator/= (const T& val);
valarray<T>& operator%= (const T& val);
valarray<T>& operator+= (const T& val);
valarray<T>& operator-= (const T& val);
valarray<T>& operator^= (const T& val);
valarray<T>& operator&= (const T& val);
valarray<T>& operator|= (const T& val);
valarray<T>& operator<<= (const T& val);
valarray<T>& operator>>= (const T& val);
// others
size_t size() const { return memory_array._get_length(); }
T sum() const;
#ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
T min() const;
T max() const;
#endif
valarray<T> shift(int sh) const;
valarray<T> cshift(int sh) const;
valarray<T> apply(T func(T)) const;
valarray<T> apply(T func(const T&)) const;
void free()
{ memory_array._RW_resize_without_copy(0); }
void resize(size_t sz, const T c= T() )
{
memory_array._RW_resize_without_copy(sz);
*this = c;
}
// implementation specific
const _RW_IMP_SPACE(_RW_array<T>)& _RW_get_memory_array( ) const
{ return memory_array; }
_RW_IMP_SPACE(_RW_array<T>)* _RW_get_memory_array_adr( )
{ return &memory_array; }
valarray(_RW_IMP_SPACE(_RW_temporary<T>)* tmp)
{
memory_array._replace(tmp->store_adr,tmp->length);
delete tmp;
}
private:
_RW_IMP_SPACE(_RW_array<T>) memory_array;
};
/*
* VALARRAY INLINE MEMBER FUNCTIONS
*/
template <class T>
inline valarray<T>& valarray<T>::operator=(const T& value)
{
memory_array._initialize_with_value(value, size());
return *this;
}
// operator[] for slice
template <class T>
inline slice_array<T> valarray<T>::operator[](slice sl)
{
return slice_array<T>(&memory_array, sl);
}
// operator[] for gslice
template <class T>
inline gslice_array<T> valarray<T>::operator[](const gslice& sl)
{
return gslice_array<T>(&memory_array, sl);
}
// operator[] for valarray[valarray<bool>] used with mask_array
template <class T>
inline mask_array<T> valarray<T>::operator[](const valarray<bool>& array)
{
return mask_array<T>(&memory_array, array);
}
// operator[] for valarray[valarray<size_t>] used with indirect_array
template <class T>
inline indirect_array<T> valarray<T>::operator[](const valarray<size_t>& array)
{
return indirect_array<T>(&memory_array, array);
}
/*
*
* VALARRAY NON MEMBER FUNCTIONS
*
*/
// binary operators
template<class T>
valarray<T> operator* (const valarray<T>& , const valarray<T>& );
template<class T>
valarray<T> operator/ (const valarray<T>& , const valarray<T>& );
template<class T>
valarray<T> operator% (const valarray<T>&, const valarray<T>&);
template<class T>
valarray<T> operator+ (const valarray<T>& , const valarray<T>& );
template<class T>
valarray<T> operator- (const valarray<T>& , const valarray<T>& );
template<class T>
valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
template<class T>
valarray<T> operator& (const valarray<T>&, const valarray<T>&);
template<class T>
valarray<T> operator| (const valarray<T>&, const valarray<T>&);
template<class T>
valarray<T> operator<< (const valarray<T>&, const valarray<T>&);
template<class T>
valarray<T> operator>> (const valarray<T>&, const valarray<T>&);
template<class T>
valarray<bool> operator&& (const valarray<T>&, const valarray<T>&);
template<class T>
valarray<bool> operator|| (const valarray<T>&, const valarray<T>&);
// with non array second param
template<class T>
valarray<T> operator* (const valarray<T>& , const T& );
template<class T>
valarray<T> operator/ (const valarray<T>& , const T& );
template<class T>
valarray<T> operator% (const valarray<T>&, const T&);
template<class T>
valarray<T> operator+ (const valarray<T>& , const T& );
template<class T>
valarray<T> operator- (const valarray<T>& , const T& );
template<class T>
valarray<T> operator^ (const valarray<T>&, const T&);
template<class T>
valarray<T> operator& (const valarray<T>&, const T&);
template<class T>
valarray<T> operator| (const valarray<T>&, const T&);
template<class T>
valarray<T> operator<< (const valarray<T>&, const T&);
template<class T>
valarray<T> operator>> (const valarray<T>&, const T&);
template<class T>
valarray<bool> operator&& (const valarray<T>&, const T&);
template<class T>
valarray<bool> operator|| (const valarray<T>&, const T&);
// with non array first param
template<class T>
valarray<T> operator* (const T& , const valarray<T>& );
template<class T>
valarray<T> operator/ (const T& , const valarray<T>& );
template<class T>
valarray<T> operator% (const T&, const valarray<T>&);
template<class T>
valarray<T> operator+ (const T& , const valarray<T>& );
template<class T>
valarray<T> operator- (const T& , const valarray<T>& );
template<class T>
valarray<T> operator^ (const T&, const valarray<T>&);
template<class T>
valarray<T> operator& (const T&, const valarray<T>&);
template<class T>
valarray<T> operator| (const T&, const valarray<T>&);
template<class T>
valarray<T> operator<< (const T&, const valarray<T>&);
template<class T>
valarray<T> operator>> (const T&, const valarray<T>&);
template<class T>
valarray<bool> operator&& (const T&, const valarray<T>&);
template<class T>
valarray<bool> operator|| (const T&, const valarray<T>&);
// comparison operators
template<class T>
valarray<bool> operator== (const valarray<T>& , const valarray<T>& );
template<class T>
valarray<bool> operator!= (const valarray<T>& , const valarray<T>& );
template<class T>
valarray<bool> operator< (const valarray<T>& , const valarray<T>& );
template<class T>
valarray<bool> operator> (const valarray<T>& , const valarray<T>& );
template<class T>
valarray<bool> operator<= (const valarray<T>& , const valarray<T>& );
template<class T>
valarray<bool> operator>= (const valarray<T>& , const valarray<T>& );
// comparison operators, non valarray second param
template<class T>
valarray<bool> operator== (const valarray<T>& , const T& );
template<class T>
valarray<bool> operator!= (const valarray<T>& , const T& );
template<class T>
valarray<bool> operator< (const valarray<T>& , const T& );
template<class T>
valarray<bool> operator> (const valarray<T>& , const T& );
template<class T>
valarray<bool> operator<= (const valarray<T>& , const T& );
template<class T>
valarray<bool> operator>= (const valarray<T>& , const T& );
// comparison operators, non valarray first param
template<class T>
valarray<bool> operator== (const T& , const valarray<T>& );
template<class T>
valarray<bool> operator!= (const T& , const valarray<T>& );
template<class T>
valarray<bool> operator< (const T& , const valarray<T>& );
template<class T>
valarray<bool> operator> (const T& , const valarray<T>& );
template<class T>
valarray<bool> operator<= (const T& , const valarray<T>& );
template<class T>
valarray<bool> operator>= (const T& , const valarray<T>& );
// transcendentals
template<class T>
valarray<T> abs(const valarray<T>& );
template<class T>
valarray<T> acos(const valarray<T>& );
template<class T>
valarray<T> asin(const valarray<T>& );
template<class T>
valarray<T> atan(const valarray<T>& );
template<class T>
valarray<T> cos(const valarray<T>& );
template<class T>
valarray<T> cosh(const valarray<T>& );
template<class T>
valarray<T> exp(const valarray<T>& );
template<class T>
valarray<T> log(const valarray<T>& );
template<class T>
valarray<T> log10(const valarray<T>& );
template<class T>
valarray<T> sinh(const valarray<T>& );
template<class T>
valarray<T> sin(const valarray<T>& );
template<class T>
valarray<T> sqrt(const valarray<T>& );
template<class T>
valarray<T> tan(const valarray<T>& );
template<class T>
valarray<T> tanh(const valarray<T>& );
template<class T>
valarray<T> atan2(const valarray<T>& , const valarray<T>& );
template<class T>
valarray<T> atan2(const valarray<T>& , const T& );
template<class T>
valarray<T> atan2(const T& , const valarray<T>& );
template<class T>
valarray<T> pow(const valarray<T>& , const valarray<T>& );
template<class T>
valarray<T> pow(const valarray<T>& , const T& );
template<class T>
valarray<T> pow(const T& , const valarray<T>& );
// Global min and max template fonction
// for compiler that try to instantiate all the member function
#ifdef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
template <class T> T max(const valarray<T>&);
template <class T> T min(const valarray<T>&);
#endif
/****************************************************************
* SLICE AND SLICE_ARRAY *
****************************************************************/
class _RWSTDExport slice {
public:
slice()
: start_(0), length_(0), stride_(0)
{;}
slice(size_t start, size_t length, size_t stride)
: start_(start)
, length_(length)
, stride_(stride)
{;}
slice(const slice& sl)
:start_(sl.start())
,length_(sl.size())
,stride_(sl.stride())
{;}
size_t start() const { return start_; }
size_t size() const { return length_; }
size_t stride() const { return stride_; }
private:
size_t start_;
size_t length_;
size_t stride_;
};
template <class T> class slice_array {
public:
typedef T value_type;
slice_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const slice& a )
:ref_mem_array(pt)
,slice_(a)
{;}
slice_array(const slice_array<T>& sl)
:ref_mem_array(sl.get_ref_mem_array())
,slice_(sl.get_slice())
{;}
_RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
slice get_slice() const { return slice_; }
// assignment
void operator= (const valarray<T>& ) const;
void operator= (const T&) const;
// computed assignment
void operator*= (const valarray<T>& ) const;
void operator/= (const valarray<T>& ) const;
void operator+= (const valarray<T>& ) const;
void operator-= (const valarray<T>& ) const;
#ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
void operator%= (const valarray<T>& ) const;
void operator^= (const valarray<T>& ) const;
void operator&= (const valarray<T>& ) const;
void operator|= (const valarray<T>& ) const;
void operator<<= (const valarray<T>& ) const;
void operator>>= (const valarray<T>& ) const;
#endif
private:
slice_array();
slice_array<T>& operator= (const slice_array<T>&);
_RW_IMP_SPACE(_RW_array<T>)* ref_mem_array;
slice slice_;
};
/****************************************************************
* GSLICE AND GSLICE_ARRAY *
****************************************************************/
class _RWSTDExport gslice {
public:
gslice()
: start_(0)
, reset_(true)
{;}
gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d)
: start_(s)
, length_(l)
, stride_(d)
, reset_(true)
, r_length_((size_t)0,l.size())
{;}
gslice(const gslice& sl)
: start_(sl.start())
, length_(sl.size())
, stride_(sl.stride())
, reset_(true)
, r_length_((size_t)0,sl.size().size())
{;}
size_t start() const { return start_; }
valarray<size_t> size() const { return length_; }
valarray<size_t> stride() const { return stride_; }
size_t next_ind();
inline size_t is_reseted() const { return reset_; }
size_t ind_max() const;
size_t ind_numb() const;
private:
size_t start_;
valarray<size_t> length_;
valarray<size_t> stride_;
bool reset_;
valarray<size_t> r_length_;
};
// class gslice_array
template <class T> class gslice_array {
public:
typedef T value_type;
gslice_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const gslice& a )
:ref_mem_array(pt)
,slice_(a)
{;}
gslice_array(const gslice_array<T>& sl)
:ref_mem_array(sl.get_ref_mem_array())
,slice_(sl.get_slice())
{;}
_RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
gslice get_slice() const { return slice_; }
// assignment
void operator= (const valarray<T>& ) const;
void operator= (const T&) const;
// computed assignment
void operator*= (const valarray<T>& ) const;
void operator/= (const valarray<T>& ) const;
void operator+= (const valarray<T>& ) const;
void operator-= (const valarray<T>& ) const;
#ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
void operator%= (const valarray<T>& ) const;
void operator^= (const valarray<T>& ) const;
void operator&= (const valarray<T>& ) const;
void operator|= (const valarray<T>& ) const;
void operator<<= (const valarray<T>& ) const;
void operator>>= (const valarray<T>& ) const;
#endif
private:
gslice_array();
gslice_array<T>& operator= (const gslice_array<T>&);
_RW_IMP_SPACE(_RW_array<T>)* ref_mem_array;
gslice slice_;
};
/****************************************************************
* MASK_ARRAY *
****************************************************************/
// class mask_array
template <class T> class mask_array {
public:
typedef T value_type;
mask_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const valarray<bool>& a )
:ref_mem_array(pt)
,array(a)
{;}
mask_array(const mask_array<T>& sl)
:ref_mem_array(sl.get_ref_mem_array())
,array(sl.get_array())
{;}
_RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
valarray<bool> get_array() const { return array; }
valarray<bool>* get_array_pt() { return &array; }
// assignment
void operator= (const valarray<T>& ) const;
void operator= (const T&) const;
// computed assignment
void operator*= (const valarray<T>& ) const;
void operator/= (const valarray<T>& ) const;
void operator+= (const valarray<T>& ) const;
void operator-= (const valarray<T>& ) const;
#ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
void operator%= (const valarray<T>& ) const;
void operator^= (const valarray<T>& ) const;
void operator&= (const valarray<T>& ) const;
void operator|= (const valarray<T>& ) const;
void operator<<= (const valarray<T>& ) const;
void operator>>= (const valarray<T>& ) const;
#endif
private:
mask_array();
mask_array<T>& operator= (const mask_array<T>&);
_RW_IMP_SPACE(_RW_array<T>)* ref_mem_array;
valarray<bool> array;
};
/****************************************************************
* INDIRECT_ARRAY *
****************************************************************/
// class indirect_array
template <class T> class indirect_array {
public:
typedef T value_type;
indirect_array( _RW_IMP_SPACE(_RW_array<T>)* pt,const valarray<size_t>& a )
:ref_mem_array(pt)
,array(a)
{;}
indirect_array(const indirect_array<T>& sl)
:ref_mem_array(sl.get_ref_mem_array())
,array(sl.get_array())
{;}
_RW_IMP_SPACE(_RW_array<T>)* get_ref_mem_array() const { return ref_mem_array; }
valarray<size_t> get_array() const { return array; }
valarray<size_t>* get_array_pt() { return &array; }
// assignment
void operator= (const valarray<T>& ) const;
void operator= (const T& ) const;
// computed assignment
void operator*= (const valarray<T>& ) const;
void operator/= (const valarray<T>& ) const;
void operator+= (const valarray<T>& ) const;
void operator-= (const valarray<T>& ) const;
#ifndef _RWSTD_NO_ONLY_NEEDED_INSTANTIATION
void operator%= (const valarray<T>& ) const;
void operator^= (const valarray<T>& ) const;
void operator&= (const valarray<T>& ) const;
void operator|= (const valarray<T>& ) const;
void operator<<= (const valarray<T>& ) const;
void operator>>= (const valarray<T>& ) const;
#endif
private:
indirect_array();
indirect_array<T>& operator= (const indirect_array<T>&);
_RW_IMP_SPACE(_RW_array<T>)* ref_mem_array;
valarray<size_t> array;
};
#ifndef _RWSTD_NO_NAMESPACE
}
#endif
#ifdef _RWSTD_NO_TEMPLATE_REPOSITORY
#include <valarray.cc>
#endif
#endif /* __VALARRAY__ */
#ifndef __USING_STD_NAMES__
using namespace std;
#endif
#pragma option pop
#endif /* __VALARRAY_H */
Reference in a new issue Copy permalink