mirror of
https://gcc.gnu.org/git/gcc.git
synced 2025-01-24 13:24:33 +08:00
std_valarray.h: New file.
* std/std_valarray.h: New file. * std/slice.h: New file. * std/slice_array.h: New file. * std/gslice.h: New file. * std/gslice_array.h: New file. * std/mask_array.h: New file. * std/indirect_array.h: New file. * std/valarray_array.h: New file. * std/valarray_array.tcc: New file. * std/valarray_meta.h: New file. * valarray.cc: New file. * valarray: New file * Makefile.in (OBJS): add valarray.o (HEADERS): add valarray (valarray.o): define dependency on valarray.cc (install): make it possible to install valarray files. From-SVN: r27354
This commit is contained in:
Gabriel Dos Reis
Gabriel Dos Reis
parent
5c5d086f85
commit
27ac1891d2
@ -1,3 +1,23 @@
|
||||
1999-06-06 Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
|
||||
|
||||
* std/std_valarray.h: New file.
|
||||
* std/slice.h: New file.
|
||||
* std/slice_array.h: New file.
|
||||
* std/gslice.h: New file.
|
||||
* std/gslice_array.h: New file.
|
||||
* std/mask_array.h: New file.
|
||||
* std/indirect_array.h: New file.
|
||||
* std/valarray_array.h: New file.
|
||||
* std/valarray_array.tcc: New file.
|
||||
* std/valarray_meta.h: New file.
|
||||
* valarray.cc: New file.
|
||||
* valarray: New file
|
||||
|
||||
* Makefile.in (OBJS): add valarray.o
|
||||
(HEADERS): add valarray
|
||||
(valarray.o): define dependency on valarray.cc
|
||||
(install): make it possible to install valarray file.
|
||||
|
||||
Wed Jun 2 00:21:54 1999 Robert Lipe <robertlipe@usa.net>
|
||||
|
||||
* std/bastring.h (class basic_string:Rep): Encode xlock opcode
|
||||
|
||||
@ -19,7 +19,7 @@ INTERFACE = 2
|
||||
|
||||
gxx_include_dir=${includedir}/g++
|
||||
|
||||
OBJS = cstringi.o stdexcepti.o cstdlibi.o cmathi.o stlinst.o
|
||||
OBJS = cstringi.o stdexcepti.o cstdlibi.o cmathi.o stlinst.o valarray.o
|
||||
SUBLIBS = $(STAMP)-string $(STAMP)-complx
|
||||
|
||||
# C++ headers with no extension
|
||||
@ -28,7 +28,7 @@ HEADERS= cassert cctype cerrno cfloat ciso646 climits clocale cmath complex \
|
||||
cwchar cwctype string stdexcept \
|
||||
algorithm deque functional hash_map hash_set iterator list map \
|
||||
memory numeric pthread_alloc queue rope set slist stack utility \
|
||||
vector fstream iomanip iostream strstream iosfwd bitset
|
||||
vector fstream iomanip iostream strstream iosfwd bitset valarray
|
||||
|
||||
ARLIB = libstdc++.a.$(VERSION)
|
||||
ARLINK = libstdc++.a
|
||||
@ -130,6 +130,7 @@ cstdlibi.o: cstdlibi.cc
|
||||
cmathi.o: cmathi.cc
|
||||
stdexcepti.o: stdexcepti.cc
|
||||
stlinst.o: stlinst.cc
|
||||
valarray.o: valarray.cc
|
||||
|
||||
# Later do wide strings, too.
|
||||
stmp-string: ${srcdir}/sinst.cc ${srcdir}/std/bastring.h \
|
||||
@ -269,7 +270,7 @@ install:
|
||||
fi ; \
|
||||
chmod a-x $(gxx_include_dir)/$$FILE ; \
|
||||
done ; \
|
||||
for FILE in *.h std/*.h std/*.cc; do \
|
||||
for FILE in *.h std/*.h std/*.cc std/*.tcc; do \
|
||||
rm -f $(gxx_include_dir)/$$FILE ; \
|
||||
$(INSTALL_DATA) $$FILE $(gxx_include_dir)/$$FILE ; \
|
||||
chmod a-x $(gxx_include_dir)/$$FILE ; \
|
||||
|
||||
111
libstdc++/std/gslice.h
Normal file
111
libstdc++/std/gslice.h
Normal file
@ -0,0 +1,111 @@
|
||||
// The template and inlines for the -*- C++ -*- gslice class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
#ifndef __GSLICE__
|
||||
#define __GSLICE__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
struct _Indexer {
|
||||
size_t _M_count;
|
||||
size_t _M_start;
|
||||
valarray<size_t> _M_size;
|
||||
valarray<size_t> _M_stride;
|
||||
valarray<size_t> _M_index;
|
||||
_Indexer(size_t, const valarray<size_t>&, const valarray<size_t>&);
|
||||
void _M_increment_use() { ++_M_count; }
|
||||
size_t _M_decrement_use() { return --_M_count; }
|
||||
};
|
||||
|
||||
|
||||
class gslice
|
||||
{
|
||||
public:
|
||||
gslice ();
|
||||
gslice (size_t, const valarray<size_t>&, const valarray<size_t>&);
|
||||
gslice(const gslice&);
|
||||
~gslice();
|
||||
|
||||
gslice& operator= (const gslice&);
|
||||
size_t start () const;
|
||||
valarray<size_t> size () const;
|
||||
valarray<size_t> stride () const;
|
||||
|
||||
private:
|
||||
_Indexer* _M_index;
|
||||
|
||||
template<typename _Tp> friend class valarray;
|
||||
};
|
||||
|
||||
inline size_t
|
||||
gslice::start () const
|
||||
{ return _M_index ? _M_index->_M_start : 0; }
|
||||
|
||||
inline valarray<size_t>
|
||||
gslice::size () const
|
||||
{ return _M_index ? _M_index->_M_size : valarray<size_t>(); }
|
||||
|
||||
inline valarray<size_t>
|
||||
gslice::stride () const
|
||||
{ return _M_index ? _M_index->_M_stride : valarray<size_t>(); }
|
||||
|
||||
inline gslice::gslice () : _M_index(0) {}
|
||||
|
||||
inline
|
||||
gslice::gslice(size_t __o, const valarray<size_t>& __l,
|
||||
const valarray<size_t>& __s)
|
||||
: _M_index(new _Indexer(__o, __l, __s)) {}
|
||||
|
||||
inline
|
||||
gslice::gslice(const gslice& __g) : _M_index(__g._M_index)
|
||||
{ if (_M_index) _M_index->_M_increment_use(); }
|
||||
|
||||
inline
|
||||
gslice::~gslice()
|
||||
{ if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; }
|
||||
|
||||
inline gslice&
|
||||
gslice::operator= (const gslice& __g)
|
||||
{
|
||||
if (__g._M_index) __g._M_index->_M_increment_use();
|
||||
if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index;
|
||||
_M_index = __g._M_index;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __GSLICE__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
170
libstdc++/std/gslice_array.h
Normal file
170
libstdc++/std/gslice_array.h
Normal file
@ -0,0 +1,170 @@
|
||||
// The template and inlines for the -*- C++ -*- gslice_array class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
#ifndef __GSLICE_ARRAY__
|
||||
#define __GSLICE_ARRAY__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template<typename _Tp> class gslice_array
|
||||
{
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
|
||||
void operator= (const valarray<_Tp>&) const;
|
||||
void operator*= (const valarray<_Tp>&) const;
|
||||
void operator/= (const valarray<_Tp>&) const;
|
||||
void operator%= (const valarray<_Tp>&) const;
|
||||
void operator+= (const valarray<_Tp>&) const;
|
||||
void operator-= (const valarray<_Tp>&) const;
|
||||
void operator^= (const valarray<_Tp>&) const;
|
||||
void operator&= (const valarray<_Tp>&) const;
|
||||
void operator|= (const valarray<_Tp>&) const;
|
||||
void operator<<=(const valarray<_Tp>&) const;
|
||||
void operator>>=(const valarray<_Tp>&) const;
|
||||
void operator=(const _Tp&);
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>= (const _Expr<_Dom,_Tp>&) const;
|
||||
|
||||
private:
|
||||
_Array<_Tp> _M_array;
|
||||
const valarray<size_t>& _M_index;
|
||||
|
||||
friend class valarray<_Tp>;
|
||||
|
||||
gslice_array (_Array<_Tp>, const valarray<size_t>&);
|
||||
|
||||
// this constructor needs to be implemented.
|
||||
gslice_array (const gslice_array&);
|
||||
|
||||
// not implemented
|
||||
gslice_array();
|
||||
gslice_array& operator= (const gslice_array&);
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
gslice_array<_Tp>::gslice_array (_Array<_Tp> __a,
|
||||
const valarray<size_t>& __i)
|
||||
: _M_array (__a), _M_index (__i) {}
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
gslice_array<_Tp>::gslice_array (const gslice_array<_Tp>& __a)
|
||||
: _M_array (__a._M_array), _M_index (__a._M_index) {}
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
gslice_array<_Tp>::operator= (const _Tp& __t)
|
||||
{
|
||||
__valarray_fill (_M_array, _Array<size_t>(_M_index),
|
||||
_M_index.size(), __t);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
gslice_array<_Tp>::operator= (const valarray<_Tp>& __v) const
|
||||
{
|
||||
__valarray_copy (_Array<_Tp> (__v), __v.size (),
|
||||
_M_array, _Array<size_t>(_M_index));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
template<class E>
|
||||
inline void
|
||||
gslice_array<_Tp>::operator= (const _Expr<E, _Tp>& __e) const
|
||||
{
|
||||
__valarray_copy (__e, _M_index.size(), _M_array,
|
||||
_Array<size_t>(_M_index));
|
||||
}
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
gslice_array<_Tp>::operator##op##= (const valarray<_Tp>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _Array<size_t>(_M_index), \
|
||||
_Array<_Tp> (__v), __v.size ()); \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> template<class E> \
|
||||
inline void \
|
||||
gslice_array<_Tp>::operator##op##= (const _Expr<E, _Tp>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _Array<size_t>(_M_index), __e, \
|
||||
_M_index.size()); \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
|
||||
#endif // __GSLICE_ARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
157
libstdc++/std/indirect_array.h
Normal file
157
libstdc++/std/indirect_array.h
Normal file
@ -0,0 +1,157 @@
|
||||
// The template and inlines for the -*- C++ -*- indirect_array class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
#ifndef __INDIRECT_ARRAY__
|
||||
#define __INDIRECT_ARRAY__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template <class _Tp> class indirect_array
|
||||
{
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
|
||||
void operator= (const valarray<_Tp>&) const;
|
||||
void operator*= (const valarray<_Tp>&) const;
|
||||
void operator/= (const valarray<_Tp>&) const;
|
||||
void operator%= (const valarray<_Tp>&) const;
|
||||
void operator+= (const valarray<_Tp>&) const;
|
||||
void operator-= (const valarray<_Tp>&) const;
|
||||
void operator^= (const valarray<_Tp>&) const;
|
||||
void operator&= (const valarray<_Tp>&) const;
|
||||
void operator|= (const valarray<_Tp>&) const;
|
||||
void operator<<= (const valarray<_Tp>&) const;
|
||||
void operator>>= (const valarray<_Tp>&) const;
|
||||
void operator= (const _Tp&);
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>= (const _Expr<_Dom, _Tp>&) const;
|
||||
|
||||
private:
|
||||
indirect_array (const indirect_array&);
|
||||
indirect_array (_Array<_Tp>, size_t, _Array<size_t>);
|
||||
|
||||
friend class valarray<_Tp>;
|
||||
friend class gslice_array<_Tp>;
|
||||
|
||||
const size_t _M_sz;
|
||||
const _Array<size_t> _M_index;
|
||||
const _Array<_Tp> _M_array;
|
||||
|
||||
// not implemented
|
||||
indirect_array ();
|
||||
indirect_array& operator= (const indirect_array&);
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
|
||||
: _M_sz (__a._M_sz), _M_index (__a._M_index),
|
||||
_M_array (__a._M_array) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
indirect_array<_Tp>::indirect_array (_Array<_Tp> __a, size_t __s,
|
||||
_Array<size_t> __i)
|
||||
: _M_sz (__s), _M_index (__i), _M_array (__a) {}
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator= (const _Tp& __t)
|
||||
{ __valarray_fill(_M_array, _M_index, _M_sz, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator= (const valarray<_Tp>& __v) const
|
||||
{ __valarray_copy (_Array<_Tp> (__v), _M_sz, _M_array, _M_index); }
|
||||
|
||||
template<typename _Tp>
|
||||
template<class _Dom>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
|
||||
{ __valarray_copy (__e, _M_sz, _M_array, _M_index); }
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
indirect_array<_Tp>::operator##op##= (const valarray<_Tp>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_index, _Array<_Tp> (__v), _M_sz); \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> template<class _Dom> \
|
||||
inline void \
|
||||
indirect_array<_Tp>::operator##op##= (const _Expr<_Dom,_Tp>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_index, __e, _M_sz); \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __INDIRECT_ARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
154
libstdc++/std/mask_array.h
Normal file
154
libstdc++/std/mask_array.h
Normal file
@ -0,0 +1,154 @@
|
||||
// The template and inlines for the -*- C++ -*- mask_array class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
#ifndef __MASK_ARRAY__
|
||||
#define __MASK_ARRAY__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template <class _T> class mask_array
|
||||
{
|
||||
public:
|
||||
typedef _T value_type;
|
||||
|
||||
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;
|
||||
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 _T&);
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<=(const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>=(const _Expr<_Dom,_T>&) const;
|
||||
|
||||
private:
|
||||
mask_array (_Array<_T>, size_t, _Array<bool>);
|
||||
friend class valarray<_T>;
|
||||
|
||||
const size_t _M_sz;
|
||||
const _Array<bool> _M_mask;
|
||||
const _Array<_T> _M_array;
|
||||
|
||||
mask_array (const mask_array&);
|
||||
|
||||
// not implemented
|
||||
mask_array ();
|
||||
mask_array& operator= (const mask_array&);
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline mask_array<_Tp>::mask_array (const mask_array<_Tp>& a)
|
||||
: _M_sz (a._M_sz), _M_mask (a._M_mask), _M_array (a._M_array) {}
|
||||
|
||||
template<typename _T>
|
||||
inline
|
||||
mask_array<_T>::mask_array (_Array<_T> __a, size_t __s, _Array<bool> __m)
|
||||
: _M_sz (__s), _M_mask (__m), _M_array (__a) {}
|
||||
|
||||
template<typename _T>
|
||||
inline void
|
||||
mask_array<_T>::operator= (const _T& __t)
|
||||
{ __valarray_fill (_M_array, _M_sz, _M_mask, __t); }
|
||||
|
||||
template<typename _T>
|
||||
inline void
|
||||
mask_array<_T>::operator= (const valarray<_T>& __v) const
|
||||
{ __valarray_copy (_Array<_T> (__v), __v.size (), _M_array, _M_mask); }
|
||||
|
||||
template<typename _T>
|
||||
template<class E>
|
||||
inline void
|
||||
mask_array<_T>::operator= (const _Expr<E, _T>& __e) const
|
||||
{ __valarray_copy (__e, __e.size (), _M_array, _M_mask); }
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _T> \
|
||||
inline void \
|
||||
mask_array<_T>::operator##op##= (const valarray<_T>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_mask, \
|
||||
_Array<_T> (__v), __v.size ()); \
|
||||
} \
|
||||
\
|
||||
template<typename _T> template<class E> \
|
||||
inline void \
|
||||
mask_array<_T>::operator##op##= (const _Expr<E, _T>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_mask, __e, __e.size ()); \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __MASK_ARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
76
libstdc++/std/slice.h
Normal file
76
libstdc++/std/slice.h
Normal file
@ -0,0 +1,76 @@
|
||||
// The template and inlines for the -*- C++ -*- slice class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
#ifndef __SLICE__
|
||||
#define __SLICE__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
class slice
|
||||
{
|
||||
public:
|
||||
slice ();
|
||||
slice (size_t, size_t, size_t);
|
||||
|
||||
size_t start () const;
|
||||
size_t size () const;
|
||||
size_t stride () const;
|
||||
|
||||
private:
|
||||
size_t _M_off; // offset
|
||||
size_t _M_sz; // size
|
||||
size_t _M_st; // stride unit
|
||||
};
|
||||
|
||||
inline slice::slice () {}
|
||||
|
||||
inline slice::slice (size_t __o, size_t __d, size_t __s)
|
||||
: _M_off (__o), _M_sz (__d), _M_st (__s) {}
|
||||
|
||||
inline size_t
|
||||
slice::start () const
|
||||
{ return _M_off; }
|
||||
|
||||
inline size_t
|
||||
slice::size () const
|
||||
{ return _M_sz; }
|
||||
|
||||
inline size_t
|
||||
slice::stride () const
|
||||
{ return _M_st; }
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __SLICE__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
156
libstdc++/std/slice_array.h
Normal file
156
libstdc++/std/slice_array.h
Normal file
@ -0,0 +1,156 @@
|
||||
// The template and inlines for the -*- C++ -*- slice_array class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
#ifndef __SLICE_ARRAY__
|
||||
#define __SLICE_ARRAY__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template<typename _T>
|
||||
class slice_array
|
||||
{
|
||||
public:
|
||||
typedef _T value_type;
|
||||
|
||||
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;
|
||||
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 _T &);
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>= (const _Expr<_Dom,_T>&) const;
|
||||
|
||||
private:
|
||||
friend class valarray<_T>;
|
||||
slice_array(_Array<_T>, const slice&);
|
||||
|
||||
const size_t _M_sz;
|
||||
const size_t _M_stride;
|
||||
const _Array<_T> _M_array;
|
||||
|
||||
// this constructor is implemented since we need to return a value.
|
||||
slice_array (const slice_array&);
|
||||
|
||||
// not implemented
|
||||
slice_array ();
|
||||
slice_array& operator= (const slice_array&);
|
||||
};
|
||||
|
||||
template<typename _T>
|
||||
inline slice_array<_T>::slice_array (_Array<_T> __a, const slice& __s)
|
||||
: _M_sz (__s.size ()), _M_stride (__s.stride ()),
|
||||
_M_array (__a.begin () + __s.start ()) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline slice_array<_Tp>::slice_array(const slice_array<_Tp>& a)
|
||||
: _M_sz(a._M_sz), _M_stride(a._M_stride), _M_array(a._M_array) {}
|
||||
|
||||
template<typename _T>
|
||||
inline void
|
||||
slice_array<_T>::operator= (const _T& __t)
|
||||
{ __valarray_fill (_M_array, _M_sz, _M_stride, __t); }
|
||||
|
||||
template<typename _T>
|
||||
inline void
|
||||
slice_array<_T>::operator= (const valarray<_T>& __v) const
|
||||
{ __valarray_copy (_Array<_T> (__v), _M_array, _M_sz, _M_stride); }
|
||||
|
||||
template<typename _T>
|
||||
template<class _Dom>
|
||||
inline void
|
||||
slice_array<_T>::operator= (const _Expr<_Dom,_T>& __e) const
|
||||
{ __valarray_copy (__e, _M_sz, _M_array, _M_stride); }
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _T> \
|
||||
inline void \
|
||||
slice_array<_T>::operator##op##= (const valarray<_T>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_sz, _M_stride, _Array<_T> (__v));\
|
||||
} \
|
||||
\
|
||||
template<typename _T> template<class _Dom> \
|
||||
inline void \
|
||||
slice_array<_T>::operator##op##= (const _Expr<_Dom,_T>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_stride, __e, _M_sz); \
|
||||
}
|
||||
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __SLICE_ARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
703
libstdc++/std/std_valarray.h
Normal file
703
libstdc++/std/std_valarray.h
Normal file
@ -0,0 +1,703 @@
|
||||
// The template and inlines for the -*- C++ -*- valarray class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
#ifndef __STD_VALARRAY__
|
||||
#define __STD_VALARRAY__
|
||||
#define _G_NO_VALARRAY_TEMPLATE_EXPORT 1
|
||||
|
||||
#include <cstddef>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <numeric>
|
||||
#include <functional>
|
||||
#include <algorithm>
|
||||
|
||||
#include <alloca.h> // XXX non-standard.
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template<class _Clos, typename _Tp> class _Expr;
|
||||
|
||||
template<typename _Tp1, typename _Tp2> class _ValArray;
|
||||
|
||||
template<template<class> class _Oper,
|
||||
template<class, class> class _Meta, class _Dom> struct _UnClos;
|
||||
|
||||
template<template<class> class _Oper,
|
||||
template<class, class> class _Meta1,
|
||||
template<class, class> class _Meta2,
|
||||
class _Dom1, class _Dom2> class _BinClos;
|
||||
|
||||
template<template<class, class> class _Meta, class _Dom> class _SClos;
|
||||
|
||||
template<template<class, class> class _Meta, class _Dom> class _GClos;
|
||||
|
||||
template<template<class, class> class _Meta, class _Dom> class _IClos;
|
||||
|
||||
template<template<class, class> class _Meta, class _Dom> class _ValFunClos;
|
||||
|
||||
template<template<class, class> class _Meta, class _Dom> class _RefFunClos;
|
||||
|
||||
template<class _Tp> struct _Unary_plus;
|
||||
template<class _Tp> struct _Bitwise_and;
|
||||
template<class _Tp> struct _Bitwise_or;
|
||||
template<class _Tp> struct _Bitwise_xor;
|
||||
template<class _Tp> struct _Bitwise_not;
|
||||
template<class _Tp> struct _Shift_left;
|
||||
template<class _Tp> struct _Shift_right;
|
||||
|
||||
template<class _Tp> class valarray; // An array of type _Tp
|
||||
class slice; // BLAS-like slice out of an array
|
||||
template<class _Tp> class slice_array;
|
||||
class gslice; // generalized slice out of an array
|
||||
template<class _Tp> class gslice_array;
|
||||
template<class _Tp> class mask_array; // masked array
|
||||
template<class _Tp> class indirect_array; // indirected array
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#include <std/valarray_array.h>
|
||||
#include <std/valarray_meta.h>
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template<class _Tp> class valarray
|
||||
{
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
|
||||
// _lib.valarray.cons_ construct/destroy:
|
||||
valarray();
|
||||
explicit valarray(size_t);
|
||||
valarray(const _Tp&, size_t);
|
||||
valarray(const _Tp* __restrict__, size_t);
|
||||
valarray(const valarray&);
|
||||
valarray(const slice_array<_Tp>&);
|
||||
valarray(const gslice_array<_Tp>&);
|
||||
valarray(const mask_array<_Tp>&);
|
||||
valarray(const indirect_array<_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray(const _Expr<_Dom,_Tp>& __e);
|
||||
~valarray();
|
||||
|
||||
// _lib.valarray.assign_ assignment:
|
||||
valarray<_Tp>& operator=(const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator=(const _Tp&);
|
||||
valarray<_Tp>& operator=(const slice_array<_Tp>&);
|
||||
valarray<_Tp>& operator=(const gslice_array<_Tp>&);
|
||||
valarray<_Tp>& operator=(const mask_array<_Tp>&);
|
||||
valarray<_Tp>& operator=(const indirect_array<_Tp>&);
|
||||
|
||||
template<class _Dom> valarray<_Tp>&
|
||||
operator= (const _Expr<_Dom,_Tp>&);
|
||||
|
||||
// _lib.valarray.access_ element access:
|
||||
_Tp operator[](size_t) const;
|
||||
_Tp& operator[](size_t);
|
||||
// _lib.valarray.sub_ subset operations:
|
||||
_Expr<_SClos<_ValArray,_Tp>, _Tp> operator[](slice) const;
|
||||
slice_array<_Tp> operator[](slice);
|
||||
_Expr<_GClos<_ValArray,_Tp>, _Tp> operator[](const gslice&) const;
|
||||
gslice_array<_Tp> operator[](const gslice&);
|
||||
valarray<_Tp> operator[](const valarray<bool>&) const;
|
||||
mask_array<_Tp> operator[](const valarray<bool>&);
|
||||
_Expr<_IClos<_ValArray, _Tp>, _Tp>
|
||||
operator[](const valarray<size_t>&) const;
|
||||
indirect_array<_Tp> operator[](const valarray<size_t>&);
|
||||
|
||||
// _lib.valarray.unary_ unary operators:
|
||||
_Expr<_UnClos<_Unary_plus,_ValArray,_Tp>,_Tp> operator+ () const;
|
||||
_Expr<_UnClos<negate,_ValArray,_Tp>,_Tp> operator- () const;
|
||||
_Expr<_UnClos<_Bitwise_not,_ValArray,_Tp>,_Tp> operator~ () const;
|
||||
_Expr<_UnClos<logical_not,_ValArray,_Tp>,bool> operator! () const;
|
||||
|
||||
// _lib.valarray.cassign_ computed assignment:
|
||||
valarray<_Tp>& operator*= (const _Tp&);
|
||||
valarray<_Tp>& operator/= (const _Tp&);
|
||||
valarray<_Tp>& operator%= (const _Tp&);
|
||||
valarray<_Tp>& operator+= (const _Tp&);
|
||||
valarray<_Tp>& operator-= (const _Tp&);
|
||||
valarray<_Tp>& operator^= (const _Tp&);
|
||||
valarray<_Tp>& operator&= (const _Tp&);
|
||||
valarray<_Tp>& operator|= (const _Tp&);
|
||||
valarray<_Tp>& operator<<=(const _Tp&);
|
||||
valarray<_Tp>& operator>>=(const _Tp&);
|
||||
valarray<_Tp>& operator*= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator/= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator%= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator+= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator-= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator^= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator|= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator&= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator<<=(const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator>>=(const valarray<_Tp>&);
|
||||
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator*= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator/= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator%= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator+= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator-= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator^= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator|= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator&= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator>>=(const _Expr<_Dom,_Tp>&);
|
||||
|
||||
|
||||
// _lib.valarray.members_ member functions:
|
||||
size_t size() const;
|
||||
_Tp sum() const;
|
||||
_Tp min() const;
|
||||
_Tp max() const;
|
||||
|
||||
// FIXME: Extension
|
||||
_Tp product () const;
|
||||
|
||||
valarray<_Tp> shift (int) const;
|
||||
valarray<_Tp> cshift(int) const;
|
||||
_Expr<_ValFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(_Tp)) const;
|
||||
_Expr<_RefFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(const _Tp&)) const;
|
||||
void resize(size_t __size, _Tp __c = _Tp());
|
||||
|
||||
private:
|
||||
size_t _M_size;
|
||||
_Tp* __restrict__ _M_data;
|
||||
|
||||
friend class _Array<_Tp>;
|
||||
};
|
||||
|
||||
|
||||
template<typename _Tp> struct _Unary_plus : unary_function<_Tp,_Tp> {
|
||||
_Tp operator() (const _Tp& __t) const { return __t; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Bitwise_and : binary_function<_Tp,_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __x, _Tp __y) const { return __x & __y; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Bitwise_or : binary_function<_Tp,_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __x, _Tp __y) const { return __x | __y; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Bitwise_xor : binary_function<_Tp,_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __x, _Tp __y) const { return __x ^ __y; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Bitwise_not : unary_function<_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __t) const { return ~__t; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Shift_left : unary_function<_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __x, _Tp __y) const { return __x << __y; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Shift_right : unary_function<_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __x, _Tp __y) const { return __x >> __y; }
|
||||
};
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
valarray<_Tp>::operator[] (size_t __i) const
|
||||
{ return _M_data[__i]; }
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp&
|
||||
valarray<_Tp>::operator[] (size_t __i)
|
||||
{ return _M_data[__i]; }
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#include <std/slice.h>
|
||||
#include <std/slice_array.h>
|
||||
#include <std/gslice.h>
|
||||
#include <std/gslice_array.h>
|
||||
#include <std/mask_array.h>
|
||||
#include <std/indirect_array.h>
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray () : _M_size (0), _M_data (0) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (size_t __n)
|
||||
: _M_size (__n), _M_data (new _Tp[__n]) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const _Tp& __t, size_t __n)
|
||||
: _M_size (__n), _M_data (new _Tp[__n])
|
||||
{ __valarray_fill (_M_data, _M_size, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const _Tp* __restrict__ __pT, size_t __n)
|
||||
: _M_size (__n), _M_data (new _Tp[__n])
|
||||
{ __valarray_copy (__pT, __n, _M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const valarray<_Tp>& __v)
|
||||
: _M_size (__v._M_size), _M_data (new _Tp[__v._M_size])
|
||||
{ __valarray_copy (__v._M_data, _M_size, _M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const slice_array<_Tp>& __sa)
|
||||
: _M_size (__sa._M_sz), _M_data (new _Tp[__sa._M_sz])
|
||||
{ __valarray_copy (__sa._M_array, __sa._M_sz, __sa._M_stride,
|
||||
_Array<_Tp>(_M_data)); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const gslice_array<_Tp>& __ga)
|
||||
: _M_size (__ga._M_index.size()), _M_data (new _Tp[_M_size])
|
||||
{ __valarray_copy (__ga._M_array, _Array<size_t>(__ga._M_index),
|
||||
_Array<_Tp>(_M_data), _M_size); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const mask_array<_Tp>& __ma)
|
||||
: _M_size (__ma._M_sz), _M_data (new _Tp[__ma._M_sz])
|
||||
{ __valarray_copy (__ma._M_array, __ma._M_mask,
|
||||
_Array<_Tp>(_M_data), _M_size); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const indirect_array<_Tp>& __ia)
|
||||
: _M_size (__ia._M_sz), _M_data (new _Tp[__ia._M_sz])
|
||||
{ __valarray_copy (__ia._M_array, __ia._M_index,
|
||||
_Array<_Tp>(_M_data), _M_size); }
|
||||
|
||||
template<typename _Tp> template<class _Dom>
|
||||
inline valarray<_Tp>::valarray (const _Expr<_Dom, _Tp>& __e)
|
||||
: _M_size (__e.size ()), _M_data (new _Tp[_M_size])
|
||||
{ __valarray_copy (__e, _M_size, _Array<_Tp>(_M_data)); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::~valarray () { delete[] _M_data; }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const valarray<_Tp>& __v)
|
||||
{
|
||||
__valarray_copy(__v._M_data, _M_size, _M_data);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const _Tp& __t)
|
||||
{
|
||||
__valarray_fill (_M_data, _M_size, __t);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const slice_array<_Tp>& __sa)
|
||||
{
|
||||
__valarray_copy (__sa._M_array, __sa._M_sz,
|
||||
__sa._M_stride, _Array<_Tp>(_M_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const gslice_array<_Tp>& __ga)
|
||||
{
|
||||
__valarray_copy (__ga._M_array, _Array<size_t>(__ga._M_index),
|
||||
_Array<_Tp>(_M_data), _M_size);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const mask_array<_Tp>& __ma)
|
||||
{
|
||||
__valarray_copy (__ma._M_array, __ma._M_mask,
|
||||
_Array<_Tp>(_M_data), _M_size);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const indirect_array<_Tp>& __ia)
|
||||
{
|
||||
__valarray_copy (__ia._M_array, __ia._M_index,
|
||||
_Array<_Tp>(_M_data), _M_size);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp> template<class _Dom>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const _Expr<_Dom, _Tp>& __e)
|
||||
{
|
||||
__valarray_copy (__e, _M_size, _Array<_Tp>(_M_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Expr<_SClos<_ValArray,_Tp>, _Tp>
|
||||
valarray<_Tp>::operator[] (slice __s) const
|
||||
{
|
||||
typedef _SClos<_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure, _Tp> (_Closure (_Array<_Tp>(_M_data), __s));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline slice_array<_Tp>
|
||||
valarray<_Tp>::operator[] (slice __s)
|
||||
{
|
||||
return slice_array<_Tp> (_Array<_Tp>(_M_data), __s);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Expr<_GClos<_ValArray,_Tp>, _Tp>
|
||||
valarray<_Tp>::operator[] (const gslice& __gs) const
|
||||
{
|
||||
typedef _GClos<_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure, _Tp>
|
||||
(_Closure (_Array<_Tp>(_M_data), __gs._M_index->_M_index));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline gslice_array<_Tp>
|
||||
valarray<_Tp>::operator[] (const gslice& __gs)
|
||||
{
|
||||
return gslice_array<_Tp>
|
||||
(_Array<_Tp>(_M_data), __gs._M_index->_M_index);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>
|
||||
valarray<_Tp>::operator[] (const valarray<bool>& __m) const
|
||||
{
|
||||
size_t __s (0);
|
||||
size_t __e (__m.size ());
|
||||
for (size_t __i=0; __i<__e; ++__i)
|
||||
if (__m[__i]) ++__s;
|
||||
return valarray<_Tp> (mask_array<_Tp> (_Array<_Tp>(_M_data), __s,
|
||||
_Array<bool> (__m)));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline mask_array<_Tp>
|
||||
valarray<_Tp>::operator[] (const valarray<bool>& __m)
|
||||
{
|
||||
size_t __s (0);
|
||||
size_t __e (__m.size ());
|
||||
for (size_t __i=0; __i<__e; ++__i)
|
||||
if (__m[__i]) ++__s;
|
||||
return mask_array<_Tp> (_Array<_Tp>(_M_data), __s, _Array<bool> (__m));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Expr<_IClos<_ValArray,_Tp>, _Tp>
|
||||
valarray<_Tp>::operator[] (const valarray<size_t>& __i) const
|
||||
{
|
||||
typedef _IClos<_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure, _Tp> (_Closure (*this, __i));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline indirect_array<_Tp>
|
||||
valarray<_Tp>::operator[] (const valarray<size_t>& __i)
|
||||
{
|
||||
return indirect_array<_Tp> (_Array<_Tp>(_M_data), __i.size(),
|
||||
_Array<size_t> (__i));
|
||||
}
|
||||
|
||||
template<class _Tp>
|
||||
inline size_t valarray<_Tp>::size () const { return _M_size; }
|
||||
|
||||
template<class _Tp>
|
||||
inline _Tp
|
||||
valarray<_Tp>::sum () const
|
||||
{
|
||||
return accumulate (_M_data, _M_data + _M_size, _Tp ());
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
valarray<_Tp>::product () const
|
||||
{
|
||||
return accumulate (_M_data, _M_data+_M_size, _Tp(1), multiplies<_Tp> ());
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline valarray<_Tp>
|
||||
valarray<_Tp>::shift (int __n) const
|
||||
{
|
||||
_Tp* const __a = static_cast<_Tp*> (alloca (sizeof(_Tp) * _M_size));
|
||||
if (! __n) // __n == 0: no shift
|
||||
__valarray_copy (_M_data, _M_size, __a);
|
||||
else if (__n > 0) { // __n > 0: shift left
|
||||
if (__n > _M_size)
|
||||
__valarray_fill(__a, __n, _Tp());
|
||||
else {
|
||||
__valarray_copy (_M_data+__n, _M_size-__n, __a);
|
||||
__valarray_fill (__a+_M_size-__n, __n, _Tp());
|
||||
}
|
||||
}
|
||||
else { // __n < 0: shift right
|
||||
__valarray_copy (_M_data, _M_size+__n, __a-__n);
|
||||
__valarray_fill(__a, -__n, _Tp());
|
||||
}
|
||||
return valarray<_Tp> (__a, _M_size);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline valarray<_Tp>
|
||||
valarray<_Tp>::cshift (int __n) const
|
||||
{
|
||||
_Tp* const __a = static_cast<_Tp*> (alloca (sizeof(_Tp) * _M_size));
|
||||
if (! __n) // __n == 0: no cshift
|
||||
__valarray_copy(_M_data, _M_size, __a);
|
||||
else if (__n > 0) { // __n > 0: cshift left
|
||||
__valarray_copy (_M_data, __n, __a + _M_size-__n);
|
||||
__valarray_copy (_M_data + __n, _M_size-__n, __a);
|
||||
}
|
||||
else { // __n < 0: cshift right
|
||||
__valarray_copy (_M_data + _M_size + __n, -__n, __a);
|
||||
__valarray_copy (_M_data, _M_size + __n, __a - __n);
|
||||
}
|
||||
return valarray<_Tp> (__a, _M_size);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline void
|
||||
valarray<_Tp>::resize (size_t __n, _Tp __c)
|
||||
{
|
||||
if (_M_size != __n) {
|
||||
delete[] _M_data;
|
||||
_M_size = __n;
|
||||
_M_data = new _Tp[_M_size];
|
||||
}
|
||||
__valarray_fill (_M_data, _M_size, __c);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
valarray<_Tp>::min() const
|
||||
{
|
||||
return *min_element (_M_data, _M_data+_M_size);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
valarray<_Tp>::max() const
|
||||
{
|
||||
return *max_element (_M_data, _M_data+_M_size);
|
||||
}
|
||||
|
||||
template<class _Tp>
|
||||
inline _Expr<_ValFunClos<_ValArray,_Tp>,_Tp>
|
||||
valarray<_Tp>::apply (_Tp func (_Tp)) const
|
||||
{
|
||||
typedef _ValFunClos<_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure,_Tp> (_Closure (*this, func));
|
||||
}
|
||||
|
||||
template<class _Tp>
|
||||
inline _Expr<_RefFunClos<_ValArray,_Tp>,_Tp>
|
||||
valarray<_Tp>::apply (_Tp func (const _Tp &)) const
|
||||
{
|
||||
typedef _RefFunClos<_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure,_Tp> (_Closure (*this, func));
|
||||
}
|
||||
|
||||
#define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \
|
||||
template<typename _Tp> \
|
||||
inline _Expr<_UnClos<_Name,_ValArray,_Tp>, _Tp> \
|
||||
valarray<_Tp>::operator##_Op() const \
|
||||
{ \
|
||||
typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \
|
||||
return _Expr<_Closure, _Tp> (_Closure (*this)); \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_UNARY_OPERATOR(+, _Unary_plus)
|
||||
_DEFINE_VALARRAY_UNARY_OPERATOR(-, negate)
|
||||
_DEFINE_VALARRAY_UNARY_OPERATOR(~, _Bitwise_not)
|
||||
|
||||
#undef _DEFINE_VALARRAY_UNARY_OPERATOR
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Expr<_UnClos<logical_not,_ValArray,_Tp>, bool>
|
||||
valarray<_Tp>::operator!() const
|
||||
{
|
||||
typedef _UnClos<logical_not,_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure, bool> (_Closure (*this));
|
||||
}
|
||||
|
||||
#define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \
|
||||
template<class _Tp> \
|
||||
inline valarray<_Tp> & \
|
||||
valarray<_Tp>::operator##_Op##= (const _Tp &__t) \
|
||||
{ \
|
||||
_Array_augmented_##_Name (_Array<_Tp>(_M_data), _M_size, __t); \
|
||||
return *this; \
|
||||
} \
|
||||
\
|
||||
template<class _Tp> \
|
||||
inline valarray<_Tp> & \
|
||||
valarray<_Tp>::operator##_Op##= (const valarray<_Tp> &__v) \
|
||||
{ \
|
||||
_Array_augmented_##_Name (_Array<_Tp>(_M_data), _M_size, \
|
||||
_Array<_Tp>(__v._M_data)); \
|
||||
return *this; \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, plus)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, minus)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, multiplies)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, divides)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, modulus)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, xor)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, and)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, or)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, shift_left)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT
|
||||
|
||||
|
||||
#define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \
|
||||
template<class _Tp> template<class _Dom> \
|
||||
inline valarray<_Tp> & \
|
||||
valarray<_Tp>::operator##_Op##= (const _Expr<_Dom,_Tp> &__e) \
|
||||
{ \
|
||||
_Array_augmented_##_Name (_Array<_Tp>(_M_data), __e, _M_size); \
|
||||
return *this; \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, plus)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, minus)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, multiplies)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, divides)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, modulus)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, xor)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, and)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, or)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, shift_left)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT
|
||||
|
||||
|
||||
#define _DEFINE_BINARY_OPERATOR(_Op, _Name) \
|
||||
template<typename _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>, _Tp> \
|
||||
operator##_Op (const valarray<_Tp> &__v, const valarray<_Tp> &__w) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, _Tp> (_Closure (__v, __w)); \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>,_Tp> \
|
||||
operator##_Op (const valarray<_Tp> &__v, const _Tp &__t) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, _Tp> (_Closure (__v, __t)); \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>,_Tp> \
|
||||
operator##_Op (const _Tp &__t, const valarray<_Tp> &__v) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, _Tp> (_Closure (__t, __v)); \
|
||||
}
|
||||
|
||||
_DEFINE_BINARY_OPERATOR(+, plus)
|
||||
_DEFINE_BINARY_OPERATOR(-, minus)
|
||||
_DEFINE_BINARY_OPERATOR(*, multiplies)
|
||||
_DEFINE_BINARY_OPERATOR(/, divides)
|
||||
_DEFINE_BINARY_OPERATOR(%, modulus)
|
||||
_DEFINE_BINARY_OPERATOR(^, _Bitwise_xor)
|
||||
_DEFINE_BINARY_OPERATOR(&, _Bitwise_and)
|
||||
_DEFINE_BINARY_OPERATOR(|, _Bitwise_or)
|
||||
_DEFINE_BINARY_OPERATOR(<<, _Shift_left)
|
||||
_DEFINE_BINARY_OPERATOR(>>, _Shift_right)
|
||||
|
||||
#undef _DEFINE_BINARY_OPERATOR
|
||||
|
||||
#define _DEFINE_LOGICAL_OPERATOR(_Op, _Name) \
|
||||
template<typename _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>,bool> \
|
||||
operator##_Op (const valarray<_Tp> &__v, const valarray<_Tp> &__w) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, bool> (_Closure (__v, __w)); \
|
||||
} \
|
||||
\
|
||||
template<class _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>,bool> \
|
||||
operator##_Op (const valarray<_Tp> &__v, const _Tp &__t) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, bool> (_Closure (__v, __t)); \
|
||||
} \
|
||||
\
|
||||
template<class _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>,bool> \
|
||||
operator##_Op (const _Tp &__t, const valarray<_Tp> &__v) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, bool> (_Closure (__t, __v)); \
|
||||
}
|
||||
|
||||
_DEFINE_LOGICAL_OPERATOR(&&, logical_and)
|
||||
_DEFINE_LOGICAL_OPERATOR(||, logical_or)
|
||||
_DEFINE_LOGICAL_OPERATOR(==, equal_to)
|
||||
_DEFINE_LOGICAL_OPERATOR(!=, not_equal_to)
|
||||
_DEFINE_LOGICAL_OPERATOR(<, less)
|
||||
_DEFINE_LOGICAL_OPERATOR(>, greater)
|
||||
_DEFINE_LOGICAL_OPERATOR(<=, less_equal)
|
||||
_DEFINE_LOGICAL_OPERATOR(>=, greater_equal)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
#undef _G_NO_VALARRAY_TEMPLATE_EXPORT
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __STD_VALARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
346
libstdc++/std/valarray_array.h
Normal file
346
libstdc++/std/valarray_array.h
Normal file
@ -0,0 +1,346 @@
|
||||
// The template and inlines for the -*- C++ -*- internal _Array helper class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
#ifndef __VALARRAY_ARRAY__
|
||||
#define __VALARRAY_ARRAY__
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
|
||||
extern "C++" {
|
||||
|
||||
//
|
||||
// Helper functions on raw pointers
|
||||
//
|
||||
|
||||
// fill plain array __a[<__n>] with __t
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Tp* __restrict__ __a, size_t __n, const _Tp& __t)
|
||||
{ while (__n--) *__a++ = __t; }
|
||||
|
||||
// fill strided array __a[<__n-1 : __s>] with __t
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Tp* __restrict__ __a, size_t __n,
|
||||
size_t __s, const _Tp& __t)
|
||||
{ for (size_t __i=0; __i<__n; ++__i, __a+=__s) *__a = __t; }
|
||||
|
||||
// fill indirect array __a[__i[<__n>]] with __i
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i,
|
||||
size_t __n, const _Tp& __t)
|
||||
{ for (size_t __j=0; __j<__n; ++__j, ++__i) __a[*__i] = __t; }
|
||||
|
||||
// copy plain array __a[<__n>] in __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a, size_t __n,
|
||||
_Tp* __restrict__ __b)
|
||||
{ memcpy (__b, __a, __n * sizeof(_Tp)); }
|
||||
|
||||
// copy strided array __a[<__n : __s>] in plain __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a, size_t __n, size_t __s,
|
||||
_Tp* __restrict__ __b)
|
||||
{ for (size_t __i=0; __i<__n; ++__i, ++__b, __a += __s) *__b += *__a; }
|
||||
|
||||
// copy plain __a[<__n>] in strided __b[<__n : __s>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a, _Tp* __restrict__ __b,
|
||||
size_t __n, size_t __s)
|
||||
{ for (size_t __i=0; __i<__n; ++__i, ++__a, __b+=__s) *__b = *__a; }
|
||||
|
||||
// copy indexed __a[__i[<__n>]] in plain __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a,
|
||||
const size_t* __restrict__ __i,
|
||||
_Tp* __restrict__ __b, size_t __n)
|
||||
{ for (size_t __j=0; __j<__n; ++__j, ++__b, ++__i) *__b = __a[*__i]; }
|
||||
|
||||
// copy plain __a[<__n>] in indexed __b[__i[<__n>]]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a, size_t __n,
|
||||
_Tp* __restrict__ __b, const size_t* __restrict__ __i)
|
||||
{ for (size_t __j=0; __j<__n; ++__j, ++__a, ++__i) __b[*__i] = *__a; }
|
||||
|
||||
//
|
||||
// Helper class _Array, first layer of valarray abstraction.
|
||||
// All operations on valarray should be forwarded to this class
|
||||
// whenever possible. -- gdr
|
||||
//
|
||||
|
||||
template<typename _Tp> struct _Array {
|
||||
|
||||
explicit _Array (size_t);
|
||||
explicit _Array (_Tp* const __restrict__);
|
||||
explicit _Array (const valarray<_Tp>&);
|
||||
_Array (const _Tp* __restrict__, size_t);
|
||||
|
||||
void free_data() const;
|
||||
_Tp* begin () const;
|
||||
|
||||
_Tp* const __restrict__ _M_data;
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
|
||||
{ __valarray_fill (__a._M_data, __n, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t)
|
||||
{ __valarray_fill (__a._M_data, __n, __s, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Array<_Tp> __a, _Array<size_t> __i,
|
||||
size_t __n, const _Tp& __t)
|
||||
{ __valarray_fill (__a._M_data, __i._M_data, __n, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
|
||||
{ __valarray_copy (__a._M_data, __n, __b._M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
|
||||
{ __valarray_copy(__a._M_data, __n, __s, __b._M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s)
|
||||
{ __valarray_copy (__a._M_data, __b._M_data, __n, __s); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (_Array<_Tp> __a, _Array<size_t> __i,
|
||||
_Array<_Tp> __b, size_t __n)
|
||||
{ __valarray_copy (__a._M_data, __i._M_data, __b._M_data, __n); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
|
||||
_Array<size_t> __i)
|
||||
{ __valarray_copy (__a._M_data, __n, __b._M_data, __i._M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
_Array<_Tp>::_Array (size_t __n) : _M_data (new _Tp[__n]) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
_Array<_Tp>::_Array (_Tp* const __restrict__ __p) : _M_data (__p) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Array<_Tp>::_Array (const valarray<_Tp>& __v)
|
||||
: _M_data (__v._M_data) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
_Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s)
|
||||
: _M_data (new _Tp[__s]) { __valarray_copy (__b, __s, _M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
_Array<_Tp>::free_data() const { delete[] _M_data; }
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp*
|
||||
_Array<_Tp>::begin () const
|
||||
{ return _M_data; }
|
||||
|
||||
#define _DEFINE_ARRAY_FUNCTION(_Op, _Name) \
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, const _Tp& __t) \
|
||||
{ \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p) \
|
||||
*__p _Op##= __t; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) \
|
||||
{ \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__p, ++__q) \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, \
|
||||
const _Expr<_Dom,_Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t __i=0; __i<__n; ++__i, ++__p) *__p _Op##= __e[__i]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, size_t __s, \
|
||||
_Array<_Tp> __b) \
|
||||
{ \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__s*__n; __p+=__s, ++__q) \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<_Tp> __b, \
|
||||
size_t __n, size_t __s) \
|
||||
{ \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, __q+=__s) \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __s, \
|
||||
const _Expr<_Dom,_Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t __i=0; __i<__n; ++__i, __p+=__s) *__p _Op##= __e[__i]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<size_t> __i, \
|
||||
_Array<_Tp> __b, size_t __n) \
|
||||
{ \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__q) \
|
||||
__a._M_data[*__j] _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \
|
||||
_Array<_Tp> __b, _Array<size_t> __i) \
|
||||
{ \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__p) \
|
||||
*__p _Op##= __b._M_data[*__j]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<size_t> __i, \
|
||||
const _Expr<_Dom, _Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
size_t* __j (__i._M_data); \
|
||||
for (size_t __k=0; __k<__n; ++__k, ++__j) \
|
||||
__a._M_data[*__j] _Op##= __e[__k]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __m, \
|
||||
_Array<_Tp> __b, size_t __n) \
|
||||
{ \
|
||||
bool* ok (__m._M_data); \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__q, ++ok, ++__p) { \
|
||||
while (! *ok) { \
|
||||
++ok; \
|
||||
++__p; \
|
||||
} \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \
|
||||
_Array<_Tp> __b, _Array<bool> __m) \
|
||||
{ \
|
||||
bool* ok (__m._M_data); \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, ++ok, ++__q) { \
|
||||
while (! *ok) { \
|
||||
++ok; \
|
||||
++__q; \
|
||||
} \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __m, \
|
||||
const _Expr<_Dom, _Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
bool* ok(__m._M_data); \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t __i=0; __i<__n; ++__i, ++ok, ++__p) { \
|
||||
while (! *ok) { \
|
||||
++ok; \
|
||||
++__p; \
|
||||
} \
|
||||
*__p _Op##= __e[__i]; \
|
||||
} \
|
||||
}
|
||||
|
||||
_DEFINE_ARRAY_FUNCTION(+, plus)
|
||||
_DEFINE_ARRAY_FUNCTION(-, minus)
|
||||
_DEFINE_ARRAY_FUNCTION(*, multiplies)
|
||||
_DEFINE_ARRAY_FUNCTION(/, divides)
|
||||
_DEFINE_ARRAY_FUNCTION(%, modulus)
|
||||
_DEFINE_ARRAY_FUNCTION(^, xor)
|
||||
_DEFINE_ARRAY_FUNCTION(|, or)
|
||||
_DEFINE_ARRAY_FUNCTION(&, and)
|
||||
_DEFINE_ARRAY_FUNCTION(<<, shift_left)
|
||||
_DEFINE_ARRAY_FUNCTION(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_ARRAY_FUNCTION
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#ifdef _G_NO_VALARRAY_TEMPLATE_EXPORT
|
||||
# define export
|
||||
# include <std/valarray_array.tcc>
|
||||
#endif
|
||||
|
||||
#endif // __VALARRAY_ARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
130
libstdc++/std/valarray_array.tcc
Normal file
130
libstdc++/std/valarray_array.tcc
Normal file
@ -0,0 +1,130 @@
|
||||
// The template and inlines for the -*- C++ -*- internal _Array helper class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, 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 General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
|
||||
|
||||
#ifndef __VALARRAY_ARRAY_TCC__
|
||||
#define __VALARRAY_ARRAY_TCC__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
export template<typename _Tp>
|
||||
void
|
||||
__valarray_fill (_Array<_Tp> __a, size_t __n, _Array<bool> __m, const _Tp& __t)
|
||||
{
|
||||
_Tp* __p = __a._M_data;
|
||||
bool* __ok (__m._M_data);
|
||||
for (size_t __i=0; __i<__n; ++__i, ++__ok, ++__p) {
|
||||
while (! *__ok) {
|
||||
++__ok;
|
||||
++__p;
|
||||
}
|
||||
*__p = __t;
|
||||
}
|
||||
}
|
||||
|
||||
export template<typename _Tp>
|
||||
void
|
||||
__valarray_copy (_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n)
|
||||
{
|
||||
_Tp* __p (__a._M_data);
|
||||
bool* __ok (__m._M_data);
|
||||
for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__q, ++__ok, ++__p) {
|
||||
while (! *__ok) {
|
||||
++__ok;
|
||||
++__p;
|
||||
}
|
||||
*__q = *__p;
|
||||
}
|
||||
}
|
||||
|
||||
export template<typename _Tp>
|
||||
void
|
||||
__valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m)
|
||||
{
|
||||
_Tp* __q (__b._M_data);
|
||||
bool* __ok (__m._M_data);
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, ++__ok, ++__q) {
|
||||
while (! *__ok) {
|
||||
++__ok;
|
||||
++__q;
|
||||
}
|
||||
*__q = *__p;
|
||||
}
|
||||
}
|
||||
|
||||
export template<typename _Tp, class _Dom>
|
||||
void
|
||||
__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a)
|
||||
{
|
||||
_Tp* __p (__a._M_data);
|
||||
for (size_t __i=0; __i<__n; ++__i, ++__p) *__p = __e[__i];
|
||||
}
|
||||
|
||||
export template<typename _Tp, class _Dom>
|
||||
void
|
||||
__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n,
|
||||
_Array<_Tp> __a, size_t __s)
|
||||
{
|
||||
_Tp* __p (__a._M_data);
|
||||
for (size_t __i=0; __i<__n; ++__i, __p+=__s) *__p = __e[__i];
|
||||
}
|
||||
|
||||
export template<typename _Tp, class _Dom>
|
||||
void
|
||||
__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n,
|
||||
_Array<_Tp> __a, _Array<size_t> __i)
|
||||
{
|
||||
size_t* __j (__i._M_data);
|
||||
for (size_t __k=0; __k<__n; ++__k, ++__j) __a._M_data[*__j] = __e[__k];
|
||||
}
|
||||
|
||||
export template<typename _Tp, class _Dom>
|
||||
void
|
||||
__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n,
|
||||
_Array<_Tp> __a, _Array<bool> __m)
|
||||
{
|
||||
bool* __ok (__m._M_data);
|
||||
_Tp* __p (__a._M_data);
|
||||
for (size_t __i=0; __i<__n; ++__i, ++__ok, ++__p) {
|
||||
while (! *__ok) {
|
||||
++__ok;
|
||||
++__p;
|
||||
}
|
||||
*__p = __e[__i];
|
||||
}
|
||||
}
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __VALARRAY_ARRAY_TCC__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
1045
libstdc++/std/valarray_meta.h
Normal file
1045
libstdc++/std/valarray_meta.h
Normal file
File diff suppressed because it is too large
Load Diff
8
libstdc++/valarray
Normal file
8
libstdc++/valarray
Normal file
@ -0,0 +1,8 @@
|
||||
// Main header for -*- C++ -*- valarray classes.
|
||||
|
||||
#ifndef __VALARRAY__
|
||||
#define __VALARRAY__
|
||||
|
||||
#include <std/std_valarray.h>
|
||||
|
||||
#endif
|
||||
50
libstdc++/valarray.cc
Normal file
50
libstdc++/valarray.cc
Normal file
@ -0,0 +1,50 @@
|
||||
#include <std/std_valarray.h>
|
||||
|
||||
// Some Explicit Instanciations.
|
||||
template class multiplies<size_t>;
|
||||
template size_t accumulate(size_t*, size_t*, size_t, multiplies<size_t>);
|
||||
|
||||
template void
|
||||
__valarray_fill(size_t* __restrict__, size_t, const size_t&);
|
||||
|
||||
template void
|
||||
__valarray_copy(const size_t* __restrict__, size_t, size_t* __restrict__);
|
||||
|
||||
template valarray<size_t>::valarray(size_t);
|
||||
template valarray<size_t>::~valarray();
|
||||
template valarray<size_t>::valarray(const valarray<size_t>&);
|
||||
template size_t valarray<size_t>::size() const;
|
||||
template size_t& valarray<size_t>::operator[](size_t);
|
||||
template size_t valarray<size_t>::product() const;
|
||||
|
||||
|
||||
void __gslice_to_index(size_t __o, const valarray<size_t>& __l,
|
||||
const valarray<size_t>& __s,
|
||||
valarray<size_t>& __i)
|
||||
{
|
||||
const size_t __n = __l.size();
|
||||
size_t* const __t = static_cast<size_t*>(alloca(__n*sizeof(size_t)));
|
||||
__valarray_fill(__t, __n, size_t(0));
|
||||
const size_t __z = __i.size();
|
||||
__valarray_fill(&__i[0], __z, __o);
|
||||
for (size_t __j=0; __j<__z; ++__j) {
|
||||
for (size_t __k=0; __k<__n; ++__k)
|
||||
__i[__j] += __s[__k]*__t[__k];
|
||||
++__t[__n-1];
|
||||
for (size_t __k=__n-1; __k; --__k) {
|
||||
if (__t[__k] >= __l[__k]) {
|
||||
__t[__k] = 0;
|
||||
++__t[__k-1];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
_Indexer::_Indexer(size_t __o, const valarray<size_t>& __l,
|
||||
const valarray<size_t>& __s)
|
||||
: _M_count(1), _M_start(__o), _M_size(__l), _M_stride(__s),
|
||||
_M_index(__l.size() ? __l.product() : 0)
|
||||
{ __gslice_to_index(__o, __l, __s, _M_index); }
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user