valarray< _Ty > Class Template Reference

Public Types
typedef valarray< _Ty >	_Myt
typedef _Ty	value_type

Public Member Functions
	valarray ()
	valarray (size_t _Count)
	valarray (const _Ty &_Val, size_t _Count)
	valarray (const _Ty *_Ptr, size_t _Count)
	valarray (const _Myt &_Right)
	valarray (const slice_array< _Ty > &_Slicearr)
	valarray (const gslice_array< _Ty > &_Gslicearr)
	valarray (const mask_array< _Ty > &_Maskarr)
	valarray (const indirect_array< _Ty > &_Indarr)
	valarray (_Myt &&_Right) _NOEXCEPT
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT
void	_Assign_rv (_Myt &&_Right)
	valarray (_XSTD initializer_list< _Ty > _Ilist)
_Myt &	operator= (_XSTD initializer_list< _Ty > _Ilist)
void	swap (_Myt &_Right) _NOEXCEPT
	~valarray () _NOEXCEPT
_Myt &	operator= (const _Myt &_Right)
_Myt &	operator= (const _Ty &_Val)
void	resize (size_t _Newsize)
void	resize (size_t _Newsize, _Ty _Val)
_Myt &	operator= (const slice_array< _Ty > &_Slicearr)
_Myt &	operator= (const gslice_array< _Ty > &_Gslicearr)
_Myt &	operator= (const mask_array< _Ty > &_Maskarr)
_Myt &	operator= (const indirect_array< _Ty > &_Indarr)
_Myt	operator+ () const
_Myt	operator- () const
_Myt	operator~ () const
_Boolarray	operator! () const
_Myt &	operator*= (const _Ty &_Right)
_Myt &	operator/= (const _Ty &_Right)
_Myt &	operator%= (const _Ty &_Right)
_Myt &	operator+= (const _Ty &_Right)
_Myt &	operator-= (const _Ty &_Right)
_Myt &	operator^= (const _Ty &_Right)
_Myt &	operator&= (const _Ty &_Right)
_Myt &	operator|= (const _Ty &_Right)
_Myt &	operator<<= (const _Ty &_Right)
_Myt &	operator>>= (const _Ty &_Right)
_Myt &	operator*= (const _Myt &_Right)
_Myt &	operator/= (const _Myt &_Right)
_Myt &	operator%= (const _Myt &_Right)
_Myt &	operator+= (const _Myt &_Right)
_Myt &	operator-= (const _Myt &_Right)
_Myt &	operator^= (const _Myt &_Right)
_Myt &	operator|= (const _Myt &_Right)
_Myt &	operator&= (const _Myt &_Right)
_Myt &	operator<<= (const _Myt &_Right)
_Myt &	operator>>= (const _Myt &_Right)
size_t	size () const
const _Ty &	operator[] (size_t _Off) const
_Ty &	operator[] (size_t _Off)
_Myt	operator[] (slice _Slicearr) const
slice_array< _Ty >	operator[] (slice _Slicearr)
_Myt	operator[] (const gslice &_Gslicearr) const
gslice_array< _Ty >	operator[] (const gslice &_Gslicearr)
_Myt	operator[] (const _Boolarray &_Boolarr) const
mask_array< _Ty >	operator[] (const _Boolarray &_Boolarr)
_Myt	operator[] (const _Sizarray &_Indarr) const
indirect_array< _Ty >	operator[] (const _Sizarray &_Indarr)
_Ty	sum () const
_Ty()	min () const
_Ty()	max () const
_Myt	shift (int _Count) const
_Myt	cshift (int _Count) const
_Myt	apply (_Ty _Func(_Ty)) const
_Myt	apply (_Ty _Func(const _Ty &)) const
void()	free ()

Private Member Functions
void	_Grow (size_t _Newsize)
void	_Grow (size_t _Newsize, const _Ty *_Ptr, size_t _Inc=0)
void	_Tidy (bool _Constructed=false)
void	_Assign (size_t _Newsize, const _Ty *_Ptr)

Private Attributes
_Ty *	_Myptr
size_t	_Mysize

Member Typedef Documentation

template<class _Ty>

typedef valarray<_Ty> valarray< _Ty >::_Myt

template<class _Ty>

typedef _Ty valarray< _Ty >::value_type

Constructor & Destructor Documentation

template<class _Ty>

valarray< _Ty >::valarray ( )

inline

        {   // construct empty valarray
        _Tidy();
        }

template<class _Ty>

valarray< _Ty >::valarray ( size_t  _Count )

inlineexplicit

        {   // construct with _Count * _Ty()
        _Tidy();
        _Grow(_Count);
        }

template<class _Ty>

valarray< _Ty >::valarray ( const _Ty &  _Val, size_t  _Count  )

inline

        {   // construct with _Count * _Val
        _Tidy();
        _Grow(_Count, &_Val);
        }

template<class _Ty>

valarray< _Ty >::valarray ( const _Ty *  _Ptr, size_t  _Count  )

inline

        {   // construct with [_Ptr, _Ptr + _Count)
        _Tidy();
        _Grow(_Count, _Ptr, 1);
        }

template<class _Ty>

valarray< _Ty >::valarray ( const _Myt &  _Right )

inline

        {   // construct from valarray
        _Tidy();
        _Grow(_Right.size(), _Right._Myptr, 1);
        }

template<class _Ty>

valarray< _Ty >::valarray ( const slice_array< _Ty > &  _Slicearr )

inline

        {   // construct from slice_array
        _Tidy();
        *this = _Slicearr;
        }

template<class _Ty>

valarray< _Ty >::valarray ( const gslice_array< _Ty > &  _Gslicearr )

inline

        {   // construct from gslice_array
        _Tidy();
        *this = _Gslicearr;
        }

template<class _Ty>

valarray< _Ty >::valarray ( const mask_array< _Ty > &  _Maskarr )

inline

        {   // construct from mask_array
        _Tidy();
        *this = _Maskarr;
        }

template<class _Ty>

valarray< _Ty >::valarray ( const indirect_array< _Ty > &  _Indarr )

inline

        {   // construct from indirect_array
        _Tidy();
        *this = _Indarr;
        }

template<class _Ty>

valarray< _Ty >::valarray ( _Myt &&  _Right )

inline

        {   // construct by moving _Right
        _Tidy();
        _Assign_rv(_STD forward<_Myt>(_Right));
        }

template<class _Ty>

valarray< _Ty >::valarray ( _XSTD initializer_list< _Ty >  _Ilist )

inline

        {   // construct from initializer_list
        _Tidy();
        _Grow(_Ilist.size(), _Ilist.begin(), 1);
        }

template<class _Ty>

valarray< _Ty >::~valarray ( )

inline

        {   // destroy the object
        _Tidy(true);
        }

Member Function Documentation

template<class _Ty>

void valarray< _Ty >::_Assign ( size_t  _Newsize, const _Ty *  _Ptr  )

inlineprivate

        {   // assign [_Ptr, _Ptr + _Newsize)
        if (size() == _Newsize)
            for (size_t _Idx = 0; _Idx < size(); ++_Idx)
                _Myptr[_Idx] = _Ptr[_Idx];
        else
            {   // resize and copy
            _Tidy(true);
            _Grow(_Newsize, _Ptr, 1);
            }
        }

template<class _Ty>

void valarray< _Ty >::_Assign_rv ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        if (this != &_Right)
            {   // clear this and steal from _Right
            _Tidy(true);
            _Myptr = _Right._Myptr;
            _Mysize = _Right._Mysize;
            _Right._Tidy();
            }
        }

template<class _Ty>

void valarray< _Ty >::_Grow ( size_t  _Newsize )

inlineprivate

        {   // grow to _Count elements and pad with default values
        if (0 < _Newsize)
            {   // worth doing, allocate
            _Myptr = _Allocate(_Newsize, (_Ty *)0);

            _TRY_BEGIN
            for (size_t _Idx = 0; _Idx < _Newsize; ++_Idx)
                _Construct(&_Myptr[_Idx]);
            _CATCH_ALL
            _Tidy(true);    // construction failed, clean up and reraise
            _RERAISE;
            _CATCH_END

            _Mysize = _Newsize;
            }
        }

template<class _Ty>

void valarray< _Ty >::_Grow ( size_t  _Newsize, const _Ty *  _Ptr, size_t  _Inc = 0  )

inlineprivate

        {   // grow to _Count elements and fill
        if (0 < _Newsize)
            {   // worth doing, allocate
            _Myptr = _Allocate(_Newsize, (_Ty *)0);

            _TRY_BEGIN
            for (size_t _Idx = 0; _Idx < _Newsize; ++_Idx, _Ptr += _Inc)
                _Construct(&_Myptr[_Idx], *_Ptr);
            _CATCH_ALL
            _Tidy(true);    // construction failed, clean up and reraise
            _RERAISE;
            _CATCH_END

            _Mysize = _Newsize;
            }
        }

template<class _Ty>

void valarray< _Ty >::_Tidy ( bool  _Constructed = false )

inlineprivate

        {   // initialize the object, freeing any allocated storage
        if (_Constructed && _Myptr != 0)
            {   // destroy elements
            for (size_t _Idx = 1; _Idx < _Mysize; ++_Idx)
                _Destroy(&_Myptr[_Idx]);
            delete _Myptr;
            }

        _Mysize = 0;
        _Myptr = 0;
        }

template<class _Ty>

_Myt valarray< _Ty >::apply ( _Ty   _Func_Ty ) const

inline

        {   // return valarray transformed by _Func, value argument
        _VALOP(_Ty, size(), _Func(_Myptr[_Idx]));
        }

template<class _Ty>

_Myt valarray< _Ty >::apply ( _Ty   _Funcconst _Ty & ) const

inline

        {   // return valarray transformed by _Func, nonmutable argument
        _VALOP(_Ty, size(), _Func(_Myptr[_Idx]));
        }

template<class _Ty>

_Myt valarray< _Ty >::cshift ( int  _Count ) const

inline

        {   // return valarray left rotated
        if (size() == 0)
            ;   // no shift
        else if (_Count < 0)
            {   // right shift
            if (size() < (size_t)0 - _Count)
                _Count = (int)(size() - ((size_t)0 - _Count - size())
                    % size());
            else
                _Count = (int)(size() + _Count);
            }
        else if (size() <= (size_t)_Count)
            _Count %= size();

        _VALOP(_Ty, size(), size() - _Idx <= (size_t)_Count
            ? _Myptr[_Idx - size() + _Count] : _Myptr[_Idx + _Count]);
        }

template<class _Ty>

void() valarray< _Ty >::free ( )

inline

        {   // erase all elements
        _Tidy(true);
        }

template<class _Ty>

_Ty() valarray< _Ty >::max ( ) const

inline

        {   // return largest of all elements
        _Ty _Max = _Myptr[0];
        for (size_t _Idx = 0; ++_Idx < size(); )
            if (_Max < _Myptr[_Idx])
                _Max = _Myptr[_Idx];
        return (_Max);
        }

template<class _Ty>

_Ty() valarray< _Ty >::min ( ) const

inline

        {   // return smallest of all elements
        _Ty _Min = _Myptr[0];
        for (size_t _Idx = 0; ++_Idx < size(); )
            if (_Myptr[_Idx] < _Min)
                _Min = _Myptr[_Idx];
        return (_Min);
        }

template<class _Ty>

_Boolarray valarray< _Ty >::operator! ( ) const

inline

        {   // return !valarray
        _VALOP(_Bool, size(), !_Myptr[_Idx]);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator%= ( const _Ty &  _Right )

inline

        {   // remainder valarray elements by _Right
        _VALGOP(%= _Right);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator%= ( const _Myt &  _Right )

inline

        {   // remainder valarray elements by valarray _Right elements
        _VALGOP(%= _Right[_Idx]);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator&= ( const _Ty &  _Right )

inline

        {   // AND _Right into valarray elements
        _VALGOP(&= _Right);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator&= ( const _Myt &  _Right )

inline

        {   // AND valarray _Right elements into valarray elements
        _VALGOP(&= _Right[_Idx]);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator*= ( const _Ty &  _Right )

inline

        {   // multiply valarray elements by _Right
        _VALGOP(*= _Right);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator*= ( const _Myt &  _Right )

inline

        {   // multiply valarray elements by valarray _Right elements
        _VALGOP(*= _Right[_Idx]);
        }

template<class _Ty>

_Myt valarray< _Ty >::operator+ ( ) const

inline

        {   // return +valarray
        _VALOP(_Ty, size(), +_Myptr[_Idx]);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator+= ( const _Ty &  _Right )

inline

        {   // add _Right to valarray elements
        _VALGOP(+= _Right);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator+= ( const _Myt &  _Right )

inline

        {   // add valarray _Right elements to valarray elements
        _VALGOP(+= _Right[_Idx]);
        }

template<class _Ty>

_Myt valarray< _Ty >::operator- ( void  ) const

inline

        {   // return -valarray
        _VALOP(_Ty, size(), -_Myptr[_Idx]);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator-= ( const _Ty &  _Right )

inline

        {   // subtract _Right from valarray elements
        _VALGOP(-= _Right);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator-= ( const _Myt &  _Right )

inline

        {   // subtract valarray _Right elements from valarray elements
        _VALGOP(-= _Right[_Idx]);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator/= ( const _Ty &  _Right )

inline

        {   // divide valarray elements by _Right
        _VALGOP(/= _Right);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator/= ( const _Myt &  _Right )

inline

        {   // divide valarray elements by valarray _Right elements
        _VALGOP(/= _Right[_Idx]);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator<<= ( const _Ty &  _Right )

inline

        {   // left shift valarray elements by _Right
        _VALGOP(<<= _Right);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator<<= ( const _Myt &  _Right )

inline

        {   // left shift valarray elements by valarray _Right elements
        _VALGOP(<<= _Right[_Idx]);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator= ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        _Assign_rv(_STD forward<_Myt>(_Right));
        return (*this);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator= ( _XSTD initializer_list< _Ty >  _Ilist )

inline

        {   // assign initializer_list
        _Assign(_Ilist.size(), _Ilist.begin());
        return (*this);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator= ( const _Myt &  _Right )

inline

        {   // assign valarray _Right
        if (this != &_Right)
            _Assign(_Right.size(), _Right._Myptr);
        return (*this);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator= ( const _Ty &  _Val )

inline

        {   // assign _Val to each element
        _VALGOP(= _Val);
        }

template<class _Ty>

valarray< _Ty > & valarray< _Ty >::operator= ( const slice_array< _Ty > &  _Slicearr )

inline

    {   // assign slice array to valarray
    _Tidy(true);
    _Grow(_Slicearr.size(), &_Slicearr._Data(_Slicearr.start()),
        _Slicearr.stride());
    return (*this);
    }

template<class _Ty>

valarray< _Ty > & valarray< _Ty >::operator= ( const gslice_array< _Ty > &  _Gslicearr )

inline

    {   // assign generalized slice array to valarray
    _Tidy(true);
    _Grow(_Gslicearr._Totlen());
    _Sizarray _Indexarray((size_t)0, _Gslicearr._Nslice());
    _VALGOP(= _Gslicearr._Data(_Gslicearr._Off(_Indexarray)));
    }

template<class _Ty>

valarray< _Ty > & valarray< _Ty >::operator= ( const mask_array< _Ty > &  _Maskarr )

inline

    {   // assign masked array to valarray
    _Tidy(true);
    _Grow(_Maskarr._Totlen());
    size_t _Count = 0;

    for (size_t _Idx = 0; _Idx < size(); ++_Count)
        if (_Maskarr._Mask(_Count))
            _Myptr[_Idx++] = _Maskarr._Data(_Count);
    return (*this);
    }

template<class _Ty>

valarray< _Ty > & valarray< _Ty >::operator= ( const indirect_array< _Ty > &  _Indarr )

inline

    {   // assign indirect array to valarray
    _Tidy(true);
    _Grow(_Indarr._Totlen());
    _VALGOP(= _Indarr._Data(_Indarr._Indir(_Idx)));
    }

template<class _Ty>

_Myt& valarray< _Ty >::operator>>= ( const _Ty &  _Right )

inline

        {   // right shift valarray elements by _Right
        _VALGOP(>>= _Right);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator>>= ( const _Myt &  _Right )

inline

        {   // right shift valarray elements by valarray _Right elements
        _VALGOP(>>= _Right[_Idx]);
        }

template<class _Ty>

const _Ty& valarray< _Ty >::operator[] ( size_t  _Off ) const

inline

        {   // subscript nonmutable sequence
        return (_Myptr[_Off]);
        }

template<class _Ty>

_Ty& valarray< _Ty >::operator[] ( size_t  _Off )

inline

        {   // subscript mutable sequence
        return (_Myptr[_Off]);
        }

template<class _Ty >

valarray< _Ty > valarray< _Ty >::operator[] ( slice  _Slicearr ) const

inline

    {   // subscript nonmutable valarray by slice
    return (valarray<_Ty>(slice_array<_Ty>(_Slice, _Myptr)));
    }

template<class _Ty >

slice_array< _Ty > valarray< _Ty >::operator[] ( slice  _Slicearr )

inline

    {   // subscript mutable valarray by slice
    return (slice_array<_Ty>(_Slice, _Myptr));
    }

template<class _Ty >

valarray< _Ty > valarray< _Ty >::operator[] ( const gslice &  _Gslicearr ) const

inline

    {   // subscript nonmutable valarray by generalized slice
    return (valarray<_Ty>(gslice_array<_Ty>(_Gslice, _Myptr)));
    }

template<class _Ty >

gslice_array< _Ty > valarray< _Ty >::operator[] ( const gslice &  _Gslicearr )

inline

    {   // subscript mutable valarray by generalized slice
    return (gslice_array<_Ty>(_Gslicearr, _Myptr));
    }

template<class _Ty >

valarray< _Ty > valarray< _Ty >::operator[] ( const _Boolarray &  _Boolarr ) const

inline

    {   // subscript nonmutable valarray by boolean (mask) array
    return (valarray<_Ty>(mask_array<_Ty>(_Boolarr, _Myptr)));
    }

template<class _Ty >

mask_array< _Ty > valarray< _Ty >::operator[] ( const _Boolarray &  _Boolarr )

inline

    {   // subscript nonmutable valarray by boolean (mask) array
    return (mask_array<_Ty>(_Boolarr, _Myptr));
    }

template<class _Ty >

valarray< _Ty > valarray< _Ty >::operator[] ( const _Sizarray &  _Indarr ) const

inline

    {   // subscript nonmutable valarray by indirect (mapping) array
    return (valarray<_Ty>(indirect_array<_Ty>(_Indarr, _Myptr)));
    }

template<class _Ty >

indirect_array< _Ty > valarray< _Ty >::operator[] ( const _Sizarray &  _Indarr )

inline

    {   // subscript mutable valarray by indirect (mapping) array
    return (indirect_array<_Ty>(_Indarr, _Myptr));
    }

template<class _Ty>

_Myt& valarray< _Ty >::operator^= ( const _Ty &  _Right )

inline

        {   // XOR _Right into valarray elements
        _VALGOP(^= _Right);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator^= ( const _Myt &  _Right )

inline

        {   // XOR valarray _Right elements into valarray elements
        _VALGOP(^= _Right[_Idx]);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator|= ( const _Ty &  _Right )

inline

        {   // OR _Right into valarray elements
        _VALGOP(|= _Right);
        }

template<class _Ty>

_Myt& valarray< _Ty >::operator|= ( const _Myt &  _Right )

inline

        {   // OR valarray _Right elements into valarray elements
        _VALGOP(|= _Right[_Idx]);
        }

template<class _Ty>

_Myt valarray< _Ty >::operator~ ( ) const

inline

        {   // return ~valarray
        _VALOP(_Ty, size(), ~_Myptr[_Idx]);
        }

template<class _Ty>

void valarray< _Ty >::resize ( size_t  _Newsize )

inline

        {   // determine new length, filling with _Ty() elements
        _Tidy(true);
        _Grow(_Newsize);
        }

template<class _Ty>

void valarray< _Ty >::resize ( size_t  _Newsize, _Ty  _Val  )

inline

        {   // determine new length, filling with _Val elements
        _Tidy(true);
        _Grow(_Newsize, &_Val, 0);
        }

template<class _Ty>

_Myt valarray< _Ty >::shift ( int  _Count ) const

inline

        {   // return valarray left shifted
        __PURE_APPDOMAIN_GLOBAL static _Ty _Dflt;
        _VALOP(_Ty, size(),
            0 < _Count && size() - _Idx <= (size_t)_Count
                || _Count < 0 && _Idx < (size_t)-_Count
                    ? _Dflt : _Myptr[_Idx + _Count]);
        }

template<class _Ty>

size_t valarray< _Ty >::size ( ) const

inline

        {   // return length of sequence
        return (_Mysize);
        }

template<class _Ty>

_Ty valarray< _Ty >::sum ( ) const

inline

        {   // return sum all elements
        _Ty _Sum = _Myptr[0];
        for (size_t _Idx = 0; ++_Idx < size(); )
            _Sum += _Myptr[_Idx];
        return (_Sum);
        }

template<class _Ty>

void valarray< _Ty >::swap ( _Myt &  _Right )

inline

        {   // exchange contents with _Right
        if (this != &_Right)
            {   // swap with emptied container
            _STD swap(_Myptr, _Right._Myptr);
            _STD swap(_Mysize, _Right._Mysize);
            }
        }

Member Data Documentation

template<class _Ty>

_Ty* valarray< _Ty >::_Myptr

private

template<class _Ty>

size_t valarray< _Ty >::_Mysize

private

---

The documentation for this class was generated from the following file:

• VS2013/inc/valarray