Makefile.am (std_headers): Remove cXXX from list.

2002-01-04  Benjamin  Kosnik  <bkoz@redhat.com>

	* include/Makefile.am (std_headers): Remove cXXX from list.
	(c_base_srcdir): No bits subdirectory.
	(c_base_builddir): Same.
	(c_base_headers): Adjust names, add ciso646.
	(bits_headers): Remove std_xxx.h headers.
	* include/Makefile.in: Regenerate.

	* include/ext/iterator: Adjust includes.
	* include/ext/ropeimpl.h: Same.
	* include/ext/stl_hash_fun.h: Same.
	* include/ext/algorithm: Same.

	* include/backward/bvector.h: Adjust includes.
	* include/backward/vector.h: Same.
	* include/backward/strstream: Same.
	* include/backward/streambuf.h: Same.
	* include/backward/stack.h: Same.
	* include/backward/set.h: Same.
	* include/backward/queue.h: Same.
	* include/backward/multiset.h: Same.
	* include/backward/multimap.h: Same.
	* include/backward/map.h: Same.
	* include/backward/list.h: Same.
	* include/backward/iterator.h: Same.
	* include/backward/iostream.h: Same.
	* include/backward/iomanip.h: Same.
	* include/backward/fstream.h: Same.
	* include/backward/deque.h: Same.
	* include/backward/complex.h: Same.

	* include/bits/std_algorithm.h: Move to...
	* include/std/algorithm: ...here.
	* include/bits/std_iosfwd.h, std_locale.h, std_stack.h,
	std_bitset.h, std_ios.h, std_map.h, std_stdexcept.h,
	std_complex.h, std_iostream.h, std_memory.h, std_streambuf.h,
	std_deque.h, std_istream.h, std_numeric.h, std_string.h,
	std_fstream.h, std_ostream.h, std_utility.h, std_iterator.h,
	std_queue.h, std_valarray.h, std_functional.h, std_limits.h,
	std_set.h, std_vector.h, std_iomanip.h, std_list.h, std_sstream.h:
	Same.

	* include/c_std/bits/std_cassert.h: Move to...
	* include/c_std/cassert: Here.
	* include/c_std/std_cctype.h, std_cerrno.h, std_cfloat.h,
	std_climits.h, std_clocale.h, std_cmath.h, std_csetjmp.h,
	std_csignal.h, std_cstdarg.h, std_cstddef.h, std_cstdio.h,
	std_cstdlib.h, std_cstring.h, std_ctime.h, std_cwchar.h,
	std_cwctype.h: Same.
	* include/c_std/cmath: Adjust cmath.tcc include.
	* include/c_std/cstdlib: Adjust includes.
	* include/c_std/cwchar: Same.
	* include/c_std/ctime: Same.
	* include/c_std/cstring: Same.
	* include/c_std/cstdio: Same.
	* include/c_std/bits: Remove directory.

	* include/c/bits/std_cassert.h: Move to...
	* include/c/cassert: Here.
	* include/c/std_cctype.h, std_cerrno.h, std_cfloat.h,
	std_climits.h, std_clocale.h, std_cmath.h, std_csetjmp.h,
	std_csignal.h, std_cstdarg.h, std_cstddef.h, std_cstdio.h,
	std_cstdlib.h, std_cstring.h, std_ctime.h, std_cwchar.h,
	std_cwctype.h: Same.
	* include/c/bits: Remove directory.

	* include/std/cwctype: Remove.
	* include/std/cwchar: Remove.
	* include/std/ctime: Remove.
	* include/std/cstring: Remove.
	* include/std/cstdlib: Remove.
	* include/std/cstdio: Remove.
	* include/std/cstddef: Remove.
	* include/std/cstdarg: Remove.
	* include/std/csignal: Remove.
	* include/std/csetjmp: Remove.
	* include/std/cmath: Remove.
	* include/std/clocale: Remove.
	* include/std/climits: Remove.
	* include/std/ciso646: Remove.
	* include/std/cfloat: Remove.
	* include/std/cerrno: Remove.
	* include/std/cctype: Remove.
	* include/std/cassert: Remove.

	* include/bits/fpos.h: Adjust includes, removing <bits/std_xxx.h>
	files and subsituting <.xxx>
	* include/bits/valarray_array.h: Same.
	* include/bits/stl_uninitialized.h: Same.
	* include/bits/stl_alloc.h: Same.
	* include/bits/stl_algobase.h: Same.
	* include/bits/sstream.tcc: Same.
	* include/bits/pthread_allocimpl.h: Same.
	* include/bits/ostream.tcc: Same.
	* include/bits/localefwd.h: Same.
	* include/bits/locale_facets.tcc: Same.
	* include/bits/locale_facets.h: Same.
	* include/bits/istream.tcc: Same.
	* include/bits/char_traits.h: Same.
	* include/bits/boost_concept_check.h: Same.
	* include/bits/basic_file.h: Same.
	* include/std/bitset: Same.
	* include/std/complex: Same.
	* include/std/fstream: Same.
	* include/std/functional: Same.
	* include/std/ios: Same.
	* include/std/iostream: Same.
	* include/std/ostream: Same.
	* include/std/sstream: Same.
	* include/std/streambuf: Same.
	* include/std/string: Same.
	* include/std/iterator: Same.
	* include/std/valarray: Same.

	* src/ios.cc: Adjust includes.
	* src/valarray-inst.cc: Same.
	* src/string-inst.cc: Same.
	* src/stl-inst.cc: Same.
	* src/stdexcept.cc: Same.
	* src/misc-inst.cc: Same.
	* src/localename.cc: Same.
	* src/locale-inst.cc: Same.
	* src/locale.cc: Same.
	* src/limits.cc: Same.
	* src/concept-inst.cc: Same.
	* src/complex_io.cc: Same.
	* src/codecvt.cc: Same.
	* src/bitset.cc: Same.
	* src/cmath.cc: Same.

