00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033 #ifndef _VALARRAY_ARRAY_TCC
00034 #define _VALARRAY_ARRAY_TCC 1
00035
00036 namespace std _GLIBCXX_VISIBILITY(default)
00037 {
00038 _GLIBCXX_BEGIN_NAMESPACE_VERSION
00039
00040 template<typename _Tp>
00041 void
00042 __valarray_fill(_Array<_Tp> __a, size_t __n, _Array<bool> __m,
00043 const _Tp& __t)
00044 {
00045 _Tp* __p = __a._M_data;
00046 bool* __ok (__m._M_data);
00047 for (size_t __i=0; __i < __n; ++__i, ++__ok, ++__p)
00048 {
00049 while (!*__ok)
00050 {
00051 ++__ok;
00052 ++__p;
00053 }
00054 *__p = __t;
00055 }
00056 }
00057
00058
00059
00060
00061
00062
00063
00064 template<typename _Tp>
00065 void
00066 __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b,
00067 size_t __n)
00068 {
00069 _Tp* __p (__a._M_data);
00070 bool* __ok (__m._M_data);
00071 for (_Tp* __q = __b._M_data; __q < __b._M_data + __n;
00072 ++__q, ++__ok, ++__p)
00073 {
00074 while (! *__ok)
00075 {
00076 ++__ok;
00077 ++__p;
00078 }
00079 *__q = *__p;
00080 }
00081 }
00082
00083
00084
00085
00086
00087
00088
00089 template<typename _Tp>
00090 void
00091 __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
00092 _Array<bool> __m)
00093 {
00094 _Tp* __q (__b._M_data);
00095 bool* __ok (__m._M_data);
00096 for (_Tp* __p = __a._M_data; __p < __a._M_data+__n;
00097 ++__p, ++__ok, ++__q)
00098 {
00099 while (! *__ok)
00100 {
00101 ++__ok;
00102 ++__q;
00103 }
00104 *__q = *__p;
00105 }
00106 }
00107
00108
00109
00110
00111
00112
00113 template<typename _Tp>
00114 void
00115 __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, size_t __n,
00116 _Array<_Tp> __b, _Array<bool> __k)
00117 {
00118 _Tp* __p (__a._M_data);
00119 _Tp* __q (__b._M_data);
00120 bool* __srcok (__m._M_data);
00121 bool* __dstok (__k._M_data);
00122 for (size_t __i = 0; __i < __n;
00123 ++__srcok, ++__p, ++__dstok, ++__q, ++__i)
00124 {
00125 while (! *__srcok)
00126 {
00127 ++__srcok;
00128 ++__p;
00129 }
00130 while (! *__dstok)
00131 {
00132 ++__dstok;
00133 ++__q;
00134 }
00135 *__q = *__p;
00136 }
00137 }
00138
00139
00140
00141 template<typename _Tp, class _Dom>
00142 void
00143 __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a)
00144 {
00145 _Tp* __p (__a._M_data);
00146 for (size_t __i = 0; __i < __n; ++__i, ++__p)
00147 *__p = __e[__i];
00148 }
00149
00150
00151
00152 template<typename _Tp, class _Dom>
00153 void
00154 __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
00155 _Array<_Tp> __a, size_t __s)
00156 {
00157 _Tp* __p (__a._M_data);
00158 for (size_t __i = 0; __i < __n; ++__i, __p += __s)
00159 *__p = __e[__i];
00160 }
00161
00162
00163
00164 template<typename _Tp, class _Dom>
00165 void
00166 __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
00167 _Array<_Tp> __a, _Array<size_t> __i)
00168 {
00169 size_t* __j (__i._M_data);
00170 for (size_t __k = 0; __k < __n; ++__k, ++__j)
00171 __a._M_data[*__j] = __e[__k];
00172 }
00173
00174
00175
00176 template<typename _Tp>
00177 void
00178 __valarray_copy(_Array<_Tp> __e, _Array<size_t> __f,
00179 size_t __n,
00180 _Array<_Tp> __a, _Array<size_t> __i)
00181 {
00182 size_t* __g (__f._M_data);
00183 size_t* __j (__i._M_data);
00184 for (size_t __k = 0; __k < __n; ++__k, ++__j, ++__g)
00185 __a._M_data[*__j] = __e._M_data[*__g];
00186 }
00187
00188
00189
00190
00191
00192
00193
00194 template<typename _Tp, class _Dom>
00195 void
00196 __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
00197 _Array<_Tp> __a, _Array<bool> __m)
00198 {
00199 bool* __ok (__m._M_data);
00200 _Tp* __p (__a._M_data);
00201 for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p)
00202 {
00203 while (! *__ok)
00204 {
00205 ++__ok;
00206 ++__p;
00207 }
00208 *__p = __e[__i];
00209 }
00210 }
00211
00212
00213 template<typename _Tp, class _Dom>
00214 void
00215 __valarray_copy_construct(const _Expr<_Dom, _Tp>& __e, size_t __n,
00216 _Array<_Tp> __a)
00217 {
00218 _Tp* __p (__a._M_data);
00219 for (size_t __i = 0; __i < __n; ++__i, ++__p)
00220 new (__p) _Tp(__e[__i]);
00221 }
00222
00223
00224 template<typename _Tp>
00225 void
00226 __valarray_copy_construct(_Array<_Tp> __a, _Array<bool> __m,
00227 _Array<_Tp> __b, size_t __n)
00228 {
00229 _Tp* __p (__a._M_data);
00230 bool* __ok (__m._M_data);
00231 for (_Tp* __q = __b._M_data; __q < __b._M_data+__n; ++__q, ++__ok, ++__p)
00232 {
00233 while (! *__ok)
00234 {
00235 ++__ok;
00236 ++__p;
00237 }
00238 new (__q) _Tp(*__p);
00239 }
00240 }
00241
00242 _GLIBCXX_END_NAMESPACE_VERSION
00243 }
00244
00245 #endif