Commit 27ac1891 by Gabriel Dos Reis Committed by Gabriel Dos Reis

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
parent 5c5d086f
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 ; \
......
// 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:
// 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:
// 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:
// 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:
// 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:
// 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:
// 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:
// Main header for -*- C++ -*- valarray classes.
#ifndef __VALARRAY__
#define __VALARRAY__
#include <std/std_valarray.h>
#endif
#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); }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment