valarray_array.tcc

Go to the documentation of this file.
00001 // The template and inlines for the -*- C++ -*- internal _Array helper class.
00002 
00003 // Copyright (C) 1997, 1998, 1999, 2003, 2005, 2009 Free Software Foundation, Inc.
00004 //
00005 // This file is part of the GNU ISO C++ Library.  This library is free
00006 // software; you can redistribute it and/or modify it under the
00007 // terms of the GNU General Public License as published by the
00008 // Free Software Foundation; either version 3, or (at your option)
00009 // any later version.
00010 
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 // GNU General Public License for more details.
00015 
00016 // Under Section 7 of GPL version 3, you are granted additional
00017 // permissions described in the GCC Runtime Library Exception, version
00018 // 3.1, as published by the Free Software Foundation.
00019 
00020 // You should have received a copy of the GNU General Public License and
00021 // a copy of the GCC Runtime Library Exception along with this program;
00022 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00023 // <http://www.gnu.org/licenses/>.
00024 
00025 /** @file valarray_array.tcc
00026  *  This is an internal header file, included by other library headers.
00027  *  You should not attempt to use it directly.
00028  */
00029 
00030 // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
00031 
00032 #ifndef _VALARRAY_ARRAY_TCC
00033 #define _VALARRAY_ARRAY_TCC 1
00034 
00035 _GLIBCXX_BEGIN_NAMESPACE(std)
00036 
00037   template<typename _Tp>
00038     void
00039     __valarray_fill(_Array<_Tp> __a, size_t __n, _Array<bool> __m,
00040             const _Tp& __t)
00041     {
00042       _Tp* __p = __a._M_data;
00043       bool* __ok (__m._M_data);
00044       for (size_t __i=0; __i < __n; ++__i, ++__ok, ++__p)
00045     {
00046       while (!*__ok)
00047       {
00048         ++__ok;
00049         ++__p;
00050       }
00051       *__p = __t;
00052     }
00053     }
00054 
00055   // Copy n elements of a into consecutive elements of b.  When m is
00056   // false, the corresponding element of a is skipped.  m must contain
00057   // at least n true elements.  a must contain at least n elements and
00058   // enough elements to match up with m through the nth true element
00059   // of m.  I.e.  if n is 10, m has 15 elements with 5 false followed
00060   // by 10 true, a must have 15 elements.
00061   template<typename _Tp>
00062     void
00063     __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b,
00064             size_t __n)
00065     {
00066       _Tp* __p (__a._M_data);
00067       bool* __ok (__m._M_data);
00068       for (_Tp* __q = __b._M_data; __q < __b._M_data + __n;
00069        ++__q, ++__ok, ++__p)
00070     {
00071       while (! *__ok)
00072         {
00073           ++__ok;
00074           ++__p;
00075         }
00076       *__q = *__p;
00077     }
00078     }
00079 
00080   // Copy n consecutive elements from a into elements of b.  Elements
00081   // of b are skipped if the corresponding element of m is false.  m
00082   // must contain at least n true elements.  b must have at least as
00083   // many elements as the index of the nth true element of m.  I.e. if
00084   // m has 15 elements with 5 false followed by 10 true, b must have
00085   // at least 15 elements.
00086   template<typename _Tp>
00087     void
00088     __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
00089             _Array<bool> __m)
00090     {
00091       _Tp* __q (__b._M_data);
00092       bool* __ok (__m._M_data);
00093       for (_Tp* __p = __a._M_data; __p < __a._M_data+__n;
00094        ++__p, ++__ok, ++__q)
00095     {
00096       while (! *__ok)
00097         {
00098           ++__ok;
00099           ++__q;
00100         }
00101       *__q = *__p;
00102     }
00103     }
00104 
00105   // Copy n elements from a into elements of b.  Elements of a are
00106   // skipped if the corresponding element of m is false.  Elements of
00107   // b are skipped if the corresponding element of k is false.  m and
00108   // k must contain at least n true elements.  a and b must have at
00109   // least as many elements as the index of the nth true element of m.
00110   template<typename _Tp>
00111     void
00112     __valarray_copy(_Array<_Tp> __a, _Array<bool> __m, size_t __n,
00113             _Array<_Tp> __b, _Array<bool> __k)
00114     {
00115       _Tp* __p (__a._M_data);
00116       _Tp* __q (__b._M_data);
00117       bool* __srcok (__m._M_data);
00118       bool* __dstok (__k._M_data);
00119       for (size_t __i = 0; __i < __n;
00120        ++__srcok, ++__p, ++__dstok, ++__q, ++__i)
00121     {
00122       while (! *__srcok)
00123         {
00124           ++__srcok;
00125           ++__p;
00126         }
00127       while (! *__dstok) 
00128         {
00129           ++__dstok;
00130           ++__q;
00131         }
00132       *__q = *__p;
00133     }
00134     }
00135 
00136   // Copy n consecutive elements of e into consecutive elements of a.
00137   // I.e. a[i] = e[i].
00138   template<typename _Tp, class _Dom>
00139     void
00140     __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a)
00141     {
00142       _Tp* __p (__a._M_data);
00143       for (size_t __i = 0; __i < __n; ++__i, ++__p)
00144     *__p = __e[__i];
00145     }
00146 
00147   // Copy n consecutive elements of e into elements of a using stride
00148   // s.  I.e., a[0] = e[0], a[s] = e[1], a[2*s] = e[2].
00149   template<typename _Tp, class _Dom>
00150     void
00151     __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
00152              _Array<_Tp> __a, size_t __s)
00153     {
00154       _Tp* __p (__a._M_data);
00155       for (size_t __i = 0; __i < __n; ++__i, __p += __s)
00156     *__p = __e[__i];
00157     }
00158 
00159   // Copy n consecutive elements of e into elements of a indexed by
00160   // contents of i.  I.e., a[i[0]] = e[0].
00161   template<typename _Tp, class _Dom>
00162     void
00163     __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
00164             _Array<_Tp> __a, _Array<size_t> __i)
00165     {
00166       size_t* __j (__i._M_data);
00167       for (size_t __k = 0; __k < __n; ++__k, ++__j)
00168     __a._M_data[*__j] = __e[__k];
00169     }
00170 
00171   // Copy n elements of e indexed by contents of f into elements of a
00172   // indexed by contents of i.  I.e., a[i[0]] = e[f[0]].
00173   template<typename _Tp>
00174     void
00175     __valarray_copy(_Array<_Tp> __e, _Array<size_t> __f,
00176             size_t __n, 
00177             _Array<_Tp> __a, _Array<size_t> __i)
00178     {
00179       size_t* __g (__f._M_data);
00180       size_t* __j (__i._M_data);
00181       for (size_t __k = 0; __k < __n; ++__k, ++__j, ++__g) 
00182     __a._M_data[*__j] = __e._M_data[*__g];
00183     }
00184 
00185   // Copy n consecutive elements of e into elements of a.  Elements of
00186   // a are skipped if the corresponding element of m is false.  m must
00187   // have at least n true elements and a must have at least as many
00188   // elements as the index of the nth true element of m.  I.e. if m
00189   // has 5 false followed by 10 true elements and n == 10, a must have
00190   // at least 15 elements.
00191   template<typename _Tp, class _Dom>
00192     void
00193     __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n,
00194             _Array<_Tp> __a, _Array<bool> __m)
00195     {
00196       bool* __ok (__m._M_data);
00197       _Tp* __p (__a._M_data);
00198       for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p)
00199     {
00200       while (! *__ok)
00201         {
00202           ++__ok;
00203           ++__p;
00204         }
00205       *__p = __e[__i];
00206     }
00207     }
00208 
00209 
00210   template<typename _Tp, class _Dom>
00211     void
00212     __valarray_copy_construct(const _Expr<_Dom, _Tp>& __e, size_t __n,
00213                   _Array<_Tp> __a)
00214     {
00215       _Tp* __p (__a._M_data);
00216       for (size_t __i = 0; __i < __n; ++__i, ++__p)
00217     new (__p) _Tp(__e[__i]);
00218     }
00219 
00220 
00221   template<typename _Tp>
00222     void
00223     __valarray_copy_construct(_Array<_Tp> __a, _Array<bool> __m,
00224                   _Array<_Tp> __b, size_t __n)
00225     {
00226       _Tp* __p (__a._M_data);
00227       bool* __ok (__m._M_data);
00228       for (_Tp* __q = __b._M_data; __q < __b._M_data+__n; ++__q, ++__ok, ++__p)
00229     {
00230       while (! *__ok)
00231         {
00232           ++__ok;
00233           ++__p;
00234         }
00235       new (__q) _Tp(*__p);
00236     }
00237     }
00238 
00239 _GLIBCXX_END_NAMESPACE
00240 
00241 #endif /* _VALARRAY_ARRAY_TCC */

Generated on Thu Jul 23 21:16:35 2009 for libstdc++ by  doxygen 1.5.8