From-SVN: r48544

1 files changed, 712 insertions, 7 deletions

diff --git a/libstdc++-v3/include/std/valarray b/libstdc++-v3/include/std/valarray
index e20b7b8..a354708 100644
--- a/libstdc++-v3/include/std/valarray
+++ b/libstdc++-v3/include/std/valarray
@@ -1,6 +1,6 @@
-// -*- C++ -*- std header.
+// The template and inlines for the -*- C++ -*- valarray class.
 
-// Copyright (C) 2001 Free Software Foundation, Inc.
+// Copyright (C) 1997-1999, 2000, 2001 Free Software Foundation, Inc.
 //
 // 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
@@ -27,11 +27,716 @@
 // invalidate any other reasons why the executable file might be covered by
 // the GNU General Public License.
 
-/** @file valarray
- *  This is a Standard C++ Library file.  You should @c #include this file
- *  in your programs, rather than any of the "st[dl]_*.h" implementation files.
+// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
+
+/** @file std_valarray.h
+ *  This is an internal header file, included by other library headers.
+ *  You should not attempt to use it directly.
  */
 
 #ifndef _CPP_VALARRAY
-#include <bits/std_valarray.h>
-#endif
+#define _CPP_VALARRAY 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <cstddef>
+#include <cmath>
+#include <cstdlib>
+#include <numeric>
+#include <functional>
+#include <algorithm>
+
+namespace std
+{
+    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
+
+} // namespace std
+
+#include <bits/valarray_array.h>
+#include <bits/valarray_meta.h>
+  
+namespace std
+{
+  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:
+      // XXX: LWG to be resolved.
+      const _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 const _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]; }
+
+} // std::
+      
+#include <bits/slice.h>
+#include <bits/slice_array.h>
+#include <bits/gslice.h>
+#include <bits/gslice_array.h>
+#include <bits/mask_array.h>
+#include <bits/indirect_array.h>
+
+namespace std
+{
+  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(__valarray_get_storage<_Tp>(__n))
+  { __valarray_default_construct(_M_data, _M_data + __n); }
+
+  template<typename _Tp>
+  inline valarray<_Tp>::valarray (const _Tp& __t, size_t __n)
+    : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
+  { __valarray_fill_construct (_M_data, _M_data + __n, __t); }
+
+  template<typename _Tp>
+  inline valarray<_Tp>::valarray (const _Tp* __restrict__ __p, size_t __n)
+    : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
+  { __valarray_copy_construct (__p, __p + __n, _M_data); }
+
+  template<typename _Tp>
+  inline valarray<_Tp>::valarray (const valarray<_Tp>& __v)
+    : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size))
+  { __valarray_copy_construct (__v._M_data, __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(__valarray_get_storage<_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(__valarray_get_storage<_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(__valarray_get_storage<_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(__valarray_get_storage<_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(__valarray_get_storage<_Tp>(_M_size))
+  { __valarray_copy (__e, _M_size, _Array<_Tp>(_M_data)); }
+
+  template<typename _Tp>
+  inline valarray<_Tp>::~valarray ()
+  {
+      __valarray_destroy_elements(_M_data, _M_data + _M_size);
+      __valarray_release_memory(_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 __valarray_sum(_M_data, _M_data + _M_size);
+  }
+
+//   template<typename _Tp>
+//   inline _Tp
+//   valarray<_Tp>::product () const
+//   {
+//       return __valarray_product(_M_data, _M_data + _M_size);
+//   }
+
+  template <class _Tp>
+     inline valarray<_Tp>
+     valarray<_Tp>::shift(int __n) const
+     {
+       _Tp* const __a = static_cast<_Tp*>
+         (__builtin_alloca(sizeof(_Tp) * _M_size));
+       if (__n == 0)                          // no shift
+         __valarray_copy_construct(_M_data, _M_data + _M_size, __a);
+       else if (__n > 0)         // __n > 0: shift left
+         {                 
+           if (size_t(__n) > _M_size)
+             __valarray_default_construct(__a, __a + __n);
+           else
+             {
+               __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
+               __valarray_default_construct(__a+_M_size-__n, __a + _M_size);
+             }
+         }
+       else                        // __n < 0: shift right
+         {                          
+           __valarray_copy_construct (_M_data, _M_data+_M_size+__n, __a-__n);
+           __valarray_default_construct(__a, __a - __n);
+         }
+       return valarray<_Tp> (__a, _M_size);
+     }
+
+  template <class _Tp>
+     inline valarray<_Tp>
+     valarray<_Tp>::cshift (int __n) const
+     {
+       _Tp* const __a = static_cast<_Tp*>
+         (__builtin_alloca (sizeof(_Tp) * _M_size));
+       if (__n == 0)               // no cshift
+         __valarray_copy_construct(_M_data, _M_data + _M_size, __a);
+       else if (__n > 0)           // cshift left
+         {               
+           __valarray_copy_construct(_M_data, _M_data+__n, __a+_M_size-__n);
+           __valarray_copy_construct(_M_data+__n, _M_data + _M_size, __a);
+         }
+       else                        // cshift right
+         {                       
+           __valarray_copy_construct
+             (_M_data + _M_size+__n, _M_data + _M_size, __a);
+           __valarray_copy_construct
+             (_M_data, _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)
+  {
+    // This complication is so to make valarray<valarray<T> > work
+    // even though it is not required by the standard.  Nobody should
+    // be saying valarray<valarray<T> > anyway.  See the specs.
+    __valarray_destroy_elements(_M_data, _M_data + _M_size);
+    if (_M_size != __n)
+      {
+        __valarray_release_memory(_M_data);
+        _M_size = __n;
+        _M_data = __valarray_get_storage<_Tp>(__n);
+      }
+    __valarray_fill_construct(_M_data, _M_data + __n, __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
+
+
+} // std::
+  
+
+namespace std
+{
+
+#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_LOGICAL_OPERATOR
+
+} // namespace std
+
+#endif // _CPP_VALARRAY
+
+// Local Variables:
+// mode:c++
+// End: