valarray

realview22.rar

// -*- C++ -*-
/***************************************************************************
 *
 * valaray - Declarations for the Standard Library valarray
 *
 * $Id: valarray,v 1.1.1.1 2002/01/10 17:38:30 vkorstan Exp $
 *
 ***************************************************************************
 *
 * Copyright (c) 1994-2001 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--Restricted Rights at 48 CFR 52.227-19,
 * as applicable.  Manufacturer is Rogue Wave Software, Inc., 5500
 * Flatiron Parkway, Boulder, Colorado 80301 USA.
 *
 **************************************************************************/

#ifndef _RWSTD_VALARRAY_INCLUDED
#define _RWSTD_VALARRAY_INCLUDED

#include <algorithm>
#include <functional>
#include <numeric>

#include <rw/_math.h>
#include <rw/_array.h>


_RWSTD_NAMESPACE_BEGIN (std)

// forward declarations
class _RWSTD_EXPORT slice;

template <class _TypeT> class slice_array;

class _RWSTD_EXPORT gslice;

template <class _TypeT> class gslice_array;

template <class _TypeT> class mask_array;

template <class _TypeT> class indirect_array;


// 26.3.2
template <class _TypeT>
class valarray
{
public:

    typedef _TypeT value_type;

    // 26.3.2.1, p1
    valarray () { }

    // 26.3.2.1, p2
    _EXPLICIT valarray (size_t __size)
        : _C_array (value_type (), __size) { }

    // 26.3.2.1, p3
    valarray (const value_type& __val, size_t __size)
        : _C_array (__val, __size) { }

    // 26.3.2.1, p4
    valarray (const value_type* __p, size_t __size)
        : _C_array (__p, __size) { }

    // 26.3.2.1, p5
    valarray (const valarray& __rhs)
        : _C_array (__rhs._C_array) { }

    // 26.3.2.1, p6
    valarray (const slice_array<value_type>&);
    valarray (const gslice_array<value_type>&);
    valarray (const mask_array<value_type>&);
    valarray (const indirect_array<value_type>&);

    // 26.3.2.2, p1 - assignment
    valarray& operator= (const valarray &__rhs) {
        if (this != &__rhs)
            _C_array = __rhs._C_array;
        return *this;
    }

    // 26.3.2.2, p2 - assignment
    valarray& operator= (const value_type &__val) {
        return _STD::fill (_C_array.begin (), _C_array.end (), __val), *this;
    }

    // 26.3.2.2, p3 - assignment
    valarray& operator= (const slice_array<value_type>&);
    valarray& operator= (const gslice_array<value_type>&);
    valarray& operator= (const mask_array<value_type>&);
    valarray& operator= (const indirect_array<value_type>&);

    // 26.3.2.3 - element access
    value_type operator[] (size_t __i) const {
        _RWSTD_ASSERT (__i < size ());
        return _C_array[__i];
    }

    value_type& operator[] (size_t __i) {
        _RWSTD_ASSERT (__i < size ());
        return _C_array[__i];
    }

    // 26.3.2.4 - subset operations
    valarray                   operator[] (slice) const;
    slice_array<value_type>    operator[] (slice);
    valarray                   operator[] (const gslice&) const;
    gslice_array<value_type>   operator[] (const gslice&);
    valarray                   operator[] (const valarray<bool>&) const;
    mask_array<value_type>     operator[] (const valarray<bool>&);
    valarray                   operator[] (const valarray<size_t>&) const;
    indirect_array<value_type> operator[] (const valarray<size_t>&);

    // 26.3.2.5 - unary operators
    valarray operator+ () const;
    valarray operator- () const;
    valarray operator~ () const;
    valarray<bool> operator! () const;

    // 26.3.2.6, p1 - computed assignment
    valarray& operator*= (const valarray&);
    valarray& operator/= (const valarray&);
    valarray& operator+= (const valarray&);
    valarray& operator-= (const valarray&);
    valarray& operator%= (const valarray&);
    valarray& operator^= (const valarray&);
    valarray& operator&= (const valarray&);
    valarray& operator|= (const valarray&);
    valarray& operator<<= (const valarray&);
    valarray& operator>>= (const valarray&);

    // 26.3.2.6, p5 - computed assignment
    valarray& operator*= (const value_type&);
    valarray& operator/= (const value_type&);
    valarray& operator%= (const value_type&);
    valarray& operator+= (const value_type&);
    valarray& operator-= (const value_type&);
    valarray& operator^= (const value_type&);
    valarray& operator&= (const value_type&);
    valarray& operator|= (const value_type&);
    valarray& operator<<= (const value_type&);
    valarray& operator>>= (const value_type&);

    // 26.3.2.7, p1
    size_t size () const {
        return _C_array.size ();
    }

    // 26.3.2.7, p2
    value_type sum () const {
        return accumulate (_C_array.begin (), _C_array.end (), value_type ());
    }

    // 26.3.2.7, p3
    value_type min () const {
        _RWSTD_ASSERT (0 != size ());
        return *min_element (_C_array.begin (), _C_array.end ());
    }

    // 26.3.2.7, p4
    value_type max () const {
        _RWSTD_ASSERT (0 != size ());
        return *max_element (_C_array.begin (), _C_array.end ());
    }

    // 26.3.2.7, p5 - ordinary shift
    valarray shift (int) const;

    // 26.3.2.7, p7 - circular shift
    valarray cshift (int) const;

    // 26.3.2.7, p8
    valarray apply (value_type func (value_type)) const;
    valarray apply (value_type func (const value_type&)) const;

    // 26.3.2.7, p9
    void resize (size_t __size, value_type __val = value_type ()) {
        _C_array.resize (__size, __val);
    }

    // implementation
    valarray (_RW::__rw_array<value_type> &__rhs) {
        _C_array.swap (__rhs);
    }

    _RW::__rw_array<value_type> _C_array;
};


_RWSTD_NAMESPACE_END   // std


_RWSTD_NAMESPACE_BEGIN (__rw)


template<class _TypeT, class _UnaryFunction>
inline _STD::valarray<_TypeT>
__rw_unary_function (const _STD::valarray<_TypeT> &__val, _UnaryFunction __fun)
{
    // allocate but do not initialize
    __rw_array<_TypeT> __tmp (__val.size ());

    typedef _STD::raw_storage_iterator<_TypeT*, _TypeT> _Iter;

    // apply `fun' to each element of `a' and initialize `tmp'
    _STD::transform (__val._C_array.begin (), __val._C_array.end (),
                     _Iter (__tmp.begin ()), __fun);
    
    return _STD::valarray<_TypeT>(__tmp);
}


// implements symmetric non-member valarray binary operators
template<class _TypeT, class _BinaryFunction>
inline _STD::valarray<_TYPENAME _BinaryFunction::result_type>
__rw_binary_function (const _STD::valarray<_TypeT> &__lhs, 
                      const _STD::valarray<_TypeT> &__rhs, 
                      _BinaryFunction               __fun)
{
    typedef _TYPENAME _BinaryFunction::result_type                result_type;
    typedef _STD::raw_storage_iterator<result_type*, result_type> _Iter;

    // allocate but do not initialize
    __rw_array<result_type> __tmp =
        __rw_array<result_type>(_STD::min (__lhs.size (), __rhs.size ()));

    // apply `fun' to each pair of elements of `lhs' and `rhs'
    _STD::transform (__lhs._C_array.begin (),
                     __lhs._C_array.begin () + __tmp.size (), 
                     __rhs._C_array.begin (), _Iter (__tmp.begin ()), __fun);
    
    return _STD::valarray<result_type>(__tmp);
}


// implements asymmetric non-member valarray binary operators
template<class _TypeT, class _BinaryFunction>
inline _STD::valarray<_TYPENAME _BinaryFunction::result_type>
__rw_binary_function (const _STD::valarray<_TypeT> &__val, 
                      _BinaryFunction               __fun)
{
    typedef _TYPENAME _BinaryFunction::result_type                result_type;
    typedef _STD::raw_storage_iterator<result_type*, result_type> _Iter;

    // allocate but do not initialize
    __rw_array<result_type> __tmp = __rw_array<result_type>(__val.size ());

    // apply `fun' to each element of `a' and initialize `tmp'
    _STD::transform (__val._C_array.begin (), __val._C_array.end (),
                     _Iter (__tmp.begin ()), __fun);
    
    return _STD::valarray<result_type>(__tmp);
}


template <class _TypeT, class _UnaryFunction>
inline void
__rw_unary_function (const _STD::slice_array<_TypeT>&,
                     const _STD::valarray<_TypeT>&,
                     _UnaryFunction);


template <class _TypeT, class _BinaryFunction>
inline void 
__rw_binary_function (const _STD::slice_array<_TypeT>&,
                      const _STD::valarray<_TypeT>&,
                      _BinaryFunction);


template <class _TypeT, class _UnaryFunction>
inline void
__rw_unary_function (const _STD::mask_array<_TypeT>&,
                     const _STD::valarray<_TypeT>&,
                     _UnaryFunction);


template <class _TypeT, class _BinaryFunction>
inline void
__rw_binary_function (const _STD::mask_array<_TypeT>&,
                      const _STD::valarray<_TypeT>&,
                      _BinaryFunction);


template <class _TypeT, class _UnaryFunction>
inline void
__rw_unary_function (const _STD::indirect_array<_TypeT>&,
                     const _STD::valarray<_TypeT>&,
                     _UnaryFunction);


