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 #ifndef MLN_METAL_ARRAY1D_HH
00027 # define MLN_METAL_ARRAY1D_HH
00028
00029 # include <mln/core/concept/object.hh>
00030
00031 # include <mln/trait/all.hh>
00032 # include <mln/trait/value_.hh>
00033
00034 # include <mln/value/ops.hh>
00035
00036 namespace mln
00037 {
00038
00039
00040 namespace metal {
00041 template <typename T, unsigned Size> struct array1d;
00042 }
00043
00044 namespace trait
00045 {
00046
00047 template <typename T, unsigned Size>
00048 struct value_< mln::metal::array1d<T,Size> >
00049 {
00050 typedef trait::value::nature::vectorial nature;
00051 typedef trait::value::kind::data kind;
00052
00053 enum {
00054 nbits = Size * mln_nbits(T),
00055 card = Size * mln_card(T)
00056 };
00057 typedef mln_value_quant_from_(card) quant;
00058
00059 typedef metal::array1d<mln_sum(T),Size> sum;
00060 };
00061
00062 }
00063
00064
00065 namespace metal
00066 {
00067
00068 template <typename T, unsigned Size>
00069 struct array1d : public Object< array1d<T,Size> >
00070 {
00071
00072
00073
00074
00075
00076 array1d();
00077 array1d(T* ptr);
00078
00079
00080
00081 array1d(const array1d<T, Size>& rhs);
00082 array1d<T, Size>& operator=(const array1d<T, Size>& rhs);
00083
00084
00085
00086 template <class U>
00087 array1d<T, Size> operator*(U w);
00088
00089 template <class U>
00090 array1d<mln_trait_op_div(T,U), Size>
00091 operator/(U w);
00092
00093 template <typename U>
00094 array1d<mln_trait_op_plus(T,U), Size>
00095 operator+(const array1d<U, Size>& rhs) const;
00096 array1d<T, Size>& operator+=(const array1d<T, Size>& rhs);
00097
00098 template <typename U>
00099 array1d<mln_trait_op_minus(T,U), Size>
00100 operator-(const array1d<U, Size>& rhs) const;
00101 array1d<T, Size>&
00102 operator-=(const array1d<T, Size>& rhs);
00103
00104
00105
00106
00107 T operator[](unsigned i) const {
00108 mln_precondition(i < Size);
00109 return buffer_[i];
00110 }
00111 T& operator[](unsigned i) {
00112 mln_precondition(i < Size);
00113 return buffer_[i];
00114 }
00115
00116
00117
00118 template<unsigned i>
00119 T get() const {
00120 return buffer_[i];
00121 }
00122 template<unsigned i>
00123 T& get() {
00124 return buffer_[i];
00125 }
00126
00127 enum { length = Size };
00128 protected:
00129
00130 T buffer_[Size];
00131 };
00132
00133 }
00134
00135 namespace trait
00136 {
00137
00138
00139
00140 template < template <class> class Name,
00141 unsigned n, typename T >
00142 struct set_precise_unary_< Name, metal::array1d<T, n> >
00143 {
00144 typedef mln_trait_unary(Name, T) V;
00145 typedef metal::array1d<V, n> ret;
00146 };
00147
00148
00149
00150 template < template <class, class> class Name,
00151 unsigned n, typename T,
00152 typename U >
00153 struct set_precise_binary_< Name,
00154 metal::array1d<T, n>, metal::array1d<U, n> >
00155 {
00156 typedef mln_trait_binary(Name, T, U) V;
00157 typedef metal::array1d<V, n> ret;
00158 };
00159
00160 template < unsigned n, typename T,
00161 typename U >
00162 struct set_precise_binary_< op::times,
00163 metal::array1d<T, n>, metal::array1d<U, n> >
00164 {
00165 typedef mln_sum_product(T,U) ret;
00166 };
00167
00168 template < template <class, class> class Name,
00169 unsigned n, typename T,
00170 typename S >
00171 struct set_precise_binary_< Name,
00172 metal::array1d<T, n>, mln::value::scalar_<S> >
00173 {
00174 typedef mln_trait_binary(Name, T, S) V;
00175 typedef metal::array1d<V, n> ret;
00176 };
00177
00178 template < template<class, class> class Name,
00179 unsigned n, typename T,
00180 typename S >
00181 struct set_binary_< Name,
00182 mln::Object, metal::array1d<T, n>,
00183 mln::value::Scalar, S >
00184 {
00185 typedef mln_trait_binary(Name, T, S) V;
00186 typedef metal::array1d<T, n> ret;
00187 };
00188
00189 }
00190
00191
00192 namespace metal
00193 {
00194
00195
00196
00197
00198
00199 template <typename T, unsigned Size>
00200 array1d<T,Size>::array1d()
00201 {
00202 }
00203
00204 template <typename T, unsigned Size>
00205 array1d<T,Size>::array1d(T* ptr)
00206 {
00207 for (unsigned i = 0; i < Size; ++i)
00208 buffer_[i] = *ptr++;
00209 }
00210
00211
00212
00213 template <typename T, unsigned Size>
00214 array1d<T,Size>::array1d(const array1d<T, Size>& rhs)
00215 {
00216 for (unsigned i = 0; i < Size; ++i)
00217 buffer_[i] = rhs[i];
00218 }
00219 template <typename T, unsigned Size>
00220 array1d<T, Size>&
00221 array1d<T,Size>::operator=(const array1d<T, Size>& rhs)
00222 {
00223 for (unsigned i = 0; i < Size; ++i)
00224 buffer_[i] = rhs[i];
00225 return *this;
00226 }
00227
00228
00229
00230 template <typename T, unsigned Size>
00231 template <class U>
00232 array1d<T, Size>
00233 array1d<T,Size>::operator*(U w)
00234 {
00235
00236 array1d<T, Size> tmp;
00237 for (unsigned i = 0; i < Size; ++i)
00238 tmp[i] = this->buffer_[i] * w;
00239 return tmp;
00240 }
00241
00242 template <typename T, unsigned Size>
00243 template <class U>
00244 array1d<mln_trait_op_div(T,U), Size>
00245 array1d<T,Size>::operator/(U w)
00246 {
00247 array1d<T, Size> tmp;
00248 for (unsigned i = 0; i < Size; ++i)
00249 tmp[i] = this->buffer_[i] / w;
00250 return tmp;
00251 }
00252
00253 template <typename T, unsigned Size>
00254 template <typename U>
00255 array1d<mln_trait_op_plus(T,U), Size>
00256 array1d<T,Size>::operator+(const array1d<U, Size>& rhs) const
00257 {
00258 array1d<T, Size> tmp;
00259 for (unsigned i = 0; i < Size; ++i)
00260 tmp[i] = this->buffer_[i] + rhs.buffer_[i];
00261 return tmp;
00262 }
00263 template <typename T, unsigned Size>
00264 array1d<T, Size>&
00265 array1d<T,Size>::operator+=(const array1d<T, Size>& rhs)
00266 {
00267 for (unsigned i = 0; i < Size; ++i)
00268 this->buffer_[i] += rhs.buffer_[i];
00269 return *this;
00270 }
00271
00272 template <typename T, unsigned Size>
00273 template <typename U>
00274 array1d<mln_trait_op_minus(T,U), Size>
00275 array1d<T,Size>::operator-(const array1d<U, Size>& rhs) const
00276 {
00277 array1d<T, Size> tmp;
00278 for (unsigned i = 0; i < Size; ++i)
00279 tmp[i] = this->buffer_[i] - rhs.buffer_[i];
00280 return tmp;
00281 }
00282 template <typename T, unsigned Size>
00283 array1d<T, Size>&
00284 array1d<T,Size>::operator-=(const array1d<T, Size>& rhs)
00285 {
00286 for (unsigned i = 0; i < Size; ++i)
00287 this->buffer_[i] -= rhs.buffer_[i];
00288 return *this;
00289 }
00290
00291 }
00292
00293 }
00294
00295 #endif // ! MLN_METAL_ARRAY1D_HH