Clang Project

include/c++/7/bits/valarray_array.tcc
1// The template and inlines for the -*- C++ -*- internal _Array helper 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 bits/valarray_array.tcc
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_TCC
33#define _VALARRAY_ARRAY_TCC 1
34
35namespace std _GLIBCXX_VISIBILITY(default)
36{
37_GLIBCXX_BEGIN_NAMESPACE_VERSION
38
39  template<typename _Tp>
40    void
41    __valarray_fill(_Array<_Tp> __a, size_t __n, _Array<bool> __m,
42     const _Tp& __t)
43    {
44      _Tp* __p = __a._M_data;
45      bool* __ok (__m._M_data);
46      for (size_t __i=0; __i < __n; ++__i, ++__ok, ++__p)
47 {
48   while (!*__ok)
49   {
50     ++__ok;
51     ++__p;
52   }
53   *__p = __t;
54 }
55    }
56
57  // Copy n elements of a into consecutive elements of b.  When m is
58  // false, the corresponding element of a is skipped.  m must contain
59  // at least n true elements.  a must contain at least n elements and
60  // enough elements to match up with m through the nth true element
61  // of m.  I.e.  if n is 10, m has 15 elements with 5 false followed
62  // by 10 true, a must have 15 elements.
63  template<typename _Tp>
64    void
65    __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b,
66     size_t __n)
67    {
68      _Tp* __p (__a._M_data);
69      bool* __ok (__m._M_data);
70      for (_Tp* __q = __b._M_data; __q < __b._M_data + __n;
71    ++__q, ++__ok, ++__p)
72 {
73   while (! *__ok)
74     {
75       ++__ok;
76       ++__p;
77     }
78   *__q = *__p;
79 }
80    }
81
82  // Copy n consecutive elements from a into elements of b.  Elements
83  // of b are skipped if the corresponding element of m is false.  m
84  // must contain at least n true elements.  b must have at least as
85  // many elements as the index of the nth true element of m.  I.e. if
86  // m has 15 elements with 5 false followed by 10 true, b must have
87  // at least 15 elements.
88  template<typename _Tp>
89    void
90    __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
91     _Array<bool> __m)
92    {
93      _Tp* __q (__b._M_data);
94      bool* __ok (__m._M_data);
95      for (_Tp* __p = __a._M_data; __p < __a._M_data+__n;
96    ++__p, ++__ok, ++__q)
97 {
98   while (! *__ok)
99     {
100       ++__ok;
101       ++__q;
102     }
103   *__q = *__p;
104 }
105    }
106
107  // Copy n elements from a into elements of b.  Elements of a are
108  // skipped if the corresponding element of m is false.  Elements of
109  // b are skipped if the corresponding element of k is false.  m and
110  // k must contain at least n true elements.  a and b must have at
111  // least as many elements as the index of the nth true element of m.
112  template<typename _Tp>
113    void
114    __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, size_t __n,
115     _Array<_Tp> __b, _Array<bool> __k)
116    {
117      _Tp* __p (__a._M_data);
118      _Tp* __q (__b._M_data);
119      bool* __srcok (__m._M_data);
120      bool* __dstok (__k._M_data);
121      for (size_t __i = 0; __i < __n;
122    ++__srcok, ++__p, ++__dstok, ++__q, ++__i)
123 {
124   while (! *__srcok)
125     {
126       ++__srcok;
127       ++__p;
128     }
129   while (! *__dstok) 
130     {
131       ++__dstok;
132       ++__q;
133     }
134   *__q = *__p;
135 }
136    }
137
138  // Copy n consecutive elements of e into consecutive elements of a.
139  // I.e. a[i] = e[i].
140  template<typename _Tp, class _Dom>
141    void
142    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a)
143    {
144      _Tp* __p (__a._M_data);
145      for (size_t __i = 0; __i < __n; ++__i, ++__p)
146 *__p = __e[__i];
147    }
148
149  // Copy n consecutive elements of e into elements of a using stride
150  // s.  I.e., a[0] = e[0], a[s] = e[1], a[2*s] = e[2].
151  template<typename _Tp, class _Dom>
152    void
153    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
154      _Array<_Tp> __a, size_t __s)
155    {
156      _Tp* __p (__a._M_data);
157      for (size_t __i = 0; __i < __n; ++__i, __p += __s)
158 *__p = __e[__i];
159    }
160
161  // Copy n consecutive elements of e into elements of a indexed by
162  // contents of i.  I.e., a[i[0]] = e[0].
163  template<typename _Tp, class _Dom>
164    void
165    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
166     _Array<_Tp> __a, _Array<size_t> __i)
167    {
168      size_t* __j (__i._M_data);
169      for (size_t __k = 0; __k < __n; ++__k, ++__j)
170 __a._M_data[*__j] = __e[__k];
171    }
172
173  // Copy n elements of e indexed by contents of f into elements of a
174  // indexed by contents of i.  I.e., a[i[0]] = e[f[0]].
175  template<typename _Tp>
176    void
177    __valarray_copy(_Array<_Tp> __e, _Array<size_t> __f,
178     size_t __n, 
179     _Array<_Tp> __a, _Array<size_t> __i)
180    {
181      size_t* __g (__f._M_data);
182      size_t* __j (__i._M_data);
183      for (size_t __k = 0; __k < __n; ++__k, ++__j, ++__g) 
184 __a._M_data[*__j] = __e._M_data[*__g];
185    }
186
187  // Copy n consecutive elements of e into elements of a.  Elements of
188  // a are skipped if the corresponding element of m is false.  m must
189  // have at least n true elements and a must have at least as many
190  // elements as the index of the nth true element of m.  I.e. if m
191  // has 5 false followed by 10 true elements and n == 10, a must have
192  // at least 15 elements.
193  template<typename _Tp, class _Dom>
194    void
195    __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
196     _Array<_Tp> __a, _Array<bool> __m)
197    {
198      bool* __ok (__m._M_data);
199      _Tp* __p (__a._M_data);
200      for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p)
201 {
202   while (! *__ok)
203     {
204       ++__ok;
205       ++__p;
206     }
207   *__p = __e[__i];
208 }
209    }
210
211
212  template<typename _Tp, class _Dom>
213    void
214    __valarray_copy_construct(const _Expr<_Dom, _Tp>& __e, size_t __n,
215       _Array<_Tp> __a)
216    {
217      _Tp* __p (__a._M_data);
218      for (size_t __i = 0; __i < __n; ++__i, ++__p)
219 new (__p) _Tp(__e[__i]);
220    }
221
222
223  template<typename _Tp>
224    void
225    __valarray_copy_construct(_Array<_Tp> __a, _Array<bool> __m,
226       _Array<_Tp> __b, size_t __n)
227    {
228      _Tp* __p (__a._M_data);
229      bool* __ok (__m._M_data);
230      for (_Tp* __q = __b._M_data; __q < __b._M_data+__n; ++__q, ++__ok, ++__p)
231 {
232   while (! *__ok)
233     {
234       ++__ok;
235       ++__p;
236     }
237   new (__q) _Tp(*__p);
238 }
239    }
240
241_GLIBCXX_END_NAMESPACE_VERSION
242} // namespace
243
244#endif /* _VALARRAY_ARRAY_TCC */
245
CodeThinker, Enjoy your reading code