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