libstdc++-v3/include/bits/valarray_array.h

   1 // The template and inlines for the -*- C++ -*- internal _Array helper class.
   2
   3 // Copyright (C) 1997-2024 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 bits/valarray_array.h
  26  *  This is an internal header file, included by other library headers.
  27  *  Do not attempt to use it directly. @headername{valarray}
  28  */
  29
  30 // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
  31
  32 #ifndef _VALARRAY_ARRAY_H
  33 #define _VALARRAY_ARRAY_H 1
  34
  35 #pragma GCC system_header
  36
  37 #include <bits/c++config.h>
  38 #include <bits/cpp_type_traits.h>
  39 #include <cstdlib>
  40 #include <new>
  41
  42 namespace std _GLIBCXX_VISIBILITY(default)
  43 {
  44 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  45
  46   //
  47   // Helper functions on raw pointers
  48   //
  49
  50   // We get memory the old fashioned way
  51   template<typename _Tp>
  52     _Tp*
  53     __valarray_get_storage(size_t) __attribute__((__malloc__));
  54
  55   template<typename _Tp>
  56     inline _Tp*
  57     __valarray_get_storage(size_t __n)
  58     { return static_cast<_Tp*>(operator new(__n * sizeof(_Tp))); }
  59
  60   // Return memory to the system
  61   inline void
  62   __valarray_release_memory(void* __p)
  63   { operator delete(__p); }
  64
  65   // Turn raw-memory into an array of _Tp filled with _Tp().
  66   // This is used in `valarray<T> v(n);` and in `valarray<T>::shift(n)`.
  67   template<typename _Tp>
  68     inline void
  69     __valarray_default_construct(_Tp* __b, _Tp* __e)
  70     {
  71       if _GLIBCXX17_CONSTEXPR (__is_trivial(_Tp))
  72         __builtin_memset(__b, 0, (__e - __b) * sizeof(_Tp));
  73       else
  74         while (__b != __e)
  75           ::new(static_cast<void*>(__b++)) _Tp();
  76     }
  77
  78   // Turn a raw-memory into an array of _Tp filled with __t
  79   // This is the required in valarray<T> v(n, t).  Also
  80   // used in valarray<>::resize().
  81   template<typename _Tp>
  82     inline void
  83     __valarray_fill_construct(_Tp* __b, _Tp* __e, const _Tp __t)
  84     {
  85       while (__b != __e)
  86         ::new(static_cast<void*>(__b++)) _Tp(__t);
  87     }
  88
  89   // copy-construct raw array [__o, *) from plain array [__b, __e)
  90   template<typename _Tp>
  91     inline void
  92     __valarray_copy_construct(const _Tp* __b, const _Tp* __e,
  93                               _Tp* __restrict__ __o)
  94     {
  95       if _GLIBCXX17_CONSTEXPR (__is_trivial(_Tp))
  96         {
  97           if (__b)
  98             __builtin_memcpy(__o, __b, (__e - __b) * sizeof(_Tp));
  99         }
 100       else
 101         while (__b != __e)
 102           ::new(static_cast<void*>(__o++)) _Tp(*__b++);
 103     }
 104
 105   // copy-construct raw array [__o, *) from strided array __a[<__n : __s>]
 106   template<typename _Tp>
 107     inline void
 108     __valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n,
 109                                size_t __s, _Tp* __restrict__ __o)
 110     {
 111       if _GLIBCXX17_CONSTEXPR (__is_trivial(_Tp))
 112         while (__n--)
 113           {
 114             *__o++ = *__a;
 115             __a += __s;
 116           }
 117       else
 118         while (__n--)
 119           {
 120             new(__o++) _Tp(*__a);
 121             __a += __s;
 122           }
 123     }
 124
 125   // copy-construct raw array [__o, *) from indexed array __a[__i[<__n>]]
 126   template<typename _Tp>
 127     inline void
 128     __valarray_copy_construct (const _Tp* __restrict__ __a,
 129                                const size_t* __restrict__ __i,
 130                                _Tp* __restrict__ __o, size_t __n)
 131     {
 132       if (__is_trivial(_Tp))
 133         while (__n--)
 134           *__o++ = __a[*__i++];
 135       else
 136         while (__n--)
 137           new (__o++) _Tp(__a[*__i++]);
 138     }
 139
 140   // Do the necessary cleanup when we're done with arrays.
 141   template<typename _Tp>
 142     inline void
 143     __valarray_destroy_elements(_Tp* __b, _Tp* __e)
 144     {
 145       if (!__is_trivial(_Tp))
 146         while (__b != __e)
 147           {
 148             __b->~_Tp();
 149             ++__b;
 150           }
 151     }
 152
 153   // Fill a plain array __a[<__n>] with __t
 154   template<typename _Tp>
 155     inline void
 156     __valarray_fill(_Tp* __restrict__ __a, size_t __n, const _Tp& __t)
 157     {
 158       while (__n--)
 159         *__a++ = __t;
 160     }
 161
 162   // fill strided array __a[<__n-1 : __s>] with __t
 163   template<typename _Tp>
 164     inline void
 165     __valarray_fill(_Tp* __restrict__ __a, size_t __n,
 166                     size_t __s, const _Tp& __t)
 167     {
 168       for (size_t __i = 0; __i < __n; ++__i, __a += __s)
 169         *__a = __t;
 170     }
 171
 172   // fill indirect array __a[__i[<__n>]] with __i
 173   template<typename _Tp>
 174     inline void
 175     __valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i,
 176                     size_t __n, const _Tp& __t)
 177     {
 178       for (size_t __j = 0; __j < __n; ++__j, ++__i)
 179         __a[*__i] = __t;
 180     }
 181
 182   // copy plain array __a[<__n>] in __b[<__n>]
 183   // For non-fundamental types, it is wrong to say 'memcpy()'
 184   template<typename _Tp, bool>
 185     struct _Array_copier
 186     {
 187       inline static void
 188       _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
 189       {
 190         while(__n--)
 191           *__b++ = *__a++;
 192       }
 193     };
 194
 195   template<typename _Tp>
 196     struct _Array_copier<_Tp, true>
 197     {
 198       inline static void
 199       _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b)
 200       {
 201         if (__n != 0)
 202           __builtin_memcpy(__b, __a, __n * sizeof (_Tp));
 203       }
 204     };
 205
 206   // Copy a plain array __a[<__n>] into a play array __b[<>]
 207   template<typename _Tp>
 208     inline void
 209     __valarray_copy(const _Tp* __restrict__ __a, size_t __n,
 210                     _Tp* __restrict__ __b)
 211     {
 212       _Array_copier<_Tp, __is_trivial(_Tp)>::_S_do_it(__a, __n, __b);
 213     }
 214
 215   // Copy strided array __a[<__n : __s>] in plain __b[<__n>]
 216   template<typename _Tp>
 217     inline void
 218     __valarray_copy(const _Tp* __restrict__ __a, size_t __n, size_t __s,
 219                     _Tp* __restrict__ __b)
 220     {
 221       for (size_t __i = 0; __i < __n; ++__i, ++__b, __a += __s)
 222         *__b = *__a;
 223     }
 224
 225   // Copy a plain array  __a[<__n>] into a strided array __b[<__n : __s>]
 226   template<typename _Tp>
 227     inline void
 228     __valarray_copy(const _Tp* __restrict__ __a, _Tp* __restrict__ __b,
 229                     size_t __n, size_t __s)
 230     {
 231       for (size_t __i = 0; __i < __n; ++__i, ++__a, __b += __s)
 232         *__b = *__a;
 233     }
 234
 235   // Copy strided array __src[<__n : __s1>] into another
 236   // strided array __dst[< : __s2>].  Their sizes must match.
 237   template<typename _Tp>
 238     inline void
 239     __valarray_copy(const _Tp* __restrict__ __src, size_t __n, size_t __s1,
 240                     _Tp* __restrict__ __dst, size_t __s2)
 241     {
 242       for (size_t __i = 0; __i < __n; ++__i)
 243         __dst[__i * __s2] = __src[__i * __s1];
 244     }
 245
 246   // Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
 247   template<typename _Tp>
 248     inline void
 249     __valarray_copy(const _Tp* __restrict__ __a,
 250                     const size_t* __restrict__ __i,
 251                     _Tp* __restrict__ __b, size_t __n)
 252     {
 253       for (size_t __j = 0; __j < __n; ++__j, ++__b, ++__i)
 254         *__b = __a[*__i];
 255     }
 256
 257   // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]]
 258   template<typename _Tp>
 259     inline void
 260     __valarray_copy(const _Tp* __restrict__ __a, size_t __n,
 261                     _Tp* __restrict__ __b, const size_t* __restrict__ __i)
 262     {
 263       for (size_t __j = 0; __j < __n; ++__j, ++__a, ++__i)
 264         __b[*__i] = *__a;
 265     }
 266
 267   // Copy the __n first elements of an indexed array __src[<__i>] into
 268   // another indexed array __dst[<__j>].
 269   template<typename _Tp>
 270     inline void
 271     __valarray_copy(const _Tp* __restrict__ __src, size_t __n,
 272                     const size_t* __restrict__ __i,
 273                     _Tp* __restrict__ __dst, const size_t* __restrict__ __j)
 274     {
 275       for (size_t __k = 0; __k < __n; ++__k)
 276         __dst[*__j++] = __src[*__i++];
 277     }
 278
 279   //
 280   // Compute the sum of elements in range [__f, __l) which must not be empty.
 281   // This is a naive algorithm.  It suffers from cancelling.
 282   // In the future try to specialize for _Tp = float, double, long double
 283   // using a more accurate algorithm.
 284   //
 285   template<typename _Tp>
 286     inline _Tp
 287     __valarray_sum(const _Tp* __f, const _Tp* __l)
 288     {
 289       _Tp __r = *__f++;
 290       while (__f != __l)
 291         __r += *__f++;
 292       return __r;
 293     }
 294
 295   // Compute the min/max of an array-expression
 296   template<typename _Ta>
 297     inline typename _Ta::value_type
 298     __valarray_min(const _Ta& __a)
 299     {
 300       size_t __s = __a.size();
 301       typedef typename _Ta::value_type _Value_type;
 302       _Value_type __r = __s == 0 ? _Value_type() : __a[0];
 303       for (size_t __i = 1; __i < __s; ++__i)
 304         {
 305           _Value_type __t = __a[__i];
 306           if (__t < __r)
 307             __r = __t;
 308         }
 309       return __r;
 310     }
 311
 312   template<typename _Ta>
 313     inline typename _Ta::value_type
 314     __valarray_max(const _Ta& __a)
 315     {
 316       size_t __s = __a.size();
 317       typedef typename _Ta::value_type _Value_type;
 318       _Value_type __r = __s == 0 ? _Value_type() : __a[0];
 319       for (size_t __i = 1; __i < __s; ++__i)
 320         {
 321           _Value_type __t = __a[__i];
 322           if (__t > __r)
 323             __r = __t;
 324         }
 325       return __r;
 326     }
 327
 328   //
 329   // Helper class _Array, first layer of valarray abstraction.
 330   // All operations on valarray should be forwarded to this class
 331   // whenever possible. -- gdr
 332   //
 333
 334   template<typename _Tp>
 335     struct _Array
 336     {
 337       explicit _Array(_Tp* const __restrict__);
 338       explicit _Array(const valarray<_Tp>&);
 339       _Array(const _Tp* __restrict__, size_t);
 340
 341       _Tp* begin() const;
 342
 343       _Tp* const __restrict__ _M_data;
 344     };
 345
 346
 347   // Copy-construct plain array __b[<__n>] from indexed array __a[__i[<__n>]]
 348   template<typename _Tp>
 349     inline void
 350     __valarray_copy_construct(_Array<_Tp> __a, _Array<size_t> __i,
 351                               _Array<_Tp> __b, size_t __n)
 352     { std::__valarray_copy_construct(__a._M_data, __i._M_data,
 353                                      __b._M_data, __n); }
 354
 355   // Copy-construct plain array __b[<__n>] from strided array __a[<__n : __s>]
 356   template<typename _Tp>
 357     inline void
 358     __valarray_copy_construct(_Array<_Tp> __a, size_t __n, size_t __s,
 359                               _Array<_Tp> __b)
 360     { std::__valarray_copy_construct(__a._M_data, __n, __s, __b._M_data); }
 361
 362   template<typename _Tp>
 363     inline void
 364     __valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
 365     { std::__valarray_fill(__a._M_data, __n, __t); }
 366
 367   template<typename _Tp>
 368     inline void
 369     __valarray_fill(_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t)
 370     { std::__valarray_fill(__a._M_data, __n, __s, __t); }
 371
 372   template<typename _Tp>
 373     inline void
 374     __valarray_fill(_Array<_Tp> __a, _Array<size_t> __i,
 375                     size_t __n, const _Tp& __t)
 376     { std::__valarray_fill(__a._M_data, __i._M_data, __n, __t); }
 377
 378   // Copy a plain array __a[<__n>] into a play array __b[<>]
 379   template<typename _Tp>
 380     inline void
 381     __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
 382     { std::__valarray_copy(__a._M_data, __n, __b._M_data); }
 383
 384   // Copy strided array __a[<__n : __s>] in plain __b[<__n>]
 385   template<typename _Tp>
 386     inline void
 387     __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
 388     { std::__valarray_copy(__a._M_data, __n, __s, __b._M_data); }
 389
 390   // Copy a plain array  __a[<__n>] into a strided array __b[<__n : __s>]
 391   template<typename _Tp>
 392     inline void
 393     __valarray_copy(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s)
 394     { __valarray_copy(__a._M_data, __b._M_data, __n, __s); }
 395
 396   // Copy strided array __src[<__n : __s1>] into another
 397   // strided array __dst[< : __s2>].  Their sizes must match.
 398   template<typename _Tp>
 399     inline void
 400     __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1,
 401                     _Array<_Tp> __b, size_t __s2)
 402     { std::__valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); }
 403
 404   // Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>]
 405   template<typename _Tp>
 406     inline void
 407     __valarray_copy(_Array<_Tp> __a, _Array<size_t> __i,
 408                     _Array<_Tp> __b, size_t __n)
 409     { std::__valarray_copy(__a._M_data, __i._M_data, __b._M_data, __n); }
 410
 411   // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]]
 412   template<typename _Tp>
 413     inline void
 414     __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
 415                     _Array<size_t> __i)
 416     { std::__valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); }
 417
 418   // Copy the __n first elements of an indexed array __src[<__i>] into
 419   // another indexed array __dst[<__j>].
 420   template<typename _Tp>
 421     inline void
 422     __valarray_copy(_Array<_Tp> __src, size_t __n, _Array<size_t> __i,
 423                     _Array<_Tp> __dst, _Array<size_t> __j)
 424     {
 425       std::__valarray_copy(__src._M_data, __n, __i._M_data,
 426                     __dst._M_data, __j._M_data);
 427     }
 428
 429   template<typename _Tp>
 430     inline
 431     _Array<_Tp>::_Array(_Tp* const __restrict__ __p)
 432     : _M_data (__p) {}
 433
 434   template<typename _Tp>
 435     inline
 436     _Array<_Tp>::_Array(const valarray<_Tp>& __v)
 437     : _M_data (__v._M_data) {}
 438
 439   template<typename _Tp>
 440     inline
 441     _Array<_Tp>::_Array(const _Tp* __restrict__ __b, size_t __s)
 442     : _M_data(__valarray_get_storage<_Tp>(__s))
 443     { std::__valarray_copy_construct(__b, __s, _M_data); }
 444
 445   template<typename _Tp>
 446     inline _Tp*
 447     _Array<_Tp>::begin () const
 448     { return _M_data; }
 449
 450 #define _DEFINE_ARRAY_FUNCTION(_Op, _Name)                              \
 451   template<typename _Tp>                                                \
 452     inline void                                                         \
 453     _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, const _Tp& __t) \
 454     {                                                                   \
 455       for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p)      \
 456         *__p _Op##= __t;                                                \
 457     }                                                                   \
 458                                                                         \
 459   template<typename _Tp>                                                \
 460     inline void                                                         \
 461     _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) \
 462     {                                                                   \
 463       _Tp* __p = __a._M_data;                                           \
 464       for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) \
 465         *__p _Op##= *__q;                                               \
 466     }                                                                   \
 467                                                                         \
 468   template<typename _Tp, class _Dom>                                    \
 469     void                                                                \
 470     _Array_augmented_##_Name(_Array<_Tp> __a,                           \
 471                              const _Expr<_Dom, _Tp>& __e, size_t __n)   \
 472     {                                                                   \
 473       _Tp* __p(__a._M_data);                                            \
 474       for (size_t __i = 0; __i < __n; ++__i, ++__p)                     \
 475         *__p _Op##= __e[__i];                                           \
 476     }                                                                   \
 477                                                                         \
 478   template<typename _Tp>                                                \
 479     inline void                                                         \
 480     _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, size_t __s,   \
 481                              _Array<_Tp> __b)                           \
 482     {                                                                   \
 483       _Tp* __q(__b._M_data);                                            \
 484       for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n;       \
 485            __p += __s, ++__q)                                           \
 486         *__p _Op##= *__q;                                               \
 487     }                                                                   \
 488                                                                         \
 489   template<typename _Tp>                                                \
 490     inline void                                                         \
 491     _Array_augmented_##_Name(_Array<_Tp> __a, _Array<_Tp> __b,          \
 492                              size_t __n, size_t __s)                    \
 493     {                                                                   \
 494       _Tp* __q(__b._M_data);                                            \
 495       for (_Tp* __p = __a._M_data; __p < __a._M_data + __n;             \
 496            ++__p, __q += __s)                                           \
 497         *__p _Op##= *__q;                                               \
 498     }                                                                   \
 499                                                                         \
 500   template<typename _Tp, class _Dom>                                    \
 501     void                                                                \
 502     _Array_augmented_##_Name(_Array<_Tp> __a, size_t __s,               \
 503                              const _Expr<_Dom, _Tp>& __e, size_t __n)   \
 504     {                                                                   \
 505       _Tp* __p(__a._M_data);                                            \
 506       for (size_t __i = 0; __i < __n; ++__i, __p += __s)                \
 507         *__p _Op##= __e[__i];                                           \
 508     }                                                                   \
 509                                                                         \
 510   template<typename _Tp>                                                \
 511     inline void                                                         \
 512     _Array_augmented_##_Name(_Array<_Tp> __a, _Array<size_t> __i,       \
 513                              _Array<_Tp> __b, size_t __n)               \
 514     {                                                                   \
 515       _Tp* __q(__b._M_data);                                            \
 516       for (size_t* __j = __i._M_data; __j < __i._M_data + __n;          \
 517            ++__j, ++__q)                                                \
 518         __a._M_data[*__j] _Op##= *__q;                                  \
 519     }                                                                   \
 520                                                                         \
 521   template<typename _Tp>                                                \
 522     inline void                                                         \
 523     _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n,               \
 524                              _Array<_Tp> __b, _Array<size_t> __i)       \
 525     {                                                                   \
 526       _Tp* __p(__a._M_data);                                            \
 527       for (size_t* __j = __i._M_data; __j<__i._M_data + __n;            \
 528            ++__j, ++__p)                                                \
 529         *__p _Op##= __b._M_data[*__j];                                  \
 530     }                                                                   \
 531                                                                         \
 532   template<typename _Tp, class _Dom>                                    \
 533     void                                                                \
 534     _Array_augmented_##_Name(_Array<_Tp> __a, _Array<size_t> __i,       \
 535                              const _Expr<_Dom, _Tp>& __e, size_t __n)   \
 536     {                                                                   \
 537       size_t* __j(__i._M_data);                                         \
 538       for (size_t __k = 0; __k<__n; ++__k, ++__j)                       \
 539         __a._M_data[*__j] _Op##= __e[__k];                              \
 540     }                                                                   \
 541                                                                         \
 542   template<typename _Tp>                                                \
 543     void                                                                \
 544     _Array_augmented_##_Name(_Array<_Tp> __a, _Array<bool> __m,         \
 545                              _Array<_Tp> __b, size_t __n)               \
 546     {                                                                   \
 547       bool* __ok(__m._M_data);                                          \
 548       _Tp* __p(__a._M_data);                                            \
 549       for (_Tp* __q = __b._M_data; __q < __b._M_data + __n;             \
 550            ++__q, ++__ok, ++__p)                                        \
 551         {                                                               \
 552           while (! *__ok)                                               \
 553             {                                                           \
 554               ++__ok;                                                   \
 555               ++__p;                                                    \
 556             }                                                           \
 557           *__p _Op##= *__q;                                             \
 558         }                                                               \
 559     }                                                                   \
 560                                                                         \
 561   template<typename _Tp>                                                \
 562     void                                                                \
 563     _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n,               \
 564                              _Array<_Tp> __b, _Array<bool> __m)         \
 565     {                                                                   \
 566       bool* __ok(__m._M_data);                                          \
 567       _Tp* __q(__b._M_data);                                            \
 568       for (_Tp* __p = __a._M_data; __p < __a._M_data + __n;             \
 569            ++__p, ++__ok, ++__q)                                        \
 570         {                                                               \
 571           while (! *__ok)                                               \
 572             {                                                           \
 573               ++__ok;                                                   \
 574               ++__q;                                                    \
 575             }                                                           \
 576           *__p _Op##= *__q;                                             \
 577         }                                                               \
 578     }                                                                   \
 579                                                                         \
 580   template<typename _Tp, class _Dom>                                    \
 581     void                                                                \
 582     _Array_augmented_##_Name(_Array<_Tp> __a, _Array<bool> __m,         \
 583                              const _Expr<_Dom, _Tp>& __e, size_t __n)   \
 584     {                                                                   \
 585       bool* __ok(__m._M_data);                                          \
 586       _Tp* __p(__a._M_data);                                            \
 587       for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p)             \
 588         {                                                               \
 589           while (! *__ok)                                               \
 590             {                                                           \
 591               ++__ok;                                                   \
 592               ++__p;                                                    \
 593             }                                                           \
 594           *__p _Op##= __e[__i];                                         \
 595         }                                                               \
 596     }
 597
 598    _DEFINE_ARRAY_FUNCTION(+, __plus)
 599    _DEFINE_ARRAY_FUNCTION(-, __minus)
 600    _DEFINE_ARRAY_FUNCTION(*, __multiplies)
 601    _DEFINE_ARRAY_FUNCTION(/, __divides)
 602    _DEFINE_ARRAY_FUNCTION(%, __modulus)
 603    _DEFINE_ARRAY_FUNCTION(^, __bitwise_xor)
 604    _DEFINE_ARRAY_FUNCTION(|, __bitwise_or)
 605    _DEFINE_ARRAY_FUNCTION(&, __bitwise_and)
 606    _DEFINE_ARRAY_FUNCTION(<<, __shift_left)
 607    _DEFINE_ARRAY_FUNCTION(>>, __shift_right)
 608
 609 #undef _DEFINE_ARRAY_FUNCTION
 610
 611 _GLIBCXX_END_NAMESPACE_VERSION
 612 } // namespace
 613
 614 # include <bits/valarray_array.tcc>
 615
 616 #endif /* _ARRAY_H */