template <class _TypeT, class _BinaryFunction>
inline void
__rw_binary_function (const _STD::indirect_array<_TypeT>&,
                      const _STD::valarray<_TypeT>&,
                      _BinaryFunction);


_RWSTD_NAMESPACE_END   // __rw


_RWSTD_NAMESPACE_BEGIN (std)


template<class _TypeT>
inline valarray<_TypeT>
valarray<_TypeT>::operator+ () const
{
    return _RW::__rw_unary_function (*this, _RW::unary_plus<_TypeT>());
}


template <class _TypeT>
inline valarray<_TypeT>
valarray<_TypeT>::operator- () const
{
    return _RW::__rw_unary_function (*this, negate<_TypeT>());
}


template <class _TypeT>
inline valarray<_TypeT>
valarray<_TypeT>::operator~ () const
{
    return _RW::__rw_unary_function (*this, _RW::bitwise_complement<_TypeT>());
}


template <class _TypeT>
inline valarray<bool> valarray<_TypeT>::operator! () const
{
    _RW::__rw_array<bool> __tmp = _RW::__rw_array<bool>(size ());

    transform (_C_array.begin (), _C_array.end (), __tmp.begin (), 
               logical_not<_TypeT>());
    
    return valarray<bool>(__tmp);
}


template <class _TypeT>
inline valarray<_TypeT>&
valarray<_TypeT>::operator*= (const valarray<_TypeT>& __rhs)
{
    transform (_C_array.begin (), 
               _C_array.begin () + _STD::min (size (), __rhs.size ()), 
               __rhs._C_array.begin (), _C_array.begin (), 
               multiplies<_TypeT>());

    return *this;
}


template <class _TypeT>
inline valarray<_TypeT>&
valarray<_TypeT>::operator/= (const valarray<_TypeT>& __rhs)
{
    transform (_C_array.begin (), 
               _C_array.begin () + _STD::min (size (), __rhs.size ()), 
               __rhs._C_array.begin (), _C_array.begin (), 
               divides<_TypeT>());

    return *this;
}


template <class _TypeT>
inline valarray<_TypeT>&
valarray<_TypeT>::operator+= (const valarray<_TypeT>& __rhs)
{
    transform (_C_array.begin (), 
               _C_array.begin () + _STD::min (size (), __rhs.size ()), 
               __rhs._C_array.begin (), _C_array.begin (), 
               plus<_TypeT>());

    return *this;
}


template <class _TypeT>
inline valarray<_TypeT>&
valarray<_TypeT>::operator-= (const valarray<_TypeT>& __rhs)
{
    transform (_C_array.begin (), 
               _C_array.begin () + _STD::min (size (), __rhs.size ()), 
               __rhs._C_array.begin (), _C_array.begin (), 
               minus<_TypeT>());

    return *this;
}


template <class _TypeT>
inline valarray<_TypeT>&
valarray<_TypeT>::operator%= (const valarray<_TypeT>& __rhs)
{
    transform (_C_array.begin (), 
               _C_array.begin () + _STD::min (size (), __rhs.size ()), 
               __rhs._C_array.begin (), _C_array.begin (), 
               modulus<_TypeT>());

    return *this;
}


template <class _TypeT>
inline valarray<_TypeT>&
valarray<_TypeT>::operator^= (const valarray<_TypeT>& __rhs)
{
    transform (_C_array.begin (), 
               _C_array.begin () + _STD::min (size (), __rhs.size ()), 
               __rhs._C_array.begin (), _C_array.begin (), 
               _RW::exclusive_or<_TypeT>());

    return *this;
}


template <class _TypeT>
inline valarray<_TypeT>&
valarray<_TypeT>::operator&= (const valarray<_TypeT>& __rhs)
{
    transform (_C_array.begin (), 
               _C_array.begin () + _STD::min (size (), __rhs.size ()), 
               __rhs._C_array.begin (), _C_array.begin (), 
               _RW::bitwise_and<_TypeT>());

    return *this;
}


template <class _TypeT>
inline valarray<_TypeT>&
valarray<_TypeT>::operator|= (const valarray<_TypeT>& __rhs)
{
    transform (_C_array.begin (), 
               _C_array.begin () + _STD::min (size (), __rhs.size ()), 
               __rhs._C_array.begin (), _C_array.begin (), 
               _RW::bitwise_or<_TypeT>());

    return *this;
}


template <class _TypeT>
inline valarray<_TypeT>&
valarray<_TypeT>::operator<<= (const valarray<_TypeT>& __rhs)
{
    transform (_C_array.begin (), 
               _C_array.begin () + _STD::min (size (), __rhs.size ()),