l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.6/include/std/valarray

   1 // The template and inlines for the -*- C++ -*- valarray class.
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   4 // 2006, 2007, 2008, 2009, 2010
   5 // Free Software Foundation, Inc.
   6 //
   7 // This file is part of the GNU ISO C++ Library.  This library is free
   8 // software; you can redistribute it and/or modify it under the
   9 // terms of the GNU General Public License as published by the
  10 // Free Software Foundation; either version 3, or (at your option)
  11 // any later version.
  12
  13 // This library is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // Under Section 7 of GPL version 3, you are granted additional
  19 // permissions described in the GCC Runtime Library Exception, version
  20 // 3.1, as published by the Free Software Foundation.
  21
  22 // You should have received a copy of the GNU General Public License and
  23 // a copy of the GCC Runtime Library Exception along with this program;
  24 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  25 // <http://www.gnu.org/licenses/>.
  26
  27 /** @file include/valarray
  28  *  This is a Standard C++ Library header.
  29  */
  30
  31 // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
  32
  33 #ifndef _GLIBCXX_VALARRAY
  34 #define _GLIBCXX_VALARRAY 1
  35
  36 #pragma GCC system_header
  37
  38 #include <bits/c++config.h>
  39 #include <cmath>
  40 #include <algorithm>
  41 #include <debug/debug.h>
  42 #include <initializer_list>
  43
  44 namespace std _GLIBCXX_VISIBILITY(default)
  45 {
  46 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  47
  48   template<class _Clos, typename _Tp>
  49     class _Expr;
  50
  51   template<typename _Tp1, typename _Tp2>
  52     class _ValArray;
  53
  54   template<class _Oper, template<class, class> class _Meta, class _Dom>
  55     struct _UnClos;
  56
  57   template<class _Oper,
  58         template<class, class> class _Meta1,
  59         template<class, class> class _Meta2,
  60         class _Dom1, class _Dom2>
  61     class _BinClos;
  62
  63   template<template<class, class> class _Meta, class _Dom>
  64     class _SClos;
  65
  66   template<template<class, class> class _Meta, class _Dom>
  67     class _GClos;
  68
  69   template<template<class, class> class _Meta, class _Dom>
  70     class _IClos;
  71
  72   template<template<class, class> class _Meta, class _Dom>
  73     class _ValFunClos;
  74
  75   template<template<class, class> class _Meta, class _Dom>
  76     class _RefFunClos;
  77
  78   template<class _Tp> class valarray;   // An array of type _Tp
  79   class slice;                          // BLAS-like slice out of an array
  80   template<class _Tp> class slice_array;
  81   class gslice;                         // generalized slice out of an array
  82   template<class _Tp> class gslice_array;
  83   template<class _Tp> class mask_array;     // masked array
  84   template<class _Tp> class indirect_array; // indirected array
  85
  86 _GLIBCXX_END_NAMESPACE_VERSION
  87 } // namespace
  88
  89 #include <bits/valarray_array.h>
  90 #include <bits/valarray_before.h>
  91
  92 namespace std _GLIBCXX_VISIBILITY(default)
  93 {
  94 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  95
  96   /**
  97    * @defgroup numeric_arrays Numeric Arrays
  98    * @ingroup numerics
  99    *
 100    * Classes and functions for representing and manipulating arrays of elements.
 101    * @{
 102    */
 103
 104   /**
 105    *  @brief  Smart array designed to support numeric processing.
 106    *
 107    *  A valarray is an array that provides constraints intended to allow for
 108    *  effective optimization of numeric array processing by reducing the
 109    *  aliasing that can result from pointer representations.  It represents a
 110    *  one-dimensional array from which different multidimensional subsets can
 111    *  be accessed and modified.
 112    *
 113    *  @param  Tp  Type of object in the array.
 114    */
 115   template<class _Tp>
 116     class valarray
 117     {
 118       template<class _Op>
 119         struct _UnaryOp
 120         {
 121           typedef typename __fun<_Op, _Tp>::result_type __rt;
 122           typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt;
 123         };
 124     public:
 125       typedef _Tp value_type;
 126
 127         // _lib.valarray.cons_ construct/destroy:
 128       ///  Construct an empty array.
 129       valarray();
 130
 131       ///  Construct an array with @a n elements.
 132       explicit valarray(size_t);
 133
 134       ///  Construct an array with @a n elements initialized to @a t.
 135       valarray(const _Tp&, size_t);
 136
 137       ///  Construct an array initialized to the first @a n elements of @a t.
 138       valarray(const _Tp* __restrict__, size_t);
 139
 140       ///  Copy constructor.
 141       valarray(const valarray&);
 142
 143       ///  Construct an array with the same size and values in @a sa.
 144       valarray(const slice_array<_Tp>&);
 145
 146       ///  Construct an array with the same size and values in @a ga.
 147       valarray(const gslice_array<_Tp>&);
 148
 149       ///  Construct an array with the same size and values in @a ma.
 150       valarray(const mask_array<_Tp>&);
 151
 152       ///  Construct an array with the same size and values in @a ia.
 153       valarray(const indirect_array<_Tp>&);
 154
 155 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 156       ///  Construct an array with an initializer_list of values.
 157       valarray(initializer_list<_Tp>);
 158 #endif
 159
 160       template<class _Dom>
 161         valarray(const _Expr<_Dom, _Tp>& __e);
 162
 163       ~valarray();
 164
 165       // _lib.valarray.assign_ assignment:
 166       /**
 167        *  @brief  Assign elements to an array.
 168        *
 169        *  Assign elements of array to values in @a v.  Results are undefined
 170        *  if @a v does not have the same size as this array.
 171        *
 172        *  @param  v  Valarray to get values from.
 173        */
 174       valarray<_Tp>& operator=(const valarray<_Tp>&);
 175
 176       /**
 177        *  @brief  Assign elements to a value.
 178        *
 179        *  Assign all elements of array to @a t.
 180        *
 181        *  @param  t  Value for elements.
 182        */
 183       valarray<_Tp>& operator=(const _Tp&);
 184
 185       /**
 186        *  @brief  Assign elements to an array subset.
 187        *
 188        *  Assign elements of array to values in @a sa.  Results are undefined
 189        *  if @a sa does not have the same size as this array.
 190        *
 191        *  @param  sa  Array slice to get values from.
 192        */
 193       valarray<_Tp>& operator=(const slice_array<_Tp>&);
 194
 195       /**
 196        *  @brief  Assign elements to an array subset.
 197        *
 198        *  Assign elements of array to values in @a ga.  Results are undefined
 199        *  if @a ga does not have the same size as this array.
 200        *
 201        *  @param  ga  Array slice to get values from.
 202        */
 203       valarray<_Tp>& operator=(const gslice_array<_Tp>&);
 204
 205       /**
 206        *  @brief  Assign elements to an array subset.
 207        *
 208        *  Assign elements of array to values in @a ma.  Results are undefined
 209        *  if @a ma does not have the same size as this array.
 210        *
 211        *  @param  ma  Array slice to get values from.
 212        */
 213       valarray<_Tp>& operator=(const mask_array<_Tp>&);
 214
 215       /**
 216        *  @brief  Assign elements to an array subset.
 217        *
 218        *  Assign elements of array to values in @a ia.  Results are undefined
 219        *  if @a ia does not have the same size as this array.
 220        *
 221        *  @param  ia  Array slice to get values from.
 222        */
 223       valarray<_Tp>& operator=(const indirect_array<_Tp>&);
 224
 225 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 226       /**
 227        *  @brief  Assign elements to an initializer_list.
 228        *
 229        *  Assign elements of array to values in @a l.  Results are undefined
 230        *  if @a l does not have the same size as this array.
 231        *
 232        *  @param  l  initializer_list to get values from.
 233        */
 234       valarray& operator=(initializer_list<_Tp>);
 235 #endif
 236
 237       template<class _Dom> valarray<_Tp>&
 238         operator= (const _Expr<_Dom, _Tp>&);
 239
 240       // _lib.valarray.access_ element access:
 241       /**
 242        *  Return a reference to the i'th array element.
 243        *
 244        *  @param  i  Index of element to return.
 245        *  @return  Reference to the i'th element.
 246        */
 247       _Tp&                operator[](size_t);
 248
 249       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 250       // 389. Const overload of valarray::operator[] returns by value.
 251       const _Tp&          operator[](size_t) const;
 252
 253       // _lib.valarray.sub_ subset operations:
 254       /**
 255        *  @brief  Return an array subset.
 256        *
 257        *  Returns a new valarray containing the elements of the array
 258        *  indicated by the slice argument.  The new valarray has the same size
 259        *  as the input slice.  @see slice.
 260        *
 261        *  @param  s  The source slice.
 262        *  @return  New valarray containing elements in @a s.
 263        */
 264       _Expr<_SClos<_ValArray, _Tp>, _Tp> operator[](slice) const;
 265
 266       /**
 267        *  @brief  Return a reference to an array subset.
 268        *
 269        *  Returns a new valarray containing the elements of the array
 270        *  indicated by the slice argument.  The new valarray has the same size
 271        *  as the input slice.  @see slice.
 272        *
 273        *  @param  s  The source slice.
 274        *  @return  New valarray containing elements in @a s.
 275        */
 276       slice_array<_Tp>    operator[](slice);
 277
 278       /**
 279        *  @brief  Return an array subset.
 280        *
 281        *  Returns a slice_array referencing the elements of the array
 282        *  indicated by the slice argument.  @see gslice.
 283        *
 284        *  @param  s  The source slice.
 285        *  @return  Slice_array referencing elements indicated by @a s.
 286        */
 287       _Expr<_GClos<_ValArray, _Tp>, _Tp> operator[](const gslice&) const;
 288
 289       /**
 290        *  @brief  Return a reference to an array subset.
 291        *
 292        *  Returns a new valarray containing the elements of the array
 293        *  indicated by the gslice argument.  The new valarray has
 294        *  the same size as the input gslice.  @see gslice.
 295        *
 296        *  @param  s  The source gslice.
 297        *  @return  New valarray containing elements in @a s.
 298        */
 299       gslice_array<_Tp>   operator[](const gslice&);
 300
 301       /**
 302        *  @brief  Return an array subset.
 303        *
 304        *  Returns a new valarray containing the elements of the array
 305        *  indicated by the argument.  The input is a valarray of bool which
 306        *  represents a bitmask indicating which elements should be copied into
 307        *  the new valarray.  Each element of the array is added to the return
 308        *  valarray if the corresponding element of the argument is true.
 309        *
 310        *  @param  m  The valarray bitmask.
 311        *  @return  New valarray containing elements indicated by @a m.
 312        */
 313       valarray<_Tp>       operator[](const valarray<bool>&) const;
 314
 315       /**
 316        *  @brief  Return a reference to an array subset.
 317        *
 318        *  Returns a new mask_array referencing the elements of the array
 319        *  indicated by the argument.  The input is a valarray of bool which
 320        *  represents a bitmask indicating which elements are part of the
 321        *  subset.  Elements of the array are part of the subset if the
 322        *  corresponding element of the argument is true.
 323        *
 324        *  @param  m  The valarray bitmask.
 325        *  @return  New valarray containing elements indicated by @a m.
 326        */
 327       mask_array<_Tp>     operator[](const valarray<bool>&);
 328
 329       /**
 330        *  @brief  Return an array subset.
 331        *
 332        *  Returns a new valarray containing the elements of the array
 333        *  indicated by the argument.  The elements in the argument are
 334        *  interpreted as the indices of elements of this valarray to copy to
 335        *  the return valarray.
 336        *
 337        *  @param  i  The valarray element index list.
 338        *  @return  New valarray containing elements in @a s.
 339        */
 340       _Expr<_IClos<_ValArray, _Tp>, _Tp>
 341         operator[](const valarray<size_t>&) const;
 342
 343       /**
 344        *  @brief  Return a reference to an array subset.
 345        *
 346        *  Returns an indirect_array referencing the elements of the array
 347        *  indicated by the argument.  The elements in the argument are
 348        *  interpreted as the indices of elements of this valarray to include
 349        *  in the subset.  The returned indirect_array refers to these
 350        *  elements.
 351        *
 352        *  @param  i  The valarray element index list.
 353        *  @return  Indirect_array referencing elements in @a i.
 354        */
 355       indirect_array<_Tp> operator[](const valarray<size_t>&);
 356
 357       // _lib.valarray.unary_ unary operators:
 358       ///  Return a new valarray by applying unary + to each element.
 359       typename _UnaryOp<__unary_plus>::_Rt  operator+() const;
 360
 361       ///  Return a new valarray by applying unary - to each element.
 362       typename _UnaryOp<__negate>::_Rt      operator-() const;
 363
 364       ///  Return a new valarray by applying unary ~ to each element.
 365       typename _UnaryOp<__bitwise_not>::_Rt operator~() const;
 366
 367       ///  Return a new valarray by applying unary ! to each element.
 368       typename _UnaryOp<__logical_not>::_Rt operator!() const;
 369
 370       // _lib.valarray.cassign_ computed assignment:
 371       ///  Multiply each element of array by @a t.
 372       valarray<_Tp>& operator*=(const _Tp&);
 373
 374       ///  Divide each element of array by @a t.
 375       valarray<_Tp>& operator/=(const _Tp&);
 376
 377       ///  Set each element e of array to e % @a t.
 378       valarray<_Tp>& operator%=(const _Tp&);
 379
 380       ///  Add @a t to each element of array.
 381       valarray<_Tp>& operator+=(const _Tp&);
 382
 383       ///  Subtract @a t to each element of array.
 384       valarray<_Tp>& operator-=(const _Tp&);
 385
 386       ///  Set each element e of array to e ^ @a t.
 387       valarray<_Tp>& operator^=(const _Tp&);
 388
 389       ///  Set each element e of array to e & @a t.
 390       valarray<_Tp>& operator&=(const _Tp&);
 391
 392       ///  Set each element e of array to e | @a t.
 393       valarray<_Tp>& operator|=(const _Tp&);
 394
 395       ///  Left shift each element e of array by @a t bits.
 396       valarray<_Tp>& operator<<=(const _Tp&);
 397
 398       ///  Right shift each element e of array by @a t bits.
 399       valarray<_Tp>& operator>>=(const _Tp&);
 400
 401       ///  Multiply elements of array by corresponding elements of @a v.
 402       valarray<_Tp>& operator*=(const valarray<_Tp>&);
 403
 404       ///  Divide elements of array by corresponding elements of @a v.
 405       valarray<_Tp>& operator/=(const valarray<_Tp>&);
 406
 407       ///  Modulo elements of array by corresponding elements of @a v.
 408       valarray<_Tp>& operator%=(const valarray<_Tp>&);
 409
 410       ///  Add corresponding elements of @a v to elements of array.
 411       valarray<_Tp>& operator+=(const valarray<_Tp>&);
 412
 413       ///  Subtract corresponding elements of @a v from elements of array.
 414       valarray<_Tp>& operator-=(const valarray<_Tp>&);
 415
 416       ///  Logical xor corresponding elements of @a v with elements of array.
 417       valarray<_Tp>& operator^=(const valarray<_Tp>&);
 418
 419       ///  Logical or corresponding elements of @a v with elements of array.
 420       valarray<_Tp>& operator|=(const valarray<_Tp>&);
 421
 422       ///  Logical and corresponding elements of @a v with elements of array.
 423       valarray<_Tp>& operator&=(const valarray<_Tp>&);
 424
 425       ///  Left shift elements of array by corresponding elements of @a v.
 426       valarray<_Tp>& operator<<=(const valarray<_Tp>&);
 427
 428       ///  Right shift elements of array by corresponding elements of @a v.
 429       valarray<_Tp>& operator>>=(const valarray<_Tp>&);
 430
 431       template<class _Dom>
 432         valarray<_Tp>& operator*=(const _Expr<_Dom, _Tp>&);
 433       template<class _Dom>
 434         valarray<_Tp>& operator/=(const _Expr<_Dom, _Tp>&);
 435       template<class _Dom>
 436         valarray<_Tp>& operator%=(const _Expr<_Dom, _Tp>&);
 437       template<class _Dom>
 438         valarray<_Tp>& operator+=(const _Expr<_Dom, _Tp>&);
 439       template<class _Dom>
 440         valarray<_Tp>& operator-=(const _Expr<_Dom, _Tp>&);
 441       template<class _Dom>
 442         valarray<_Tp>& operator^=(const _Expr<_Dom, _Tp>&);
 443       template<class _Dom>
 444         valarray<_Tp>& operator|=(const _Expr<_Dom, _Tp>&);
 445       template<class _Dom>
 446         valarray<_Tp>& operator&=(const _Expr<_Dom, _Tp>&);
 447       template<class _Dom>
 448         valarray<_Tp>& operator<<=(const _Expr<_Dom, _Tp>&);
 449       template<class _Dom>
 450         valarray<_Tp>& operator>>=(const _Expr<_Dom, _Tp>&);
 451
 452       // _lib.valarray.members_ member functions:
 453       ///  Return the number of elements in array.
 454       size_t size() const;
 455
 456       /**
 457        *  @brief  Return the sum of all elements in the array.
 458        *
 459        *  Accumulates the sum of all elements into a Tp using +=.  The order
 460        *  of adding the elements is unspecified.
 461        */
 462       _Tp    sum() const;
 463
 464       ///  Return the minimum element using operator<().
 465       _Tp    min() const;
 466
 467       ///  Return the maximum element using operator<().
 468       _Tp    max() const;
 469
 470       /**
 471        *  @brief  Return a shifted array.
 472        *
 473        *  A new valarray is constructed as a copy of this array with elements
 474        *  in shifted positions.  For an element with index i, the new position
 475        *  is i - n.  The new valarray has the same size as the current one.
 476        *  New elements without a value are set to 0.  Elements whose new
 477        *  position is outside the bounds of the array are discarded.
 478        *
 479        *  Positive arguments shift toward index 0, discarding elements [0, n).
 480        *  Negative arguments discard elements from the top of the array.
 481        *
 482        *  @param  n  Number of element positions to shift.
 483        *  @return  New valarray with elements in shifted positions.
 484        */
 485       valarray<_Tp> shift (int) const;
 486
 487       /**
 488        *  @brief  Return a rotated array.
 489        *
 490        *  A new valarray is constructed as a copy of this array with elements
 491        *  in shifted positions.  For an element with index i, the new position
 492        *  is (i - n) % size().  The new valarray has the same size as the
 493        *  current one.  Elements that are shifted beyond the array bounds are
 494        *  shifted into the other end of the array.  No elements are lost.
 495        *
 496        *  Positive arguments shift toward index 0, wrapping around the top.
 497        *  Negative arguments shift towards the top, wrapping around to 0.
 498        *
 499        *  @param  n  Number of element positions to rotate.
 500        *  @return  New valarray with elements in shifted positions.
 501        */
 502       valarray<_Tp> cshift(int) const;
 503
 504       /**
 505        *  @brief  Apply a function to the array.
 506        *
 507        *  Returns a new valarray with elements assigned to the result of
 508        *  applying func to the corresponding element of this array.  The new
 509        *  array has the same size as this one.
 510        *
 511        *  @param  func  Function of Tp returning Tp to apply.
 512        *  @return  New valarray with transformed elements.
 513        */
 514       _Expr<_ValFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(_Tp)) const;
 515
 516       /**
 517        *  @brief  Apply a function to the array.
 518        *
 519        *  Returns a new valarray with elements assigned to the result of
 520        *  applying func to the corresponding element of this array.  The new
 521        *  array has the same size as this one.
 522        *
 523        *  @param  func  Function of const Tp& returning Tp to apply.
 524        *  @return  New valarray with transformed elements.
 525        */
 526       _Expr<_RefFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(const _Tp&)) const;
 527
 528       /**
 529        *  @brief  Resize array.
 530        *
 531        *  Resize this array to @a size and set all elements to @a c.  All
 532        *  references and iterators are invalidated.
 533        *
 534        *  @param  size  New array size.
 535        *  @param  c  New value for all elements.
 536        */
 537       void resize(size_t __size, _Tp __c = _Tp());
 538
 539     private:
 540       size_t _M_size;
 541       _Tp* __restrict__ _M_data;
 542
 543       friend class _Array<_Tp>;
 544     };
 545
 546   template<typename _Tp>
 547     inline const _Tp&
 548     valarray<_Tp>::operator[](size_t __i) const
 549     {
 550       __glibcxx_requires_subscript(__i);
 551       return _M_data[__i];
 552     }
 553
 554   template<typename _Tp>
 555     inline _Tp&
 556     valarray<_Tp>::operator[](size_t __i)
 557     {
 558       __glibcxx_requires_subscript(__i);
 559       return _M_data[__i];
 560     }
 561
 562   // @} group numeric_arrays
 563
 564 _GLIBCXX_END_NAMESPACE_VERSION
 565 } // namespace
 566
 567 #include <bits/valarray_after.h>
 568 #include <bits/slice_array.h>
 569 #include <bits/gslice.h>
 570 #include <bits/gslice_array.h>
 571 #include <bits/mask_array.h>
 572 #include <bits/indirect_array.h>
 573
 574 namespace std _GLIBCXX_VISIBILITY(default)
 575 {
 576 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 577
 578   /**
 579    * @addtogroup numeric_arrays
 580    * @{
 581    */
 582
 583   template<typename _Tp>
 584     inline
 585     valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {}
 586
 587   template<typename _Tp>
 588     inline
 589     valarray<_Tp>::valarray(size_t __n)
 590     : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
 591     { std::__valarray_default_construct(_M_data, _M_data + __n); }
 592
 593   template<typename _Tp>
 594     inline
 595     valarray<_Tp>::valarray(const _Tp& __t, size_t __n)
 596     : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
 597     { std::__valarray_fill_construct(_M_data, _M_data + __n, __t); }
 598
 599   template<typename _Tp>
 600     inline
 601     valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n)
 602     : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
 603     {
 604       _GLIBCXX_DEBUG_ASSERT(__p != 0 || __n == 0);
 605       std::__valarray_copy_construct(__p, __p + __n, _M_data);
 606     }
 607
 608   template<typename _Tp>
 609     inline
 610     valarray<_Tp>::valarray(const valarray<_Tp>& __v)
 611     : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size))
 612     { std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size,
 613                                      _M_data); }
 614
 615   template<typename _Tp>
 616     inline
 617     valarray<_Tp>::valarray(const slice_array<_Tp>& __sa)
 618     : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz))
 619     {
 620       std::__valarray_copy_construct
 621         (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data));
 622     }
 623
 624   template<typename _Tp>
 625     inline
 626     valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga)
 627     : _M_size(__ga._M_index.size()),
 628       _M_data(__valarray_get_storage<_Tp>(_M_size))
 629     {
 630       std::__valarray_copy_construct
 631         (__ga._M_array, _Array<size_t>(__ga._M_index),
 632          _Array<_Tp>(_M_data), _M_size);
 633     }
 634
 635   template<typename _Tp>
 636     inline
 637     valarray<_Tp>::valarray(const mask_array<_Tp>& __ma)
 638     : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz))
 639     {
 640       std::__valarray_copy_construct
 641         (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size);
 642     }
 643
 644   template<typename _Tp>
 645     inline
 646     valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia)
 647     : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz))
 648     {
 649       std::__valarray_copy_construct
 650         (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size);
 651     }
 652
 653 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 654   template<typename _Tp>
 655     inline
 656     valarray<_Tp>::valarray(initializer_list<_Tp> __l)
 657     : _M_size(__l.size()), _M_data(__valarray_get_storage<_Tp>(__l.size()))
 658     { std::__valarray_copy_construct (__l.begin(), __l.end(), _M_data); }
 659 #endif
 660
 661   template<typename _Tp> template<class _Dom>
 662     inline
 663     valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e)
 664     : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size))
 665     { std::__valarray_copy_construct(__e, _M_size, _Array<_Tp>(_M_data)); }
 666
 667   template<typename _Tp>
 668     inline
 669     valarray<_Tp>::~valarray()
 670     {
 671       std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
 672       std::__valarray_release_memory(_M_data);
 673     }
 674
 675   template<typename _Tp>
 676     inline valarray<_Tp>&
 677     valarray<_Tp>::operator=(const valarray<_Tp>& __v)
 678     {
 679       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 680       // 630. arrays of valarray.
 681       if (_M_size == __v._M_size)
 682         std::__valarray_copy(__v._M_data, _M_size, _M_data);
 683       else
 684         {
 685           if (_M_data)
 686             {
 687               std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
 688               std::__valarray_release_memory(_M_data);
 689             }
 690           _M_size = __v._M_size;
 691           _M_data = __valarray_get_storage<_Tp>(_M_size);
 692           std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size,
 693                                          _M_data);
 694         }
 695       return *this;
 696     }
 697
 698 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 699   template<typename _Tp>
 700     inline valarray<_Tp>&
 701     valarray<_Tp>::operator=(initializer_list<_Tp> __l)
 702     {
 703       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 704       // 630. arrays of valarray.
 705       if (_M_size == __l.size())
 706         std::__valarray_copy(__l.begin(), __l.size(), _M_data);
 707       else
 708         {
 709           if (_M_data)
 710             {
 711               std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
 712               std::__valarray_release_memory(_M_data);
 713             }
 714           _M_size = __l.size();
 715           _M_data = __valarray_get_storage<_Tp>(_M_size);
 716           std::__valarray_copy_construct(__l.begin(), __l.begin() + _M_size,
 717                                          _M_data);
 718         }
 719       return *this;
 720     }
 721 #endif
 722
 723   template<typename _Tp>
 724     inline valarray<_Tp>&
 725     valarray<_Tp>::operator=(const _Tp& __t)
 726     {
 727       std::__valarray_fill(_M_data, _M_size, __t);
 728       return *this;
 729     }
 730
 731   template<typename _Tp>
 732     inline valarray<_Tp>&
 733     valarray<_Tp>::operator=(const slice_array<_Tp>& __sa)
 734     {
 735       _GLIBCXX_DEBUG_ASSERT(_M_size == __sa._M_sz);
 736       std::__valarray_copy(__sa._M_array, __sa._M_sz,
 737                            __sa._M_stride, _Array<_Tp>(_M_data));
 738       return *this;
 739     }
 740
 741   template<typename _Tp>
 742     inline valarray<_Tp>&
 743     valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga)
 744     {
 745       _GLIBCXX_DEBUG_ASSERT(_M_size == __ga._M_index.size());
 746       std::__valarray_copy(__ga._M_array, _Array<size_t>(__ga._M_index),
 747                            _Array<_Tp>(_M_data), _M_size);
 748       return *this;
 749     }
 750
 751   template<typename _Tp>
 752     inline valarray<_Tp>&
 753     valarray<_Tp>::operator=(const mask_array<_Tp>& __ma)
 754     {
 755       _GLIBCXX_DEBUG_ASSERT(_M_size == __ma._M_sz);
 756       std::__valarray_copy(__ma._M_array, __ma._M_mask,
 757                            _Array<_Tp>(_M_data), _M_size);
 758       return *this;
 759     }
 760
 761   template<typename _Tp>
 762     inline valarray<_Tp>&
 763     valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia)
 764     {
 765       _GLIBCXX_DEBUG_ASSERT(_M_size == __ia._M_sz);
 766       std::__valarray_copy(__ia._M_array, __ia._M_index,
 767                            _Array<_Tp>(_M_data), _M_size);
 768       return *this;
 769     }
 770
 771   template<typename _Tp> template<class _Dom>
 772     inline valarray<_Tp>&
 773     valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e)
 774     {
 775       _GLIBCXX_DEBUG_ASSERT(_M_size == __e.size());
 776       std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data));
 777       return *this;
 778     }
 779
 780   template<typename _Tp>
 781     inline _Expr<_SClos<_ValArray,_Tp>, _Tp>
 782     valarray<_Tp>::operator[](slice __s) const
 783     {
 784       typedef _SClos<_ValArray,_Tp> _Closure;
 785       return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s));
 786     }
 787
 788   template<typename _Tp>
 789     inline slice_array<_Tp>
 790     valarray<_Tp>::operator[](slice __s)
 791     { return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); }
 792
 793   template<typename _Tp>
 794     inline _Expr<_GClos<_ValArray,_Tp>, _Tp>
 795     valarray<_Tp>::operator[](const gslice& __gs) const
 796     {
 797       typedef _GClos<_ValArray,_Tp> _Closure;
 798       return _Expr<_Closure, _Tp>
 799         (_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index));
 800     }
 801
 802   template<typename _Tp>
 803     inline gslice_array<_Tp>
 804     valarray<_Tp>::operator[](const gslice& __gs)
 805     {
 806       return gslice_array<_Tp>
 807         (_Array<_Tp>(_M_data), __gs._M_index->_M_index);
 808     }
 809
 810   template<typename _Tp>
 811     inline valarray<_Tp>
 812     valarray<_Tp>::operator[](const valarray<bool>& __m) const
 813     {
 814       size_t __s = 0;
 815       size_t __e = __m.size();
 816       for (size_t __i=0; __i<__e; ++__i)
 817         if (__m[__i]) ++__s;
 818       return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s,
 819                                            _Array<bool> (__m)));
 820     }
 821
 822   template<typename _Tp>
 823     inline mask_array<_Tp>
 824     valarray<_Tp>::operator[](const valarray<bool>& __m)
 825     {
 826       size_t __s = 0;
 827       size_t __e = __m.size();
 828       for (size_t __i=0; __i<__e; ++__i)
 829         if (__m[__i]) ++__s;
 830       return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array<bool>(__m));
 831     }
 832
 833   template<typename _Tp>
 834     inline _Expr<_IClos<_ValArray,_Tp>, _Tp>
 835     valarray<_Tp>::operator[](const valarray<size_t>& __i) const
 836     {
 837       typedef _IClos<_ValArray,_Tp> _Closure;
 838       return _Expr<_Closure, _Tp>(_Closure(*this, __i));
 839     }
 840
 841   template<typename _Tp>
 842     inline indirect_array<_Tp>
 843     valarray<_Tp>::operator[](const valarray<size_t>& __i)
 844     {
 845       return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(),
 846                                  _Array<size_t>(__i));
 847     }
 848
 849   template<class _Tp>
 850     inline size_t
 851     valarray<_Tp>::size() const
 852     { return _M_size; }
 853
 854   template<class _Tp>
 855     inline _Tp
 856     valarray<_Tp>::sum() const
 857     {
 858       _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
 859       return std::__valarray_sum(_M_data, _M_data + _M_size);
 860     }
 861
 862   template<class _Tp>
 863      inline valarray<_Tp>
 864      valarray<_Tp>::shift(int __n) const
 865      {
 866        valarray<_Tp> __ret;
 867
 868        if (_M_size == 0)
 869          return __ret;
 870
 871        _Tp* __restrict__ __tmp_M_data =
 872          std::__valarray_get_storage<_Tp>(_M_size);
 873
 874        if (__n == 0)
 875          std::__valarray_copy_construct(_M_data,
 876                                         _M_data + _M_size, __tmp_M_data);
 877        else if (__n > 0)      // shift left
 878          {
 879            if (size_t(__n) > _M_size)
 880              __n = int(_M_size);
 881
 882            std::__valarray_copy_construct(_M_data + __n,
 883                                           _M_data + _M_size, __tmp_M_data);
 884            std::__valarray_default_construct(__tmp_M_data + _M_size - __n,
 885                                              __tmp_M_data + _M_size);
 886          }
 887        else                   // shift right
 888          {
 889            if (-size_t(__n) > _M_size)
 890              __n = -int(_M_size);
 891
 892            std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n,
 893                                           __tmp_M_data - __n);
 894            std::__valarray_default_construct(__tmp_M_data,
 895                                              __tmp_M_data - __n);
 896          }
 897
 898        __ret._M_size = _M_size;
 899        __ret._M_data = __tmp_M_data;
 900        return __ret;
 901      }
 902
 903   template<class _Tp>
 904      inline valarray<_Tp>
 905      valarray<_Tp>::cshift(int __n) const
 906      {
 907        valarray<_Tp> __ret;
 908
 909        if (_M_size == 0)
 910          return __ret;
 911
 912        _Tp* __restrict__ __tmp_M_data =
 913          std::__valarray_get_storage<_Tp>(_M_size);
 914
 915        if (__n == 0)
 916          std::__valarray_copy_construct(_M_data,
 917                                         _M_data + _M_size, __tmp_M_data);
 918        else if (__n > 0)      // cshift left
 919          {
 920            if (size_t(__n) > _M_size)
 921              __n = int(__n % _M_size);
 922
 923            std::__valarray_copy_construct(_M_data, _M_data + __n,
 924                                           __tmp_M_data + _M_size - __n);
 925            std::__valarray_copy_construct(_M_data + __n, _M_data + _M_size,
 926                                           __tmp_M_data);
 927          }
 928        else                   // cshift right
 929          {
 930            if (-size_t(__n) > _M_size)
 931              __n = -int(-size_t(__n) % _M_size);
 932
 933            std::__valarray_copy_construct(_M_data + _M_size + __n,
 934                                           _M_data + _M_size, __tmp_M_data);
 935            std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n,
 936                                           __tmp_M_data - __n);
 937          }
 938
 939        __ret._M_size = _M_size;
 940        __ret._M_data = __tmp_M_data;
 941        return __ret;
 942      }
 943
 944   template<class _Tp>
 945     inline void
 946     valarray<_Tp>::resize(size_t __n, _Tp __c)
 947     {
 948       // This complication is so to make valarray<valarray<T> > work
 949       // even though it is not required by the standard.  Nobody should
 950       // be saying valarray<valarray<T> > anyway.  See the specs.
 951       std::__valarray_destroy_elements(_M_data, _M_data + _M_size);
 952       if (_M_size != __n)
 953         {
 954           std::__valarray_release_memory(_M_data);
 955           _M_size = __n;
 956           _M_data = __valarray_get_storage<_Tp>(__n);
 957         }
 958       std::__valarray_fill_construct(_M_data, _M_data + __n, __c);
 959     }
 960
 961   template<typename _Tp>
 962     inline _Tp
 963     valarray<_Tp>::min() const
 964     {
 965       _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
 966       return *std::min_element(_M_data, _M_data + _M_size);
 967     }
 968
 969   template<typename _Tp>
 970     inline _Tp
 971     valarray<_Tp>::max() const
 972     {
 973       _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
 974       return *std::max_element(_M_data, _M_data + _M_size);
 975     }
 976
 977   template<class _Tp>
 978     inline _Expr<_ValFunClos<_ValArray, _Tp>, _Tp>
 979     valarray<_Tp>::apply(_Tp func(_Tp)) const
 980     {
 981       typedef _ValFunClos<_ValArray, _Tp> _Closure;
 982       return _Expr<_Closure, _Tp>(_Closure(*this, func));
 983     }
 984
 985   template<class _Tp>
 986     inline _Expr<_RefFunClos<_ValArray, _Tp>, _Tp>
 987     valarray<_Tp>::apply(_Tp func(const _Tp &)) const
 988     {
 989       typedef _RefFunClos<_ValArray, _Tp> _Closure;
 990       return _Expr<_Closure, _Tp>(_Closure(*this, func));
 991     }
 992
 993 #define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name)                     \
 994   template<typename _Tp>                                                \
 995     inline typename valarray<_Tp>::template _UnaryOp<_Name>::_Rt        \
 996     valarray<_Tp>::operator _Op() const                                 \
 997     {                                                                   \
 998       typedef _UnClos<_Name, _ValArray, _Tp> _Closure;                  \
 999       typedef typename __fun<_Name, _Tp>::result_type _Rt;              \
1000       return _Expr<_Closure, _Rt>(_Closure(*this));                     \
1001     }
1002
1003     _DEFINE_VALARRAY_UNARY_OPERATOR(+, __unary_plus)
1004     _DEFINE_VALARRAY_UNARY_OPERATOR(-, __negate)
1005     _DEFINE_VALARRAY_UNARY_OPERATOR(~, __bitwise_not)
1006     _DEFINE_VALARRAY_UNARY_OPERATOR (!, __logical_not)
1007
1008 #undef _DEFINE_VALARRAY_UNARY_OPERATOR
1009
1010 #define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name)               \
1011   template<class _Tp>                                                   \
1012     inline valarray<_Tp>&                                               \
1013     valarray<_Tp>::operator _Op##=(const _Tp &__t)                      \
1014     {                                                                   \
1015       _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size, __t);     \
1016       return *this;                                                     \
1017     }                                                                   \
1018                                                                         \
1019   template<class _Tp>                                                   \
1020     inline valarray<_Tp>&                                               \
1021     valarray<_Tp>::operator _Op##=(const valarray<_Tp> &__v)            \
1022     {                                                                   \
1023       _GLIBCXX_DEBUG_ASSERT(_M_size == __v._M_size);                    \
1024       _Array_augmented_##_Name(_Array<_Tp>(_M_data), _M_size,           \
1025                                _Array<_Tp>(__v._M_data));               \
1026       return *this;                                                     \
1027     }
1028
1029 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, __plus)
1030 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, __minus)
1031 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, __multiplies)
1032 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, __divides)
1033 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, __modulus)
1034 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
1035 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
1036 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
1037 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, __shift_left)
1038 _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, __shift_right)
1039
1040 #undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT
1041
1042 #define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name)          \
1043   template<class _Tp> template<class _Dom>                              \
1044     inline valarray<_Tp>&                                               \
1045     valarray<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e)         \
1046     {                                                                   \
1047       _Array_augmented_##_Name(_Array<_Tp>(_M_data), __e, _M_size);     \
1048       return *this;                                                     \
1049     }
1050
1051 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, __plus)
1052 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, __minus)
1053 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, __multiplies)
1054 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, __divides)
1055 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, __modulus)
1056 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, __bitwise_xor)
1057 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, __bitwise_and)
1058 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, __bitwise_or)
1059 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, __shift_left)
1060 _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right)
1061
1062 #undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT
1063
1064
1065 #define _DEFINE_BINARY_OPERATOR(_Op, _Name)                             \
1066   template<typename _Tp>                                                \
1067     inline _Expr<_BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp>,       \
1068                  typename __fun<_Name, _Tp>::result_type>               \
1069     operator _Op(const valarray<_Tp>& __v, const valarray<_Tp>& __w)    \
1070     {                                                                   \
1071       _GLIBCXX_DEBUG_ASSERT(__v.size() == __w.size());                  \
1072       typedef _BinClos<_Name, _ValArray, _ValArray, _Tp, _Tp> _Closure; \
1073       typedef typename __fun<_Name, _Tp>::result_type _Rt;              \
1074       return _Expr<_Closure, _Rt>(_Closure(__v, __w));                  \
1075     }                                                                   \
1076                                                                         \
1077   template<typename _Tp>                                                \
1078     inline _Expr<_BinClos<_Name, _ValArray,_Constant, _Tp, _Tp>,        \
1079                  typename __fun<_Name, _Tp>::result_type>               \
1080     operator _Op(const valarray<_Tp>& __v, const _Tp& __t)              \
1081     {                                                                   \
1082       typedef _BinClos<_Name, _ValArray, _Constant, _Tp, _Tp> _Closure; \
1083       typedef typename __fun<_Name, _Tp>::result_type _Rt;              \
1084       return _Expr<_Closure, _Rt>(_Closure(__v, __t));                  \
1085     }                                                                   \
1086                                                                         \
1087   template<typename _Tp>                                                \
1088     inline _Expr<_BinClos<_Name, _Constant, _ValArray, _Tp, _Tp>,       \
1089                  typename __fun<_Name, _Tp>::result_type>               \
1090     operator _Op(const _Tp& __t, const valarray<_Tp>& __v)              \
1091     {                                                                   \
1092       typedef _BinClos<_Name, _Constant, _ValArray, _Tp, _Tp> _Closure; \
1093       typedef typename __fun<_Name, _Tp>::result_type _Rt;              \
1094       return _Expr<_Closure, _Rt>(_Closure(__t, __v));                  \
1095     }
1096
1097 _DEFINE_BINARY_OPERATOR(+, __plus)
1098 _DEFINE_BINARY_OPERATOR(-, __minus)
1099 _DEFINE_BINARY_OPERATOR(*, __multiplies)
1100 _DEFINE_BINARY_OPERATOR(/, __divides)
1101 _DEFINE_BINARY_OPERATOR(%, __modulus)
1102 _DEFINE_BINARY_OPERATOR(^, __bitwise_xor)
1103 _DEFINE_BINARY_OPERATOR(&, __bitwise_and)
1104 _DEFINE_BINARY_OPERATOR(|, __bitwise_or)
1105 _DEFINE_BINARY_OPERATOR(<<, __shift_left)
1106 _DEFINE_BINARY_OPERATOR(>>, __shift_right)
1107 _DEFINE_BINARY_OPERATOR(&&, __logical_and)
1108 _DEFINE_BINARY_OPERATOR(||, __logical_or)
1109 _DEFINE_BINARY_OPERATOR(==, __equal_to)
1110 _DEFINE_BINARY_OPERATOR(!=, __not_equal_to)
1111 _DEFINE_BINARY_OPERATOR(<, __less)
1112 _DEFINE_BINARY_OPERATOR(>, __greater)
1113 _DEFINE_BINARY_OPERATOR(<=, __less_equal)
1114 _DEFINE_BINARY_OPERATOR(>=, __greater_equal)
1115
1116 #undef _DEFINE_BINARY_OPERATOR
1117
1118 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1119   /**
1120    *  @brief  Return an iterator pointing to the first element of
1121    *          the valarray.
1122    *  @param  va  valarray.
1123    */
1124   template<class _Tp>
1125     inline _Tp*
1126     begin(valarray<_Tp>& __va)
1127     { return std::__addressof(__va[0]); }
1128
1129   /**
1130    *  @brief  Return an iterator pointing to the first element of
1131    *          the const valarray.
1132    *  @param  va  valarray.
1133    */
1134   template<class _Tp>
1135     inline const _Tp*
1136     begin(const valarray<_Tp>& __va)
1137     { return std::__addressof(__va[0]); }
1138
1139   /**
1140    *  @brief  Return an iterator pointing to one past the last element of
1141    *          the valarray.
1142    *  @param  va  valarray.
1143    */
1144   template<class _Tp>
1145     inline _Tp*
1146     end(valarray<_Tp>& __va)
1147     { return std::__addressof(__va[0]) + __va.size(); }
1148
1149   /**
1150    *  @brief  Return an iterator pointing to one past the last element of
1151    *          the const valarray.
1152    *  @param  va  valarray.
1153    */
1154   template<class _Tp>
1155     inline const _Tp*
1156     end(const valarray<_Tp>& __va)
1157     { return std::__addressof(__va[0]) + __va.size(); }
1158 #endif // __GXX_EXPERIMENTAL_CXX0X__
1159
1160   // @} group numeric_arrays
1161
1162 _GLIBCXX_END_NAMESPACE_VERSION
1163 } // namespace
1164
1165 #endif /* _GLIBCXX_VALARRAY */