1 // The template and inlines for the -*- C++ -*- internal _Array helper class.
2
3 // Copyright (C) 1997, 1998, 1999, 2003, 2005 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 2, 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 // You should have received a copy of the GNU General Public License along
17 // with this library; see the file COPYING. If not, write to the Free
18 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19 // USA.
20
21 // As a special exception, you may use this file as part of a free software
22 // library without restriction. Specifically, if other files instantiate
23 // templates or use macros or inline functions from this file, or you compile
24 // this file and link it with other files to produce an executable, this
25 // file does not by itself cause the resulting executable to be covered by
26 // the GNU General Public License. This exception does not however
27 // invalidate any other reasons why the executable file might be covered by
28 // the GNU General Public License.
29
30 /** @file valarray_array.tcc
31 * This is an internal header file, included by other library headers.
32 * You should not attempt to use it directly.
33 */
34
35 // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
36
37 #ifndef _VALARRAY_ARRAY_TCC
38 #define _VALARRAY_ARRAY_TCC 1
39
_GLIBCXX_BEGIN_NAMESPACE(std)40 _GLIBCXX_BEGIN_NAMESPACE(std)
41
42 template<typename _Tp>
43 void
44 __valarray_fill(_Array<_Tp> __a, size_t __n, _Array<bool> __m,
45 const _Tp& __t)
46 {
47 _Tp* __p = __a._M_data;
48 bool* __ok (__m._M_data);
49 for (size_t __i=0; __i < __n; ++__i, ++__ok, ++__p)
50 {
51 while (!*__ok)
52 {
53 ++__ok;
54 ++__p;
55 }
56 *__p = __t;
57 }
58 }
59
60 // Copy n elements of a into consecutive elements of b. When m is
61 // false, the corresponding element of a is skipped. m must contain
62 // at least n true elements. a must contain at least n elements and
63 // enough elements to match up with m through the nth true element
64 // of m. I.e. if n is 10, m has 15 elements with 5 false followed
65 // by 10 true, a must have 15 elements.
66 template<typename _Tp>
67 void
__valarray_copy(_Array<_Tp> __a,_Array<bool> __m,_Array<_Tp> __b,size_t __n)68 __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b,
69 size_t __n)
70 {
71 _Tp* __p (__a._M_data);
72 bool* __ok (__m._M_data);
73 for (_Tp* __q = __b._M_data; __q < __b._M_data + __n;
74 ++__q, ++__ok, ++__p)
75 {
76 while (! *__ok)
77 {
78 ++__ok;
79 ++__p;
80 }
81 *__q = *__p;
82 }
83 }
84
85 // Copy n consecutive elements from a into elements of b. Elements
86 // of b are skipped if the corresponding element of m is false. m
87 // must contain at least n true elements. b must have at least as
88 // many elements as the index of the nth true element of m. I.e. if
89 // m has 15 elements with 5 false followed by 10 true, b must have
90 // at least 15 elements.
91 template<typename _Tp>
92 void
__valarray_copy(_Array<_Tp> __a,size_t __n,_Array<_Tp> __b,_Array<bool> __m)93 __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
94 _Array<bool> __m)
95 {
96 _Tp* __q (__b._M_data);
97 bool* __ok (__m._M_data);
98 for (_Tp* __p = __a._M_data; __p < __a._M_data+__n;
99 ++__p, ++__ok, ++__q)
100 {
101 while (! *__ok)
102 {
103 ++__ok;
104 ++__q;
105 }
106 *__q = *__p;
107 }
108 }
109
110 // Copy n elements from a into elements of b. Elements of a are
111 // skipped if the corresponding element of m is false. Elements of
112 // b are skipped if the corresponding element of k is false. m and
113 // k must contain at least n true elements. a and b must have at
114 // least as many elements as the index of the nth true element of m.
115 template<typename _Tp>
116 void
__valarray_copy(_Array<_Tp> __a,_Array<bool> __m,size_t __n,_Array<_Tp> __b,_Array<bool> __k)117 __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, size_t __n,
118 _Array<_Tp> __b, _Array<bool> __k)
119 {
120 _Tp* __p (__a._M_data);
121 _Tp* __q (__b._M_data);
122 bool* __srcok (__m._M_data);
123 bool* __dstok (__k._M_data);
124 for (size_t __i = 0; __i < __n;
125 ++__srcok, ++__p, ++__dstok, ++__q, ++__i)
126 {
127 while (! *__srcok)
128 {
129 ++__srcok;
130 ++__p;
131 }
132 while (! *__dstok)
133 {
134 ++__dstok;
135 ++__q;
136 }
137 *__q = *__p;
138 }
139 }
140
141 // Copy n consecutive elements of e into consecutive elements of a.
142 // I.e. a[i] = e[i].
143 template<typename _Tp, class _Dom>
144 void
__valarray_copy(const _Expr<_Dom,_Tp> & __e,size_t __n,_Array<_Tp> __a)145 __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a)
146 {
147 _Tp* __p (__a._M_data);
148 for (size_t __i = 0; __i < __n; ++__i, ++__p)
149 *__p = __e[__i];
150 }
151
152 // Copy n consecutive elements of e into elements of a using stride
153 // s. I.e., a[0] = e[0], a[s] = e[1], a[2*s] = e[2].
154 template<typename _Tp, class _Dom>
155 void
__valarray_copy(const _Expr<_Dom,_Tp> & __e,size_t __n,_Array<_Tp> __a,size_t __s)156 __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
157 _Array<_Tp> __a, size_t __s)
158 {
159 _Tp* __p (__a._M_data);
160 for (size_t __i = 0; __i < __n; ++__i, __p += __s)
161 *__p = __e[__i];
162 }
163
164 // Copy n consecutive elements of e into elements of a indexed by
165 // contents of i. I.e., a[i[0]] = e[0].
166 template<typename _Tp, class _Dom>
167 void
__valarray_copy(const _Expr<_Dom,_Tp> & __e,size_t __n,_Array<_Tp> __a,_Array<size_t> __i)168 __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
169 _Array<_Tp> __a, _Array<size_t> __i)
170 {
171 size_t* __j (__i._M_data);
172 for (size_t __k = 0; __k < __n; ++__k, ++__j)
173 __a._M_data[*__j] = __e[__k];
174 }
175
176 // Copy n elements of e indexed by contents of f into elements of a
177 // indexed by contents of i. I.e., a[i[0]] = e[f[0]].
178 template<typename _Tp>
179 void
__valarray_copy(_Array<_Tp> __e,_Array<size_t> __f,size_t __n,_Array<_Tp> __a,_Array<size_t> __i)180 __valarray_copy(_Array<_Tp> __e, _Array<size_t> __f,
181 size_t __n,
182 _Array<_Tp> __a, _Array<size_t> __i)
183 {
184 size_t* __g (__f._M_data);
185 size_t* __j (__i._M_data);
186 for (size_t __k = 0; __k < __n; ++__k, ++__j, ++__g)
187 __a._M_data[*__j] = __e._M_data[*__g];
188 }
189
190 // Copy n consecutive elements of e into elements of a. Elements of
191 // a are skipped if the corresponding element of m is false. m must
192 // have at least n true elements and a must have at least as many
193 // elements as the index of the nth true element of m. I.e. if m
194 // has 5 false followed by 10 true elements and n == 10, a must have
195 // at least 15 elements.
196 template<typename _Tp, class _Dom>
197 void
__valarray_copy(const _Expr<_Dom,_Tp> & __e,size_t __n,_Array<_Tp> __a,_Array<bool> __m)198 __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
199 _Array<_Tp> __a, _Array<bool> __m)
200 {
201 bool* __ok (__m._M_data);
202 _Tp* __p (__a._M_data);
203 for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p)
204 {
205 while (! *__ok)
206 {
207 ++__ok;
208 ++__p;
209 }
210 *__p = __e[__i];
211 }
212 }
213
214
215 template<typename _Tp, class _Dom>
216 void
__valarray_copy_construct(const _Expr<_Dom,_Tp> & __e,size_t __n,_Array<_Tp> __a)217 __valarray_copy_construct(const _Expr<_Dom, _Tp>& __e, size_t __n,
218 _Array<_Tp> __a)
219 {
220 _Tp* __p (__a._M_data);
221 for (size_t __i = 0; __i < __n; ++__i, ++__p)
222 new (__p) _Tp(__e[__i]);
223 }
224
225
226 template<typename _Tp>
227 void
__valarray_copy_construct(_Array<_Tp> __a,_Array<bool> __m,_Array<_Tp> __b,size_t __n)228 __valarray_copy_construct(_Array<_Tp> __a, _Array<bool> __m,
229 _Array<_Tp> __b, size_t __n)
230 {
231 _Tp* __p (__a._M_data);
232 bool* __ok (__m._M_data);
233 for (_Tp* __q = __b._M_data; __q < __b._M_data+__n; ++__q, ++__ok, ++__p)
234 {
235 while (! *__ok)
236 {
237 ++__ok;
238 ++__p;
239 }
240 new (__q) _Tp(*__p);
241 }
242 }
243
244 _GLIBCXX_END_NAMESPACE
245
246 #endif /* _VALARRAY_ARRAY_TCC */
247