libstdc++
valarray_array.tcc
1 // The template and inlines for the -*- C++ -*- internal _Array helper class.
2 
3 // Copyright (C) 1997-2014 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 
35 namespace 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 */