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