home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 March / PCWorld_2001-03_cd.bin / Software / TemaCD / devc / _SETUP.6 / Group12 / valarray_array.h < prev    next >
C/C++ Source or Header  |  2000-01-21  |  11KB  |  347 lines
  1. // The template and inlines for the -*- C++ -*- internal _Array helper class.
  2.  
  3. // Copyright (C) 1997-1999 Cygnus Solutions
  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, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  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. // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
  31.  
  32. #ifndef __VALARRAY_ARRAY__
  33. #define __VALARRAY_ARRAY__
  34.  
  35. #include <cstdlib>
  36. #include <cstring>
  37.  
  38. extern "C++" {
  39.  
  40. //
  41. // Helper functions on raw pointers
  42. //
  43.  
  44. // fill plain array __a[<__n>] with __t
  45. template<typename _Tp>
  46. inline void
  47. __valarray_fill (_Tp* __restrict__ __a, size_t __n, const _Tp& __t)
  48. { while (__n--) *__a++ = __t; }
  49.  
  50. // fill strided array __a[<__n-1 : __s>] with __t
  51. template<typename _Tp>
  52. inline void
  53. __valarray_fill (_Tp* __restrict__ __a, size_t __n,
  54.                  size_t __s, const _Tp& __t)
  55. { for (size_t __i=0; __i<__n; ++__i, __a+=__s) *__a = __t; }
  56.  
  57. // fill indirect array __a[__i[<__n>]] with __i
  58. template<typename _Tp>
  59. inline void
  60. __valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i,
  61.                 size_t __n, const _Tp& __t)
  62. { for (size_t __j=0; __j<__n; ++__j, ++__i) __a[*__i] = __t; }
  63.  
  64. // copy plain array __a[<__n>] in __b[<__n>]
  65. template<typename _Tp>
  66. inline void
  67. __valarray_copy (const _Tp* __restrict__ __a, size_t __n,
  68.                  _Tp* __restrict__ __b)
  69. { memcpy (__b, __a, __n * sizeof(_Tp)); }
  70.  
  71. // copy strided array __a[<__n : __s>] in plain __b[<__n>]
  72. template<typename _Tp>
  73. inline void
  74. __valarray_copy (const _Tp* __restrict__ __a, size_t __n, size_t __s,
  75.                  _Tp* __restrict__ __b)
  76. { for (size_t __i=0; __i<__n; ++__i, ++__b, __a += __s) *__b = *__a; }
  77.  
  78. // copy plain __a[<__n>] in strided __b[<__n : __s>]
  79. template<typename _Tp>
  80. inline void
  81. __valarray_copy (const _Tp* __restrict__ __a, _Tp* __restrict__ __b,
  82.                  size_t __n, size_t __s)
  83. { for (size_t __i=0; __i<__n; ++__i, ++__a, __b+=__s) *__b = *__a; }
  84.  
  85. // copy indexed __a[__i[<__n>]] in plain __b[<__n>]
  86. template<typename _Tp>
  87. inline void
  88. __valarray_copy (const _Tp* __restrict__ __a,
  89.                  const size_t* __restrict__ __i,
  90.                  _Tp* __restrict__ __b, size_t __n)
  91. { for (size_t __j=0; __j<__n; ++__j, ++__b, ++__i) *__b = __a[*__i]; }
  92.  
  93. // copy plain __a[<__n>] in indexed __b[__i[<__n>]]
  94. template<typename _Tp>
  95. inline void
  96. __valarray_copy (const _Tp* __restrict__ __a, size_t __n,
  97.                  _Tp* __restrict__ __b, const size_t* __restrict__ __i)
  98. { for (size_t __j=0; __j<__n; ++__j, ++__a, ++__i) __b[*__i] = *__a; }
  99.  
  100. //
  101. // Helper class _Array, first layer of valarray abstraction.
  102. // All operations on valarray should be forwarded to this class
  103. // whenever possible. -- gdr
  104. //
  105.  
  106. template<typename _Tp> struct _Array {
  107.     
  108.     explicit _Array (size_t);
  109.     explicit _Array (_Tp* const __restrict__);
  110.     explicit _Array (const valarray<_Tp>&);
  111.     _Array (const _Tp* __restrict__, size_t);
  112.     
  113.     void free_data() const;
  114.     _Tp* begin () const;
  115.     
  116.     _Tp* const __restrict__ _M_data;
  117. };
  118.  
  119. template<typename _Tp>
  120. inline void
  121. __valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
  122. { __valarray_fill (__a._M_data, __n, __t); }
  123.  
  124. template<typename _Tp>
  125. inline void
  126. __valarray_fill (_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t)
  127. { __valarray_fill (__a._M_data, __n, __s, __t); }
  128.  
  129. template<typename _Tp>
  130. inline void
  131. __valarray_fill (_Array<_Tp> __a, _Array<size_t> __i, 
  132.                  size_t __n, const _Tp& __t)
  133. { __valarray_fill (__a._M_data, __i._M_data, __n, __t); }
  134.  
  135. template<typename _Tp>
  136. inline void
  137. __valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
  138. { __valarray_copy (__a._M_data, __n, __b._M_data); }
  139.  
  140. template<typename _Tp>
  141. inline void
  142. __valarray_copy (_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
  143. { __valarray_copy(__a._M_data, __n, __s, __b._M_data); }
  144.  
  145. template<typename _Tp>
  146. inline void
  147. __valarray_copy (_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s)
  148. { __valarray_copy (__a._M_data, __b._M_data, __n, __s); }
  149.  
  150. template<typename _Tp>
  151. inline void
  152. __valarray_copy (_Array<_Tp> __a, _Array<size_t> __i, 
  153.                  _Array<_Tp> __b, size_t __n)
  154. { __valarray_copy (__a._M_data, __i._M_data, __b._M_data, __n); }
  155.  
  156. template<typename _Tp>
  157. inline void
  158. __valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, 
  159.                  _Array<size_t> __i)
  160. { __valarray_copy (__a._M_data, __n, __b._M_data, __i._M_data); }
  161.  
  162. template<typename _Tp>
  163. inline
  164. _Array<_Tp>::_Array (size_t __n) : _M_data (new _Tp[__n]) {}
  165.  
  166. template<typename _Tp>
  167. inline
  168. _Array<_Tp>::_Array (_Tp* const __restrict__ __p) : _M_data (__p) {}
  169.  
  170. template<typename _Tp>
  171. inline _Array<_Tp>::_Array (const valarray<_Tp>& __v) 
  172.         : _M_data (__v._M_data) {}
  173.  
  174. template<typename _Tp>
  175. inline
  176. _Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s) 
  177.         : _M_data (new _Tp[__s]) { __valarray_copy (__b, __s, _M_data); }
  178.  
  179. template<typename _Tp>
  180. inline void
  181. _Array<_Tp>::free_data() const { delete[] _M_data; }
  182.  
  183. template<typename _Tp>
  184. inline _Tp*
  185. _Array<_Tp>::begin () const
  186. { return _M_data; }
  187.  
  188. #define _DEFINE_ARRAY_FUNCTION(_Op, _Name)                \
  189. template<typename _Tp>                            \
  190. inline void                                \
  191. _Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, const _Tp& __t)    \
  192. {                                    \
  193.     for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p)         \
  194.       *__p _Op##= __t;                            \
  195. }                                    \
  196.                                     \
  197. template<typename _Tp>                            \
  198. inline void                                \
  199. _Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)    \
  200. {                                    \
  201.     _Tp* __p (__a._M_data);                        \
  202.     for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__p, ++__q)     \
  203.       *__p _Op##= *__q;                            \
  204. }                                    \
  205.                                     \
  206. template<typename _Tp, class _Dom>                    \
  207. void                                    \
  208. _Array_augmented_##_Name (_Array<_Tp> __a,                 \
  209.                          const _Expr<_Dom,_Tp>& __e, size_t __n)    \
  210. {                                    \
  211.     _Tp* __p (__a._M_data);                        \
  212.     for (size_t __i=0; __i<__n; ++__i, ++__p) *__p _Op##= __e[__i];    \
  213. }                                    \
  214.                                     \
  215. template<typename _Tp>                            \
  216. inline void                                \
  217. _Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, size_t __s,     \
  218.              _Array<_Tp> __b)                \
  219. {                                           \
  220.     _Tp* __q (__b._M_data);                        \
  221.     for (_Tp* __p=__a._M_data; __p<__a._M_data+__s*__n; __p+=__s, ++__q) \
  222.       *__p _Op##= *__q;                            \
  223. }                                    \
  224.                                     \
  225. template<typename _Tp>                            \
  226. inline void                                \
  227. _Array_augmented_##_Name (_Array<_Tp> __a, _Array<_Tp> __b,         \
  228.              size_t __n, size_t __s)            \
  229. {                                    \
  230.     _Tp* __q (__b._M_data);                        \
  231.     for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, __q+=__s)    \
  232.       *__p _Op##= *__q;                            \
  233. }                                    \
  234.                                     \
  235. template<typename _Tp, class _Dom>                    \
  236. void                                    \
  237. _Array_augmented_##_Name (_Array<_Tp> __a, size_t __s,            \
  238.                           const _Expr<_Dom,_Tp>& __e, size_t __n)    \
  239. {                                    \
  240.     _Tp* __p (__a._M_data);                        \
  241.     for (size_t __i=0; __i<__n; ++__i, __p+=__s) *__p _Op##= __e[__i];    \
  242. }                                    \
  243.                                     \
  244. template<typename _Tp>                            \
  245. inline void                                \
  246. _Array_augmented_##_Name (_Array<_Tp> __a, _Array<size_t> __i,        \
  247.                           _Array<_Tp> __b, size_t __n)            \
  248. {                                    \
  249.     _Tp* __q (__b._M_data);                        \
  250.     for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__q)    \
  251.         __a._M_data[*__j] _Op##= *__q;                    \
  252. }                                    \
  253.                                     \
  254. template<typename _Tp>                            \
  255. inline void                                \
  256. _Array_augmented_##_Name (_Array<_Tp> __a, size_t __n,            \
  257.                           _Array<_Tp> __b, _Array<size_t> __i)        \
  258. {                                    \
  259.     _Tp* __p (__a._M_data);                        \
  260.     for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__p)    \
  261.         *__p _Op##= __b._M_data[*__j];                    \
  262. }                                    \
  263.                                     \
  264. template<typename _Tp, class _Dom>                    \
  265. void                                    \
  266. _Array_augmented_##_Name (_Array<_Tp> __a, _Array<size_t> __i,        \
  267.                           const _Expr<_Dom, _Tp>& __e, size_t __n)    \
  268. {                                    \
  269.     size_t* __j (__i._M_data);                        \
  270.     for (size_t __k=0; __k<__n; ++__k, ++__j)                 \
  271.       __a._M_data[*__j] _Op##= __e[__k];                \
  272. }                                    \
  273.                                     \
  274. template<typename _Tp>                            \
  275. void                                    \
  276. _Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __m,        \
  277.                           _Array<_Tp> __b, size_t __n)            \
  278. {                                    \
  279.     bool* ok (__m._M_data);                        \
  280.     _Tp* __p (__a._M_data);                        \
  281.     for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__q, ++ok, ++__p) { \
  282.         while (! *ok) {                            \
  283.             ++ok;                            \
  284.             ++__p;                            \
  285.         }                                \
  286.         *__p _Op##= *__q;                        \
  287.     }                                    \
  288. }                                    \
  289.                                     \
  290. template<typename _Tp>                            \
  291. void                                    \
  292. _Array_augmented_##_Name (_Array<_Tp> __a, size_t __n,            \
  293.                          _Array<_Tp> __b, _Array<bool> __m)        \
  294. {                                    \
  295.     bool* ok (__m._M_data);                        \
  296.     _Tp* __q (__b._M_data);                        \
  297.     for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, ++ok, ++__q) { \
  298.         while (! *ok) {                            \
  299.             ++ok;                            \
  300.             ++__q;                            \
  301.         }                                \
  302.         *__p _Op##= *__q;                        \
  303.     }                                    \
  304. }                                    \
  305.                                     \
  306. template<typename _Tp, class _Dom>                    \
  307. void                                    \
  308. _Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __m,        \
  309.                           const _Expr<_Dom, _Tp>& __e, size_t __n)    \
  310. {                                    \
  311.     bool* ok(__m._M_data);                        \
  312.     _Tp* __p (__a._M_data);                        \
  313.     for (size_t __i=0; __i<__n; ++__i, ++ok, ++__p) {            \
  314.         while (! *ok) {                            \
  315.             ++ok;                            \
  316.             ++__p;                            \
  317.         }                                \
  318.         *__p _Op##= __e[__i];                        \
  319.     }                                    \
  320. }
  321.  
  322. _DEFINE_ARRAY_FUNCTION(+, plus)
  323. _DEFINE_ARRAY_FUNCTION(-, minus)
  324. _DEFINE_ARRAY_FUNCTION(*, multiplies)
  325. _DEFINE_ARRAY_FUNCTION(/, divides)
  326. _DEFINE_ARRAY_FUNCTION(%, modulus)
  327. _DEFINE_ARRAY_FUNCTION(^, xor)
  328. _DEFINE_ARRAY_FUNCTION(|, or)
  329. _DEFINE_ARRAY_FUNCTION(&, and)    
  330. _DEFINE_ARRAY_FUNCTION(<<, shift_left)
  331. _DEFINE_ARRAY_FUNCTION(>>, shift_right)
  332.  
  333. #undef _DEFINE_ARRAY_FUNCTION    
  334.  
  335. } // extern "C++"
  336.     
  337. #ifdef _G_NO_VALARRAY_TEMPLATE_EXPORT
  338. # define export 
  339. # include <std/valarray_array.tcc>    
  340. #endif
  341.            
  342. #endif // __VALARRAY_ARRAY__
  343.  
  344. // Local Variables:
  345. // mode:c++
  346. // End:
  347.