TBCI Numerical high perf. C++ Library: vector

00001 
00006 /* KG: 1998/08/17 */
00007 /* $Id: vector_extra.h,v 1.9.2.11 2006/08/13 20:06:01 garloff Exp $ */
00008 
00009 #ifndef TBCI_VECTOR_EXTRA_H
00010 #define TBCI_VECTOR_EXTRA_H  
00011 
00012 #include "vector.h"
00013 #include "matrix.h"
00014 
00015 // avoid -fguiding-decls (here: unnecessary)
00016 #if !defined(NO_GD) && !defined(AUTO_DECL)
00017 # include "vector_extra_gd.h"
00018 #endif
00019 
00020 NAMESPACE_TBCI
00021 
00022 // elementwise multiplication
00023 INST(template <typename T> class TVector  friend TVector<T>   emul (const Vector<T>&, const Vector<T>&);)
00024 template <typename T>
00025 inline TVector<T>   emul (const Vector<T>& a, const Vector<T>& b)
00026 {
00027   const unsigned long dim = b.size();
00028   TVector<T> s (dim);
00029   BCHK(a.size() != dim, VecErr, product with diff. size Vectors, dim, s);
00030   do_vec_vec_mul<T> (dim, &s.setval(0), &a.getcref(0), &b.getcref(0));
00031   return s;
00032 }
00033 
00034 INST(template <typename T> class TVector friend TVector<T>   emul (TVector<T>, const Vector<T>&);)
00035 template <typename T>
00036 inline TVector<T>   emul (TVector<T> a, const Vector<T>& b)
00037 {
00038   const unsigned long dim = b.size();
00039   BCHK(a.size() != dim, VecErr, product with diff. size Vectors, dim, a);
00040   do_vec_mul_vec<T> (dim, &a.setval(0), &b.getcref(0));
00041   return a;
00042 }
00043 
00044 INST(template <typename T> class TVector friend TVector<T>   emul (const Vector<T>&, TVector<T>);)
00045 template <typename T>
00046 inline TVector<T>   emul (const Vector<T>& a, TVector<T> b)
00047 {
00048   const unsigned long dim = b.size();
00049   BCHK(a.size() != dim, VecErr, product with diff. size Vectors, dim, b);
00050   do_vec_mul_vec<T> (dim, &b.setval(0), &a.getcref(0));
00051   return b;
00052 }
00053 
00054 INST(template <typename T> class TVector friend TVector<T>   emul (TVector<T>, TVector<T>);)
00055 template <typename T>
00056 inline TVector<T>   emul (TVector<T> a, TVector<T> b)
00057 {
00058   const unsigned long dim = b.size();
00059   BCHK(a.size() != dim, VecErr, product with diff. size Vectors, dim, a);
00060   do_vec_mul_vec<T> (dim, &a.setval(0), &b.getcref(0));
00061   b.destroy (); return a;
00062 }
00063 
00064 INST(template <typename T> class TVector  friend TVector<T>  cemul (const Vector<T>&, const Vector<T>&);)
00065 template <typename T>
00066 inline TVector<T>  cemul (const Vector<T>& a, const Vector<T>& b)
00067 {
00068   const unsigned long dim = b.size();
00069   TVector<T> s(dim);
00070   BCHK(a.size() != dim, VecErr, product with diff. size Vectors, dim, s);
00071   do_vec_vec_cmul<T> (dim, &s.setval(0), &a.getcref(0), &b.getcref(0));
00072   return s;
00073 }
00074 
00075 INST(template <typename T> class TVector  friend TVector<T>  cemul (TVector<T>, const Vector<T>&);)
00076 template <typename T>
00077 inline TVector<T>  cemul (TVector<T> a, const Vector<T>& b)
00078 {
00079   const unsigned long dim = b.size();
00080   BCHK(a.size() != dim, VecErr, product with diff. size Vectors, dim, a);
00081   do_vec_cmul_vec<T> (dim, &a.setval(0), &b.getcref(0));
00082   return a;
00083 }
00084 
00085 INST(template <typename T> class TVector  friend TVector<T>  cemul (const Vector<T>&, TVector<T>);)
00086 template <typename T>
00087 inline TVector<T>  cemul (const Vector<T>& a, TVector<T> b)
00088 {
00089   const unsigned long dim = b.size();
00090   BCHK(a.size() != dim, VecErr, product with diff. size Vectors, dim, b);
00091   do_vec_cmul_vec_inv<T> (dim, &b.setval(0), &a.getcref(0));
00092   return b;
00093 }
00094 
00095 INST(template <typename T> class TVector  friend TVector<T>  cemul (TVector<T>, TVector<T>);)
00096 template <typename T>
00097 inline TVector<T>  cemul (TVector<T> a, TVector<T> b)
00098 {
00099   const unsigned long dim = b.size();
00100   BCHK(a.size() != dim, VecErr, product with diff. size Vectors, dim, a);
00101   do_vec_cmul_vec<T> (dim, &a.setval(0), &b.getcref(0));
00102   b.destroy (); return a;
00103 }
00104 
00105 
00106 // elementwise division
00107 
00108 INST(template <typename T> class TVector friend TVector<T>   ediv (const Vector<T>&, const Vector<T>&);)
00109 template <typename T>
00110 inline TVector<T>   ediv (const Vector<T>& a, const Vector<T>& b)
00111 {
00112   TVector<T> s (b.size());
00113   BCHK(a.size() != b.size(), VecErr, division with diff. size Vectors, b.size(), s);
00114   do_vec_vec_div<T> (b.size(), &s.setval(0), &a.getcref(0), &b.getcref(0));
00115   return s;
00116 }
00117 
00118 INST(template <typename T> class TVector friend TVector<T>   ediv (TVector<T>, const Vector<T>&);)
00119 template <typename T>
00120 inline TVector<T>   ediv (TVector<T> a, const Vector<T>& b)
00121 {
00122   BCHK(a.size() != b.size(), VecErr, division with diff. size Vectors, b.size(), a);
00123   do_vec_div_vec<T> (b.size(), &a.setval(0), &b.getcref(0));
00124   return a;
00125 }
00126 
00127 INST(template <typename T> class TVector friend TVector<T>   ediv (const Vector<T>&, TVector<T>);)
00128 template <typename T>
00129 inline TVector<T>   ediv (const Vector<T>& a, TVector<T> b)
00130 {
00131   BCHK(a.size() != b.size(), VecErr, division with diff. size Vectors, b.size(), b);
00132   do_vec_div_vec_inv<T> (b.size(), &b.setval(0), &a.getcref(0));
00133   return b;
00134 }
00135 
00136 INST(template <typename T> class TVector friend TVector<T>   ediv (TVector<T>, TVector<T>);)
00137 template <typename T>
00138 inline TVector<T>   ediv (TVector<T> a, TVector<T> b)
00139 {
00140   BCHK(a.size() != b.size(), VecErr, division with diff. size Vectors, b.size(), a);
00141   do_vec_div_vec<T> (b.size(), &a.setval(0), &b.getcref(0));
00142   b.destroy (); return a;
00143 }
00144 
00145 INST(template <typename T> class TVector friend TVector<T>  cediv (const Vector<T>&, const Vector<T>&);)
00146 template <typename T>
00147 inline TVector<T>  cediv (const Vector<T>& a, const Vector<T>& b)
00148 {
00149   TVector<T> s (b.size());
00150   BCHK(a.size() != b.size(), VecErr, division with diff. size Vectors, b.size(), s);
00151   do_vec_vec_cdiv<T> (b.size(), &s.setval(0), &a.getcref(0), &b.getcref(0));
00152   return s;
00153 }
00154 
00155 INST(template <typename T> class TVector friend TVector<T>  cediv (TVector<T>, const Vector<T>&);)
00156 template <typename T>
00157 inline TVector<T>  cediv (TVector<T> a, const Vector<T>& b)
00158 {
00159   BCHK(a.size() != b.size(), VecErr, division with diff. size Vectors, b.size(), a);
00160   do_vec_cdiv_vec<T> (b.size(), &a.setval(0), &b.getcref(0));
00161   return a;
00162 }
00163 
00164 INST(template <typename T> class TVector friend TVector<T>  cediv (const Vector<T>&, TVector<T>);)
00165 template <typename T>
00166 inline TVector<T>  cediv (const Vector<T>& a, TVector<T> b)
00167 {
00168   BCHK(a.size() != b.size(), VecErr, division with diff. size Vectors, b.size(), b);
00169   do_vec_cdiv_vec_inv<T> (a.size(), &b.setval(0), &a.getcref(0));
00170   return b;
00171 }
00172 
00173 INST(template <typename T> class TVector friend TVector<T>  cediv (TVector<T>, TVector<T>);)
00174 template <typename T>
00175 inline TVector<T>  cediv (TVector<T> a, TVector<T> b)
00176 {
00177   BCHK(a.size() != b.size(), VecErr, division with diff. size Vectors, b.size(), a);
00178   do_vec_cdiv_vec<T> (b.size(), &a.setval(0), &b.getcref(0));
00179   b.destroy (); return a;
00180 }
00181 
00182 
00183 // Now for the combinations with TSVector<T>
00184 // Not yet optimized with the unrolled kernels from vec_kern_unr_pref.h
00185 
00186 INST(template <typename T> class TSVector friend TVector<T>   emul (TVector<T>, const TSVector<T>&);)
00187 template <typename T>
00188 TVector<T>   emul (TVector<T> tv, const TSVector<T>& ts)
00189 {
00190    BCHK(tv.size() != ts.size(), VecErr, Wrong dim in emul, ts.size(), tv); 
00191    for (register unsigned long i = 0; i < tv.size(); i++)
00192      tv.setval(i) *= ts.get(i);
00193    ts.destroy (); return tv;
00194 }
00195 
00196 INST(template <typename T> class TSVector friend TVector<T>   emul (const TSVector<T>&, TVector<T>);)
00197 template <typename T>
00198 TVector<T>   emul (const TSVector<T>& ts, TVector<T> tv)
00199 {
00200    BCHK(tv.size() != ts.size(), VecErr, Wrong dim in emul, tv.size(), tv); 
00201    for (register unsigned long i = 0; i < tv.size(); i++)
00202      tv.set (ts.get(i) * tv.get(i), i);
00203    ts.destroy (); return tv;
00204 }
00205 
00206 
00207 INST(template <typename T> class TSVector friend TVector<T>   emul (const Vector<T>&, const TSVector<T>&);)
00208 template <typename T>
00209 TVector<T>   emul (const Vector<T>& v, const TSVector<T>& ts)
00210 {
00211    TVector<T> tv;
00212    if (ts.mut) { tv.setptr(ts.vecptr()); tv.setsize(ts.size()); }
00213    else tv.resize (ts.size());
00214    BCHK(v.size() != ts.size(), VecErr, Wrong dim in emul, ts.size(), tv); 
00215    for (register unsigned long i = 0; i < tv.size(); i++)
00216      tv.set (v.get(i) * ts.get(i), i);
00217    return tv;
00218 }
00219 
00220 INST(template <typename T> class TSVector friend TVector<T>   emul (const TSVector<T>&, const Vector<T>&);)
00221 template <typename T>
00222 TVector<T>   emul (const TSVector<T>& ts, const Vector<T>& v)
00223 {
00224    TVector<T> tv;
00225    if (ts.mut) { tv.setptr(ts.vecptr()); tv.setsize(ts.size()); }
00226    else tv.resize (ts.size());
00227    BCHK(v.size() != ts.size(), VecErr, Wrong dim in emul, v.size(), tv); 
00228    for (register unsigned long i = 0; i < tv.size(); i++)
00229      tv.set (ts.get(i) * v.get(i), i);
00230    return tv;
00231 }
00232 
00233 INST(template <typename T> class TSVector friend TVector<T>   emul (const TSVector<T>&, const TSVector<T>&);)
00234 template <typename T>
00235 TVector<T>   emul (const TSVector<T>& ts1, const TSVector<T>& ts2)
00236 {
00237    TVector<T> tv;
00238    if (ts1.mut) { tv.setptr(ts1.vecptr()); tv.setsize(ts1.size()); }
00239    else if (ts2.mut) { tv.setptr(ts2.vecptr()); tv.setsize(ts2.size()); }
00240         else tv.resize (ts1.size());
00241    BCHK(ts1.size() != ts2.size(), VecErr, Wrong dim in emul, ts2.size(), tv); 
00242    for (register unsigned long i = 0; i < tv.size(); i++)
00243      tv.set (ts1.get(i), i);
00244    if (ts1.mut && ts2.mut) ts2.destroy (); return tv;
00245 }
00246 
00247 
00248 INST(template <typename T> class TSVector friend TVector<T>  cemul (TVector<T>, const TSVector<T>&);)
00249 template <typename T>
00250 TVector<T>  cemul (TVector<T> tv, const TSVector<T>& ts)
00251 {
00252    BCHK(tv.size() != ts.size(), VecErr, Wrong dim in emul, ts.size(), tv); 
00253    for (register unsigned long i = 0; i < tv.size(); i++)
00254      tv.set (CPLX__ conj(tv.get(i)) * ts.get(i), i);
00255    ts.destroy (); return tv;
00256 }
00257 
00258 INST(template <typename T> class TSVector friend TVector<T>  cemul (const TSVector<T>&, TVector<T>);)
00259 template <typename T>
00260 TVector<T>  cemul (const TSVector<T>& ts, TVector<T> tv)
00261 {
00262    BCHK(tv.size() != ts.size(), VecErr, Wrong dim in emul, tv.size(), tv); 
00263    for (register unsigned long i = 0; i < tv.size(); i++)
00264      tv.set (CPLX__ conj (ts.get(i)) * tv.get(i), i);
00265    ts.destroy (); return tv;
00266 }
00267 
00268 INST(template <typename T> class TSVector friend TVector<T>  cemul (const Vector<T>&, const TSVector<T>&);)
00269 template <typename T>
00270 TVector<T>  cemul (const Vector<T>& v, const TSVector<T>& ts)
00271 {
00272    TVector<T> tv;
00273    if (ts.mut) { tv.setptr(ts.vecptr()); tv.setsize(ts.size()); }
00274    else tv.resize (ts.size());
00275    BCHK(v.size() != ts.size(), VecErr, Wrong dim in emul, ts.size(), tv); 
00276    for (register unsigned long i = 0; i < tv.size(); i++)
00277      tv.set (CPLX__ conj(v.get(i)) * ts.get(i), i);
00278    return tv;
00279 }
00280 
00281 
00282 INST(template <typename T> class TSVector friend TVector<T>  cemul (const TSVector<T>&, const Vector<T>&);)
00283 template <typename T>
00284 TVector<T>  cemul (const TSVector<T>& ts, const Vector<T>& v)
00285 {
00286    TVector<T> tv;
00287    if (ts.mut) { tv.setptr(ts.vecptr()); tv.setsize(ts.size()); }
00288    else tv.resize (ts.size());
00289    BCHK(v.size() != ts.size(), VecErr, Wrong dim in emul, v.size(), tv); 
00290    for (register unsigned long i = 0; i < tv.size(); i++)
00291      tv.set (CPLX__ conj (ts.get(i)) * v.get(i), i);
00292    return tv;
00293 }
00294 
00295 INST(template <typename T> class TSVector friend TVector<T>  cemul (const TSVector<T>&, const TSVector<T>&);)
00296 template <typename T>
00297 TVector<T>  cemul (const TSVector<T>& ts1, const TSVector<T>& ts2)
00298 {
00299    TVector<T> tv;
00300    if (ts1.mut) { tv.setptr(ts1.vecptr()); tv.setsize(ts1.size()); }
00301    else if (ts2.mut) { tv.setptr(ts2.vecptr()); tv.setsize(ts2.size()); }
00302         else tv.resize (ts1.size());
00303    BCHK(ts1.size() != ts2.size(), VecErr, Wrong dim in emul, ts2.size(), tv); 
00304    for (register unsigned long i = 0; i < tv.size(); i++)
00305      tv.set (CPLX__ conj (ts1.get(i)), i);
00306    if (ts1.mut && ts2.mut) ts2.destroy (); return tv;
00307 }
00308 
00309 
00310 INST(template <typename T> class TSVector friend  TVector<T>   ediv (TVector<T>, const TSVector<T>&);)
00311 template <typename T>
00312 TVector<T>   ediv (TVector<T> tv, const TSVector<T>& ts)
00313 {
00314    BCHK(tv.size() != ts.size(), VecErr, Wrong dim in ediv, ts.size(), tv); 
00315    for (register unsigned long i = 0; i < tv.size(); i++)
00316      tv.setval(i) /= ts.get(i);
00317    ts.destroy (); return tv;
00318 }
00319 
00320 INST(template <typename T> class TSVector friend  TVector<T>   ediv (const Vector<T>&, const TSVector<T>&);)
00321 template <typename T>
00322 TVector<T>   ediv (const Vector<T>& v, const TSVector<T>& ts)
00323 {
00324    TVector<T> tv;
00325    if (ts.mut) { tv.setptr(ts.vecptr()); tv.setsize(ts.size()); }
00326    else tv.resize (ts.size());
00327    BCHK(v.size() != ts.size(), VecErr, Wrong dim in ediv, ts.size(), tv); 
00328    for (register unsigned long i = 0; i < tv.size(); i++)
00329      tv.set (v.get(i) / ts.get(i), i);
00330    return tv;
00331 }
00332 
00333 INST(template <typename T> class TSVector friend  TVector<T>   ediv (const TSVector<T>&, const TSVector<T>&);)
00334 template <typename T>
00335 TVector<T>   ediv (const TSVector<T>& ts1, const TSVector<T>& ts2)
00336 {
00337    TVector<T> tv;
00338    if (ts1.mut) { tv.setptr(ts1.vecptr()); tv.setsize(ts1.size()); }
00339    else if (ts2.mut) { tv.setptr(ts2.vecptr()); tv.setsize(ts2.size()); }
00340         else tv.resize (ts1.size());
00341    BCHK(ts1.size() != ts2.size(), VecErr, Wrong dim in ediv, ts2.size(), tv); 
00342    for (register unsigned long i = 0; i < tv.size(); i++)
00343      tv.set (ts1.get(i), i);
00344    if (ts1.mut && ts2.mut) ts2.destroy (); return tv;
00345 }
00346 
00347 INST(template <typename T> class TSVector friend  TVector<T>   ediv (const TSVector<T>&, const Vector<T>&);)
00348 template <typename T>
00349 TVector<T>   ediv (const TSVector<T>& ts, const Vector<T>& v)
00350 {
00351    TVector<T> tv;
00352    if (ts.mut) { tv.setptr(ts.vecptr()); tv.setsize(ts.size()); }
00353    else tv.resize (ts.size());
00354    BCHK(v.size() != ts.size(), VecErr, Wrong dim in ediv, v.size(), tv); 
00355    for (register unsigned long i = 0; i < tv.size(); i++)
00356      tv.set (ts.get(i) / v.get(i), i);
00357    return tv;
00358 }
00359 
00360 INST(template <typename T> class TSVector friend  TVector<T>   ediv (const TSVector<T>&, TVector<T>);)
00361 template <typename T>
00362 TVector<T>   ediv (const TSVector<T>& ts, TVector<T> tv)
00363 {
00364    BCHK(tv.size() != ts.size(), VecErr, Wrong dim in ediv, tv.size(), tv); 
00365    for (register unsigned long i = 0; i < tv.size(); i++)
00366      tv.set (ts.get(i) / tv.get(i), i);
00367    ts.destroy (); return tv;
00368 }
00369 
00370 
00371 INST(template <typename T> class TSVector friend TVector<T>   cediv (TVector<T>, const TSVector<T>&);)
00372 template <typename T>
00373 TVector<T>   cediv (TVector<T> tv, const TSVector<T>& ts)
00374 {
00375    BCHK(tv.size() != ts.size(), VecErr, Wrong dim in ediv, ts.size(), tv); 
00376    for (register unsigned long i = 0; i < tv.size(); i++)
00377      tv.set (CPLX__ conj(tv.get(i)) / ts.get(i), i);
00378    ts.destroy (); return tv;
00379 }
00380 
00381 INST(template <typename T> class TSVector friend TVector<T>   cediv (const TSVector<T>&, TVector<T>);)
00382 template <typename T>
00383 TVector<T>  cediv (const TSVector<T>& ts, TVector<T> tv)
00384 {
00385    BCHK(tv.size() != ts.size(), VecErr, Wrong dim in ediv, tv.size(), tv); 
00386    for (register unsigned long i = 0; i < tv.size(); i++)
00387      tv.set (CPLX__ conj (ts.get(i)) / tv.get(i), i);
00388    ts.destroy (); return tv;
00389 }
00390 
00391 INST(template <typename T> class TSVector friend TVector<T>   cediv (const Vector<T>&, const TSVector<T>&);)
00392 template <typename T>
00393 TVector<T>  cediv (const Vector<T>& v, const TSVector<T>& ts)
00394 {
00395    TVector<T> tv;
00396    if (ts.mut) { tv.setptr(ts.vecptr()); tv.setsize(ts.size()); }
00397    else tv.resize (ts.size());
00398    BCHK(v.size() != ts.size(), VecErr, Wrong dim in ediv, ts.size(), tv); 
00399    for (register unsigned long i = 0; i < tv.size(); i++)
00400      tv.set (CPLX__ conj(v.get(i)) / ts.get(i), i);
00401    return tv;
00402 }
00403 
00404 
00405 INST(template <typename T> class TSVector friend TVector<T>   cediv (const TSVector<T>&, const Vector<T>&);)
00406 template <typename T>
00407 TVector<T>  cediv (const TSVector<T>& ts, const Vector<T>& v)
00408 {
00409    TVector<T> tv;
00410    if (ts.mut) { tv.setptr(ts.vecptr()); tv.setsize(ts.size()); }
00411    else tv.resize (ts.size());
00412    BCHK(v.size() != ts.size(), VecErr, Wrong dim in ediv, v.size(), tv); 
00413    for (register unsigned long i = 0; i < tv.size(); i++)
00414      tv.set (CPLX__ conj (ts.get(i)) / v.get(i), i);
00415    return tv;
00416 }
00417 
00418 INST(template <typename T> class TSVector friend TVector<T>   cediv (const TSVector<T>&, const TSVector<T>&);)
00419 template <typename T>
00420 TVector<T>  cediv (const TSVector<T>& ts1, const TSVector<T>& ts2)
00421 {
00422    TVector<T> tv;
00423    if (ts1.mut) { tv.setptr(ts1.vecptr()); tv.setsize(ts1.size()); }
00424    else if (ts2.mut) { tv.setptr(ts2.vecptr()); tv.setsize(ts2.size()); }
00425         else tv.resize (ts1.size());
00426    BCHK(ts1.size() != ts2.size(), VecErr, Wrong dim in ediv, ts2.size(), tv); 
00427    for (register unsigned long i = 0; i < tv.size(); i++)
00428      tv.set (CPLX__ conj (ts1.get(i)), i);
00429    if (ts1.mut && ts2.mut) ts2.destroy (); return tv;
00430 }
00431 
00432 
00433 
00434 INST(template <typename T> class TVector friend TVector<T> ediv (const T&, TVector<T>);)
00435 template <typename T>
00436 inline TVector<T> ediv (const T& a, TVector<T> b)
00437 {
00438         STD_SMP_TEMPLATE2C(val_div_vec, b.size(), &b.setval(0), a);
00439         return b;
00440 }
00441         
00442 INST(template <typename T> class TVector friend TVector<T> ediv (const T&, const Vector<T>&);)
00443 template <typename T>
00444 inline TVector<T> ediv (const T& a, const Vector<T>& b)
00445 { 
00446         const unsigned d = b.size();
00447         TVector<T> res (d);
00448         STD_SMP_TEMPLATE3VC(val_vec_div, d, &res.setval(0), &b.getcref(0), a);
00449         return res;
00450 }
00451         
00452 INST(template <typename T> class TSVector friend TVector<T> ediv (const T&, const TSVector<T>&);)
00453 template <typename T>
00454 inline TVector<T> ediv (const T& a, const TSVector<T>& ts)
00455 {
00456         TSVector<T> tm (ts); tm.detach ();
00457         STD_SMP_TEMPLATE4C(val_svc_div, tm.size(), tm.vecptr(), &ts.getcref(0), a, ts.getfac());
00458         tm.getfacref() = (T)1; return TVector<T> (tm);
00459 }
00460 
00461 // elementwise multiplication / division (with and without taking complex conj.)
00462 // for matrices
00463 
00464 # define _VEC getvec()
00465 # define _ENDVEC getendvec()
00466 # define _DIM size()
00467 # define _ROW rows()
00468 # define _COL columns()
00469 # define _FAC getfac()
00470 
00471 INST(template <typename T> class TMatrix friend TMatrix<T> emul (const Matrix<T>&, const Matrix<T>&);)
00472 template <typename T>
00473 TMatrix<T> emul (const Matrix<T>& a, const Matrix<T>& b)
00474 {
00475         const unsigned int rw = a.rows(), cl = a.columns();
00476         BCHK(rw != b.rows(), MatErr, rows differ in emul, rw, TMatrix<T>(0,0));
00477         BCHK(cl != b.columns(), MatErr, columns differ in emul, cl, TMatrix<T>(0,0));
00478         TMatrix<T> res (rw, cl);
00479         do_vec_vec_mul<T> (a._DIM, res._VEC, a._VEC, b._VEC);
00480         return res;
00481 }
00482 
00483 INST(template <typename T> class TMatrix friend TMatrix<T> cemul (const Matrix<T>&, const Matrix<T>&);)
00484 template <typename T>
00485 TMatrix<T> cemul (const Matrix<T>& a, const Matrix<T>& b)
00486 {
00487         const unsigned int rw = a .rows(), cl = a.columns();
00488         BCHK(rw != b.rows(), MatErr, rows differ in cemul, rw, TMatrix<T>(0,0));
00489         BCHK(cl != b.columns(), MatErr, columns differ in cemul, cl, TMatrix<T>(0,0));
00490         TMatrix<T> res (rw, cl);
00491         do_vec_vec_cmul<T> (a._DIM, res._VEC, a._VEC, b._VEC);
00492         return res;
00493 }
00494 
00495 INST(template <typename T> class TMatrix friend TMatrix<T> ediv (const Matrix<T>&, const Matrix<T>&);)
00496 template <typename T>
00497 TMatrix<T> ediv (const Matrix<T>& a, const Matrix<T>& b)
00498 {
00499         const unsigned int rw = a .rows(), cl = a.columns();
00500         BCHK(rw != b.rows(), MatErr, rows differ in ediv, rw, TMatrix<T>(0,0));
00501         BCHK(cl != b.columns(), MatErr, columns differ in ediv, cl, TMatrix<T>(0,0));
00502         TMatrix<T> res (rw, cl);
00503         do_vec_vec_div<T> (a._DIM, res._VEC, a._VEC, b._VEC);
00504         return res;
00505 }
00506 
00507 INST(template <typename T> class TMatrix friend TMatrix<T> cediv (const Matrix<T>&, const Matrix<T>&);)
00508 template <typename T>
00509 TMatrix<T> cediv (const Matrix<T>& a, const Matrix<T>& b)
00510 {
00511         const unsigned int rw = a .rows(), cl = a.columns();
00512         BCHK(rw != b.rows(), MatErr, rows differ in cediv, rw, TMatrix<T>(0,0));
00513         BCHK(cl != b.columns(), MatErr, columns differ in cediv, cl, TMatrix<T>(0,0));
00514         TMatrix<T> res (rw, cl);
00515         do_vec_vec_cdiv<T> (a._DIM, res._VEC, a._VEC, b._VEC);
00516         return res;
00517 }
00518 
00519 
00520 INST(template <typename T> class TMatrix friend TMatrix<T> ediv (const T&, TMatrix<T>);)
00521 template <typename T>
00522 inline TMatrix<T> ediv (const T& a, TMatrix<T> b)
00523 {
00524         STD_SMP_TEMPLATE2C(val_div_vec, b._DIM, b._VEC, a);
00525         return b;
00526 }
00527         
00528 INST(template <typename T> class TMatrix friend TMatrix<T> ediv (const T&, const Matrix<T>&);)
00529 template <typename T>
00530 inline TMatrix<T> ediv (const T& a, const Matrix<T>& b)
00531 { 
00532         const unsigned r = b.rows(), c = b.columns();
00533         TMatrix<T> res (r, c);
00534         STD_SMP_TEMPLATE3VC(val_vec_div, b._DIM, res._VEC, b._VEC, a);
00535         return res;
00536 }
00537         
00538 INST(template <typename T> class TSMatrix friend TMatrix<T> ediv (const T&, const TSMatrix<T>&);)
00539 template <typename T>
00540 inline TMatrix<T> ediv (const T& a, const TSMatrix<T>& ts)
00541 {
00542         TSMatrix<T> tm (ts); tm.detach ();
00543         STD_SMP_TEMPLATE4C(val_svc_div, tm._DIM, tm._VEC, ts._VEC, a, ts._FAC);
00544         tm._FAC = (T)1; return TMatrix<T> (tm);
00545 }
00546         
00547 #undef _DIM
00548 #undef _VEC
00549 #undef _ENDVEC
00550 #undef _ROW
00551 #undef _COL
00552 #undef _FAC
00553 
00554 NAMESPACE_END
00555 
00556 #endif /* TBCI_VECTOR_EXTRA_H */