examples/homography/TooN/linoperators.hh

00001 
00002 /*                       
00003          Copyright (C) 2005 Tom Drummond
00004 
00005      This library is free software; you can redistribute it and/or
00006      modify it under the terms of the GNU Lesser General Public
00007      License as published by the Free Software Foundation; either
00008      version 2.1 of the License, or (at your option) any later version.
00009 
00010      This library is distributed in the hope that it will be useful,
00011      but WITHOUT ANY WARRANTY; without even the implied warranty of
00012      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013      Lesser General Public License for more details.
00014 
00015      You should have received a copy of the GNU Lesser General Public
00016      License along with this library; if not, write to the Free Software
00017      Foundation, Inc.
00018      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00019 */
00020 #ifndef __LINOPERATORS_HH
00021 #define __LINOPERATORS_HH
00022 
00023 #include <assert.h>
00024 
00025 
00026 inline RefMatrixRM DynamicVAccessor::as_row(){
00027   return makeRefMatrixRM(1,my_size,my_values);
00028 }
00029 
00030 inline RefMatrixCM DynamicVAccessor::as_col(){
00031   return makeRefMatrixCM(my_size,1,my_values);
00032 }
00033 
00034 inline RefSkipMatrixCM DynamicSkipAccessor::as_row(){
00035   return makeRefSkipMatrixCM(1,my_size,my_skip,my_values);
00036 }
00037 
00038 inline RefSkipMatrixRM DynamicSkipAccessor::as_col(){
00039   return makeRefSkipMatrixRM(my_size,1,my_skip,my_values);
00040 }
00041 
00043 // unary operator - //
00044 //    -Vector       //
00046 
00047 template<int Size, class Accessor>
00048 struct FixedVectorNeg{
00049   inline static void eval(Vector<Size>& ret, const FixedVector<Size,Accessor>& arg){
00050     for(int i=0; i<Size; i++){
00051       ret[i]=-arg[i];
00052     }
00053   }
00054 };
00055 
00056 template<int Size, class Accessor> inline 
00057 Vector<Size> operator-(const FixedVector<Size,Accessor>& arg){
00058   return Vector<Size>(arg,Operator<FixedVectorNeg<Size,Accessor> >());
00059 }
00060 
00061 template <class Accessor>
00062 struct DynamicVectorNeg : public VSizer {
00063   inline static void eval(Vector<>& ret, const DynamicVector<Accessor>& arg){
00064     const int Size = arg.size();
00065     set_size(ret,Size);
00066     for(int i=0; i<Size; i++){
00067       ret[i]=-arg[i];
00068     }
00069   }
00070 };
00071 
00072 
00073 template <class Accessor>
00074 Vector<> operator-(const DynamicVector<Accessor>& arg){
00075   return Vector<>(arg,Operator<DynamicVectorNeg<Accessor> >());
00076 }
00077 
00079 //                 //
00080 //   operator ==   //
00081 //   operator !=   //
00082 // Vector == Vector//
00084 
00085 
00086 template<int Size, class Accessor1, class Accessor2>
00087 inline bool operator==(const FixedVector<Size, Accessor1>& lhs, const FixedVector<Size, Accessor2>& rhs){
00088   for(int i=0; i < Size; i++)
00089         if(lhs[i] != rhs[i])
00090                 return 0;
00091   return 1;
00092 }
00093 
00094 template<int Size, class Accessor1, class Accessor2>
00095 inline bool operator==(const FixedVector<Size, Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
00096   assert(rhs.size() == Size);
00097   for(int i=0; i < Size; i++)
00098         if(lhs[i] != rhs[i])
00099                 return 0;
00100   return 1;
00101 }
00102 
00103 template<class Accessor1, class Accessor2>
00104 inline bool operator==(const DynamicVector<Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
00105   assert(rhs.size() == lhs.size());
00106   for(int i=0; i < rhs.size(); i++)
00107         if(lhs[i] != rhs[i])
00108                 return 0;
00109   return 1;
00110 }
00111 
00112 template<int Size, class Accessor1, class Accessor2>
00113 inline bool operator==(const DynamicVector<Accessor1>& lhs, const FixedVector<Size, Accessor2>& rhs){
00114   assert(Size == lhs.size());
00115   for(int i=0; i < Size; i++)
00116         if(lhs[i] != rhs[i])
00117                 return 0;
00118   return 1;
00119 }
00120 
00121 
00122 
00123 template<int Size, class Accessor1, class Accessor2>
00124 inline bool operator!=(const FixedVector<Size, Accessor1>& lhs, const FixedVector<Size, Accessor2>& rhs){
00125   for(int i=0; i < Size; i++)
00126         if(lhs[i] == rhs[i])
00127                 return 0;
00128   return 1;
00129 }
00130 
00131 template<int Size, class Accessor1, class Accessor2>
00132 inline bool operator!=(const FixedVector<Size, Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
00133   assert(rhs.size() == Size);
00134   for(int i=0; i < Size; i++)
00135         if(lhs[i] == rhs[i])
00136                 return 0;
00137   return 1;
00138 }
00139 
00140 template<class Accessor1, class Accessor2>
00141 inline bool operator!=(const DynamicVector<Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
00142   assert(rhs.size() == lhs.size());
00143   for(int i=0; i < rhs.size(); i++)
00144         if(lhs[i] == rhs[i])
00145                 return 0;
00146   return 1;
00147 }
00148 
00149 template<int Size, class Accessor1, class Accessor2>
00150 inline bool operator!=(const DynamicVector<Accessor1>& lhs, const FixedVector<Size, Accessor2>& rhs){
00151   assert(Size == lhs.size());
00152   for(int i=0; i < Size; i++)
00153         if(lhs[i] == rhs[i])
00154                 return 0;
00155   return 1;
00156 }
00157 
00158 
00159 
00160 
00162 //                 //
00163 //   operator +    //
00164 // Vector + Vector //
00166 
00167 template <int Size, class LHS, class RHS>
00168 struct FixedVAdd {
00169   inline static void eval(Vector<Size>& ret,
00170                    const LHS& lhs,
00171                    const RHS& rhs){
00172     for(int i=0; i<Size; i++){
00173       ret[i] = lhs[i]+rhs[i];
00174     }
00175   }
00176 };
00177 
00178 
00179 template <int Size, class Accessor1, class Accessor2>
00180 inline Vector<Size> operator+(const FixedVector<Size,Accessor1>& lhs, const FixedVector<Size,Accessor2>& rhs) {
00181   return Vector<Size>(lhs, rhs,
00182                       Operator<FixedVAdd<Size,
00183                       FixedVector<Size,Accessor1>,
00184                       FixedVector<Size,Accessor2> > >());
00185 }
00186 
00187 
00188 template <class LHS, class RHS>
00189 struct DynamicVAdd : public VSizer{
00190   static void eval(Vector<>& ret,
00191                    const LHS& lhs,
00192                    const RHS& rhs){
00193     assert(lhs.size() == rhs.size());
00194     const int Size = lhs.size();
00195     set_size(ret,Size);
00196     for(int i=0; i<Size; i++){
00197       ret[i] = lhs[i]+rhs[i];
00198     }
00199   }
00200 };
00201 
00202 // have to specify operator + three more times
00203 // for any combination of Fixed and Dynamic except Fixed-Fixed
00204 
00205 template <class Accessor1,class Accessor2>
00206 inline Vector<> operator+(const DynamicVector<Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
00207   return Vector<>(lhs,rhs,
00208                   Operator<DynamicVAdd<
00209                   DynamicVector<Accessor1>,
00210                   DynamicVector<Accessor2> > >());
00211 }
00212 
00213 template <int Size, class Accessor1,class Accessor2>
00214 inline Vector<> operator+(const FixedVector<Size,Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
00215   return Vector<>(lhs,rhs,
00216                   Operator<DynamicVAdd<
00217                   FixedVector<Size,Accessor1>,
00218                   DynamicVector<Accessor2> > >());
00219 }
00220 
00221 template <class Accessor1, int Size, class Accessor2>
00222 inline Vector<> operator+(const DynamicVector<Accessor1>& lhs, const FixedVector<Size,Accessor2>& rhs){
00223   return Vector<>(lhs,rhs,
00224                   Operator<DynamicVAdd<
00225                   DynamicVector<Accessor1>,
00226                   FixedVector<Size,Accessor2> > >());
00227 }
00228 
00230 //                  //
00231 // operator +=      //
00232 // Vector += Vector //
00233 //                  //
00235 
00236 template <int Size, class LHAccessor, class RHAccessor>
00237 inline FixedVector<Size,LHAccessor>& operator+= (FixedVector<Size,LHAccessor>& lhs,
00238                                                  const FixedVector<Size,RHAccessor>& rhs){
00239     util::AddV<0,Size-1>::eval(lhs,rhs);
00240     return lhs;
00241 }
00242 
00243 template <int Size, class LHAccessor, class RHAccessor>
00244 inline FixedVector<Size,LHAccessor>& operator+= (FixedVector<Size,LHAccessor>& lhs,
00245                                                  const DynamicVector<RHAccessor>& rhs){
00246     assert(rhs.size() == Size);
00247     util::AddV<0,Size-1>::eval(lhs,rhs);
00248     return lhs;
00249 }
00250 
00251 template <int Size, class LHAccessor, class RHAccessor>
00252 inline DynamicVector<LHAccessor>& operator+= (DynamicVector<LHAccessor>& lhs,
00253                                               const FixedVector<Size,RHAccessor>& rhs){
00254   assert(lhs.size()==Size);
00255   util::AddV<0,Size-1>::eval(lhs,rhs);
00256   return lhs;
00257 }
00258 
00259 template <class LHAccessor, class RHAccessor>
00260 inline DynamicVector<LHAccessor>& operator+= (DynamicVector<LHAccessor>& lhs,
00261                                               const DynamicVector<RHAccessor>& rhs){
00262   assert(lhs.size()==rhs.size());
00263   for(int i=0; i<lhs.size(); i++){
00264     lhs[i]+=rhs[i];
00265   }
00266   return lhs;
00267 }
00268 
00269 
00271 //            //
00272 // operator - //
00273 //            //
00275 
00276 template <int Size, class LHS, class RHS>
00277 struct FixedVSub {
00278   static void eval(Vector<Size>& ret,
00279                    const LHS& lhs,
00280                    const RHS& rhs){
00281     for(int i=0; i<Size; i++){
00282       ret[i] = lhs[i]-rhs[i];
00283     }
00284   }
00285 };
00286 
00287 
00288 template <int Size, class Accessor1, class Accessor2>
00289 inline Vector<Size> operator-(const FixedVector<Size,Accessor1>& lhs, const FixedVector<Size,Accessor2>& rhs) {
00290   return Vector<Size>(lhs, rhs,
00291                       Operator<FixedVSub<Size,
00292                       FixedVector<Size,Accessor1>,
00293                       FixedVector<Size,Accessor2> > >());
00294 }
00295 
00296 
00297 template <class LHS, class RHS>
00298 struct DynamicVSub : public VSizer{
00299   static void eval(Vector<>& ret,
00300                    const LHS& lhs,
00301                    const RHS& rhs){
00302     assert(lhs.size() == rhs.size());
00303     const int Size = lhs.size();
00304     set_size(ret,Size);
00305     for(int i=0; i<Size; i++){
00306       ret[i] = lhs[i]-rhs[i];
00307     }
00308   }
00309 };
00310 
00311 // have to specify operator - three more times
00312 // for any combination of Fixed and Dynamic except Fixed-Fixed
00313 
00314 template <class Accessor1,class Accessor2>
00315 inline Vector<> operator-(const DynamicVector<Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
00316   return Vector<>(lhs,rhs,
00317                   Operator<DynamicVSub<
00318                   DynamicVector<Accessor1>,
00319                   DynamicVector<Accessor2> > >());
00320 }
00321 
00322 template <int Size, class Accessor1,class Accessor2>
00323 inline Vector<> operator-(const FixedVector<Size,Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
00324   return Vector<>(lhs,rhs,
00325                   Operator<DynamicVSub<
00326                   FixedVector<Size,Accessor1>,
00327                   DynamicVector<Accessor2> > >());
00328 }
00329 
00330 template <class Accessor1, int Size, class Accessor2>
00331 inline Vector<> operator-(const DynamicVector<Accessor1>& lhs, const FixedVector<Size,Accessor2>& rhs){
00332   return Vector<>(lhs,rhs,
00333                   Operator<DynamicVSub<
00334                   DynamicVector<Accessor1>,
00335                   FixedVector<Size,Accessor2> > >());
00336 }
00337 
00338 
00340 //             //
00341 // operator -= //
00342 //             //
00344 
00345 template <int Size, class LHAccessor, class RHAccessor>
00346 inline FixedVector<Size,LHAccessor>& operator-= (FixedVector<Size,LHAccessor>& lhs,
00347                                                  const FixedVector<Size,RHAccessor>& rhs){
00348   for(int i=0; i<Size; i++){
00349     lhs[i]-=rhs[i];
00350   }
00351   return lhs;
00352 }
00353 
00354 template <int Size, class LHAccessor, class RHAccessor>
00355 inline FixedVector<Size,LHAccessor>& operator-= (FixedVector<Size,LHAccessor>& lhs,
00356                                                  const DynamicVector<RHAccessor>& rhs){
00357   assert(rhs.size() == Size);
00358   for(int i=0; i<Size; i++){
00359     lhs[i]-=rhs[i];
00360   }
00361   return lhs;
00362 }
00363 
00364 template <int Size, class LHAccessor, class RHAccessor>
00365 inline DynamicVector<LHAccessor>& operator-= (DynamicVector<LHAccessor>& lhs,
00366                                               const FixedVector<Size,RHAccessor>& rhs){
00367   assert(lhs.size()==Size);
00368   for(int i=0; i<Size; i++){
00369     lhs[i]-=rhs[i];
00370   }
00371   return lhs;
00372 }
00373 
00374 template <class LHAccessor, class RHAccessor>
00375 inline DynamicVector<LHAccessor>& operator-= (DynamicVector<LHAccessor>& lhs,
00376                                               const DynamicVector<RHAccessor>& rhs){
00377   assert(lhs.size()==rhs.size());
00378   for(int i=0; i<lhs.size(); i++){
00379     lhs[i]-=rhs[i];
00380   }
00381   return lhs;
00382 }
00383 
00384 
00386 // operator *      //
00387 // Vector * double //
00388 // (or v.v.)       //
00390 
00391 template <int Size, class Accessor>
00392 struct FixedVdMult {
00393   static inline void eval(Vector<Size>& ret, const FixedVector<Size,Accessor>& lhs, double rhs){
00394     for(int i=0; i<Size; i++){
00395       ret[i] = lhs[i] * rhs;
00396     }
00397   }
00398 };
00399 
00400 template <int Size, class Accessor>
00401 inline Vector<Size> operator*(const FixedVector<Size,Accessor>& lhs, double rhs){
00402   return Vector<Size>(lhs,rhs,
00403                       Operator<FixedVdMult<Size,Accessor> >());
00404 }
00405 template <int Size, class Accessor>
00406 inline Vector<Size> operator*(double lhs, const FixedVector<Size,Accessor>& rhs){
00407   return Vector<Size>(rhs,lhs,
00408                       Operator<FixedVdMult<Size,Accessor> >());
00409 }
00410 
00411 template <class Accessor>
00412 struct DynamicVdMult : public VSizer{
00413   static inline void eval(Vector<>& ret, const DynamicVector<Accessor>& lhs, double rhs){
00414     set_size(ret,lhs.size());
00415     for(int i=0; i<lhs.size(); i++){
00416       ret[i] = lhs[i] * rhs;
00417     }
00418   }
00419 };
00420 
00421 template <class Accessor>
00422 inline Vector<> operator*(const DynamicVector<Accessor>& lhs, double rhs){
00423   return Vector<>(lhs,rhs,
00424                   Operator<DynamicVdMult<Accessor> >());
00425 }
00426 template <class Accessor>
00427 inline Vector<> operator*(double lhs, const DynamicVector<Accessor>& rhs){
00428   return Vector<>(rhs,lhs,
00429                   Operator<DynamicVdMult<Accessor> >());
00430 }
00431 
00433 // operator *=      //
00434 // Vector *= double //
00436 
00437 template <int Size, class Accessor>
00438 inline FixedVector<Size,Accessor>& operator*=(FixedVector<Size,Accessor>& lhs, const double& rhs){
00439   for(int i=0; i<Size; i++){
00440     lhs[i]*=rhs;
00441   }
00442   return lhs;
00443 }
00444 
00445 template <class Accessor>
00446 inline DynamicVector<Accessor>& operator*=(DynamicVector<Accessor>& lhs, const double& rhs){
00447   const int Size = lhs.size();
00448   for(int i=0; i<Size; i++){
00449     lhs[i]*=rhs;
00450   }
00451   return lhs;
00452 }
00453 
00455 // operator /      //
00456 // Vector / double //
00458 
00459 template <int Size, class Accessor>
00460 inline Vector<Size> operator/(const FixedVector<Size,Accessor>& lhs, double rhs){
00461   return Vector<Size>(lhs,1/rhs,
00462                       Operator<FixedVdMult<Size,Accessor> >());
00463 }
00464 
00465 template <class Accessor>
00466 inline Vector<> operator/(const DynamicVector<Accessor>& lhs, double rhs){
00467   return Vector<>(lhs,1/rhs,
00468                   Operator<DynamicVdMult<Accessor> >());
00469 }
00470 
00471 
00473 // operator /=      //
00474 // Vector /= double //
00476 
00477 template <int Size, class Accessor>
00478 inline FixedVector<Size,Accessor>& operator/=(FixedVector<Size,Accessor>& lhs, const double& rhs){
00479   return lhs*=(1/rhs);
00480 }
00481 
00482 template <class Accessor>
00483 inline DynamicVector<Accessor>& operator/=(DynamicVector<Accessor>& lhs, const double& rhs){
00484   return lhs*=(1/rhs);
00485 }
00486 
00488 //  operator *   //
00489 // (dot product) //
00491 
00492 template <int Size, class Accessor1, class Accessor2>
00493 inline double operator*(const FixedVector<Size,Accessor1>& lhs, const FixedVector<Size,Accessor2>& rhs) {
00494     return util::Dot<0,Size-1>::eval(lhs,rhs);
00495 }
00496 
00497 template <class Accessor1,class Accessor2>
00498 inline double operator*(const DynamicVector<Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
00499   assert(lhs.size() == rhs.size());
00500   double dot=0;
00501   for(int i=0; i<lhs.size(); i++){
00502       dot += lhs[i]*rhs[i];
00503   }
00504   return dot;
00505 }
00506 
00507 template <int Size, class Accessor1,class Accessor2>
00508 inline double operator*(const FixedVector<Size,Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
00509   assert(lhs.size() == rhs.size());
00510   return util::Dot<0,Size-1>::eval(lhs,rhs);
00511 }
00512 
00513 template <class Accessor1,int Size,class Accessor2>
00514 inline double operator*(const DynamicVector<Accessor1>& lhs, const FixedVector<Size,Accessor2>& rhs){
00515   assert(lhs.size() == rhs.size());
00516   return util::Dot<0,Size-1>::eval(lhs,rhs);
00517 }
00518 
00520 // operator ^            //
00521 // Vector<3> ^ Vector<3> //
00522 // cross product         //
00524 
00525 template<class Acc1, class Acc2>
00526 struct VXProduct {
00527   inline static void eval(Vector<3>& ret, const FixedVector<3,Acc1>& lhs, const FixedVector<3,Acc2>& rhs){
00528     ret[0] = lhs[1]*rhs[2] - lhs[2]*rhs[1];
00529     ret[1] = lhs[2]*rhs[0] - lhs[0]*rhs[2];
00530     ret[2] = lhs[0]*rhs[1] - lhs[1]*rhs[0];
00531   }
00532 };
00533 
00534 template<class Acc1, class Acc2>
00535 Vector<3> operator^(const FixedVector<3,Acc1>& lhs, const FixedVector<3,Acc2>& rhs){
00536   return Vector<3>(lhs,rhs,Operator<VXProduct<Acc1,Acc2> >());
00537 }
00538 
00539 
00540 
00542 // operator *      //
00543 // Matrix * Vector //
00545 
00546 template <int Rows, int Cols, class LHS, class RHS>
00547 struct FixedMVMult {
00548   inline static void eval(Vector<Rows>& ret, const LHS& lhs, const RHS& rhs){
00549     for(int r=0; r<Rows; r++){
00550         ret[r]=lhs[r]*rhs;
00551     }
00552   }
00553 };
00554 
00555 template <int Rows, int Cols, class MAccessor, class VAccessor>
00556 inline Vector<Rows> operator*(const FixedMatrix<Rows, Cols, MAccessor>& lhs,
00557                               const FixedVector<Cols, VAccessor>& rhs){
00558   return Vector<Rows>(lhs,rhs,
00559                       Operator<FixedMVMult<Rows,Cols,
00560                       FixedMatrix<Rows, Cols, MAccessor>,
00561                       FixedVector<Cols, VAccessor> > >());
00562 }
00563 
00564 
00565 template <class LHS, class RHS>
00566 struct DynamicMVMult : public VSizer {
00567   inline static void eval(Vector<>& ret, const LHS& lhs, const RHS& rhs){
00568     set_size(ret,lhs.num_rows());
00569     for(int r=0; r<lhs.num_rows(); r++){
00570       ret[r]=0;
00571       for(int c=0; c<lhs.num_cols(); c++){
00572         ret[r]+=lhs(r,c)*rhs[c];
00573       }
00574     }
00575   }
00576 };
00577 
00578 template <int Rows, int Cols, class MAccessor, class VAccessor>
00579 inline Vector<Rows> operator*(const FixedMatrix<Rows,Cols,MAccessor>& lhs,
00580                           const DynamicVector<VAccessor>& rhs){
00581   assert(rhs.size() == Cols);
00582   return Vector<Rows>(lhs,rhs,
00583                   Operator<FixedMVMult<Rows, Cols,
00584                   FixedMatrix<Rows,Cols,MAccessor>,
00585                   DynamicVector<VAccessor> > >());
00586                   
00587 }
00588 
00589 
00590 template <int Size, class MAccessor, class VAccessor>
00591 inline Vector<> operator*(const DynamicMatrix<MAccessor>& lhs,
00592                           const FixedVector<Size,VAccessor>& rhs){
00593   assert(lhs.num_cols() == Size);
00594   return Vector<>(lhs,rhs,
00595                   Operator<DynamicMVMult<
00596                   DynamicMatrix<MAccessor>,
00597                   FixedVector<Size,VAccessor> > >());
00598 }
00599 
00600 template <class MAccessor, class VAccessor>
00601 inline Vector<> operator*(const DynamicMatrix<MAccessor>& lhs,
00602                           const DynamicVector<VAccessor>& rhs){
00603   assert(lhs.num_cols() == rhs.size());
00604   return Vector<>(lhs,rhs,
00605                   Operator<DynamicMVMult<
00606                   DynamicMatrix<MAccessor>,
00607                   DynamicVector<VAccessor> > >());
00608 }
00609 
00610 
00612 // operator *      //
00613 // Vector * Matrix //
00615 
00616 template <int Rows, int Cols, class MAccessor, class VAccessor>
00617 inline Vector<Cols> operator*(const FixedVector<Rows, VAccessor>& lhs,
00618                               const FixedMatrix<Rows, Cols, MAccessor>& rhs){
00619   return (rhs.T() * lhs);
00620 }
00621 
00622 
00623 
00624 template <int Rows, int Cols, class MAccessor, class VAccessor>
00625 inline Vector<> operator*(const DynamicVector<VAccessor>& lhs,
00626                           const FixedMatrix<Rows,Cols,MAccessor>& rhs){
00627   return (rhs.T()*lhs);  
00628 }
00629 
00630 
00631 template <int Size, class MAccessor, class VAccessor>
00632 inline Vector<> operator*(const FixedVector<Size,VAccessor>& lhs,
00633                           const DynamicMatrix<MAccessor>& rhs){
00634   return (rhs.T()*lhs);
00635 }
00636 
00637 template <class MAccessor, class VAccessor>
00638 inline Vector<> operator*(const DynamicVector<VAccessor>& lhs,
00639                           const DynamicMatrix<MAccessor>& rhs){
00640   return (rhs.T()*lhs);
00641 }
00642 
00643 
00644 
00645 
00647 // operator *      //
00648 // Matrix * double //
00649 // (and v.v.)      //
00651 
00652 template <int Rows, int Cols, class Accessor>
00653 struct FixedMdMult {
00654   inline static void eval(Matrix<Rows,Cols>& ret, const FixedMatrix<Rows,Cols,Accessor>& lhs, double rhs){
00655     for(int r=0; r<Rows; r++){
00656       for(int c=0; c<Cols; c++){
00657         ret[r][c]=lhs[r][c]*rhs;
00658       }
00659     }
00660   }
00661 };
00662 
00663 template <int Rows, int Cols, class Accessor>
00664 inline Matrix<Rows,Cols> operator*(const FixedMatrix<Rows,Cols,Accessor>& lhs, double rhs){
00665   return Matrix<Rows,Cols>(lhs,rhs, Operator<FixedMdMult<Rows,Cols,Accessor> >());
00666 }
00667 
00668 template <int Rows, int Cols, class Accessor>
00669 inline Matrix<Rows,Cols> operator*(double lhs, const FixedMatrix<Rows,Cols,Accessor>& rhs){
00670   return Matrix<Rows,Cols>(rhs,lhs, Operator<FixedMdMult<Rows,Cols,Accessor> >());
00671 }
00672 
00673 
00674 template <class Accessor>
00675 struct DynamicMdMult : public MSizer {
00676   inline static void eval(Matrix<>& ret, const DynamicMatrix<Accessor>& lhs, double rhs){
00677     set_size(ret,lhs.num_rows(),lhs.num_cols());
00678     for(int r=0; r<lhs.num_rows(); r++){
00679       for(int c=0; c<lhs.num_cols(); c++){
00680         ret[r][c]=lhs[r][c]*rhs;
00681       }
00682     }
00683   }
00684 };
00685 
00686 
00687 template <class Accessor>
00688 inline Matrix<> operator*(const DynamicMatrix<Accessor>& lhs, double rhs){
00689   return Matrix<>(lhs,rhs, Operator<DynamicMdMult<Accessor> >());
00690 }
00691 
00692 template <class Accessor>
00693 inline Matrix<> operator*(double lhs, const DynamicMatrix<Accessor>& rhs){
00694   return Matrix<>(rhs,lhs, Operator<DynamicMdMult<Accessor> >());
00695 }
00696 
00697 
00699 // operator *=      //
00700 // Matrix *= double //
00702 
00703 
00704 template <class Accessor>
00705 inline void operator*=(MatrixBase<Accessor>& lhs, double rhs){
00706   for(int r=0; r<lhs.num_rows(); r++){
00707     for(int c=0; c<lhs.num_cols(); c++){
00708       lhs[r][c]*=rhs;
00709     }
00710   }
00711 }
00712 
00714 // operator /      //
00715 // Matrix / double //
00717 
00718 template <int Rows, int Cols, class Accessor>
00719 inline Matrix<Rows,Cols> operator/(const FixedMatrix<Rows,Cols,Accessor>& lhs, double rhs){
00720   return lhs * (1.0/rhs);
00721 }
00722 
00723 template <class Accessor>
00724 inline Matrix<> operator/(const DynamicMatrix<Accessor>& lhs, double rhs){
00725   return lhs * (1.0/rhs);
00726 }
00727 
00728 
00730 // operator /=      //
00731 // Matrix /= double //
00733 
00734 template <class Accessor>
00735 inline void operator/=(MatrixBase<Accessor>& lhs, double rhs){
00736   lhs*=(1.0/rhs);
00737 }
00738 
00740 // operator +      //
00741 // Matrix + Matrix //
00743 
00744 template <int Rows, int Cols, class LHAccessor, class RHAccessor>
00745 struct FixedMMSum {
00746   inline static void eval(Matrix<Rows,Cols>& ret,
00747                           const FixedMatrix<Rows,Cols,LHAccessor>& lhs,
00748                           const FixedMatrix<Rows,Cols,RHAccessor>& rhs){
00749     for(int r=0; r<Rows; r++){
00750       for(int c=0; c<Cols; c++){
00751         ret[r][c]= lhs[r][c]+rhs[r][c];
00752       }
00753     }
00754   }
00755 };
00756 
00757 template <int Rows, int Cols, class LHAccessor, class RHAccessor>
00758 Matrix<Rows,Cols> operator+(const FixedMatrix<Rows,Cols,LHAccessor>& lhs,
00759                             const FixedMatrix<Rows,Cols,RHAccessor>& rhs){
00760   return Matrix<Rows,Cols>(lhs,rhs, Operator<FixedMMSum<Rows,Cols,LHAccessor,RHAccessor> >());
00761 }
00762 
00763 template <class LHS, class RHS>
00764 struct DynamicMMSum : public MSizer {
00765   inline static void eval(Matrix<>& ret, const LHS& lhs, const RHS& rhs){
00766     set_size(ret,lhs.num_rows(),lhs.num_cols());
00767     for(int r=0; r<lhs.num_rows(); r++){
00768       for(int c=0; c<lhs.num_cols(); c++){
00769         ret[r][c]= lhs[r][c]+rhs[r][c];
00770       }
00771     }
00772   }
00773 };
00774 
00775 
00776 template <int Rows, int Cols, class LHAccessor, class RHAccessor>
00777 Matrix<> operator+(const FixedMatrix<Rows,Cols,LHAccessor>& lhs,
00778                    const DynamicMatrix<RHAccessor>& rhs){
00779   assert(rhs.num_rows()==Rows && rhs.num_cols()==Cols);
00780   return Matrix<> (lhs,rhs,
00781                    Operator<DynamicMMSum<
00782                    FixedMatrix<Rows,Cols,LHAccessor>,
00783                    DynamicMatrix<RHAccessor> > >());
00784 }
00785 
00786 
00787 template <int Rows, int Cols, class LHAccessor, class RHAccessor>
00788 Matrix<> operator+(const DynamicMatrix<LHAccessor>& lhs,
00789                    const FixedMatrix<Rows,Cols,RHAccessor>& rhs){
00790   assert(lhs.num_rows()==Rows && lhs.num_cols()==Cols);
00791   return Matrix<> (lhs,rhs,
00792                    Operator<DynamicMMSum<
00793                    DynamicMatrix<LHAccessor>,
00794                    FixedMatrix<Rows,Cols,RHAccessor> > >());
00795 }
00796 
00797 template <class LHAccessor, class RHAccessor>
00798 Matrix<> operator+(const DynamicMatrix<LHAccessor>& lhs,
00799                    const DynamicMatrix<RHAccessor>& rhs){
00800   assert(lhs.num_rows()==rhs.num_rows() && lhs.num_cols()==rhs.num_cols());
00801   return Matrix<> (lhs,rhs,
00802                    Operator<DynamicMMSum<
00803                    DynamicMatrix<LHAccessor>,
00804                    DynamicMatrix<RHAccessor> > >());
00805 }
00806 
00808 // operator +=      //
00809 // Matrix += Matrix //
00811 
00812 template <int Rows, int Cols, class MAccessor1, class MAccessor2> inline 
00813 FixedMatrix<Rows,Cols,MAccessor1>& operator += ( FixedMatrix<Rows,Cols,MAccessor1>& lhs,
00814                                                  const FixedMatrix<Rows,Cols,MAccessor2>& rhs){
00815     for(int r=0; r<Rows; r++){
00816         lhs[r] += rhs[r];
00817     }
00818     return lhs;
00819 }
00820 
00821 template <int Rows, int Cols, class MAccessor1, class MAccessor2> inline
00822 FixedMatrix<Rows,Cols,MAccessor1>& operator += ( FixedMatrix<Rows,Cols,MAccessor1>& lhs,
00823                                                  const DynamicMatrix<MAccessor2>& rhs){
00824   assert(rhs.num_rows() == Rows && rhs.num_cols() == Cols);
00825   for(int r=0; r<Rows; r++){
00826       lhs[r] += rhs[r];
00827   }
00828   return lhs;
00829 }
00830 
00831 
00832 template <int Rows, int Cols, class MAccessor1, class MAccessor2> inline
00833 DynamicMatrix<MAccessor1>& operator += ( DynamicMatrix<MAccessor1>& lhs,
00834                                          const FixedMatrix<Rows,Cols,MAccessor2>& rhs){
00835   assert(lhs.num_rows() == Rows && lhs.num_cols() == Cols);
00836   for(int r=0; r<Rows; r++){
00837       lhs[r] += rhs[r];
00838   }
00839   return lhs;
00840 }
00841 
00842 template <class MAccessor1, class MAccessor2> inline
00843 DynamicMatrix<MAccessor1>& operator += ( DynamicMatrix<MAccessor1>& lhs,
00844                                          const DynamicMatrix<MAccessor2>& rhs){
00845   assert(lhs.num_rows() == rhs.num_rows() && lhs.num_cols() == rhs.num_cols());
00846   for(int r=0; r<lhs.num_rows(); r++){
00847       lhs[r] += rhs[r];
00848   }
00849   return lhs;
00850 }
00851 
00853 // operator -      //
00854 // Matrix - Matrix //
00856 
00857 template <int Rows, int Cols, class LHAccessor, class RHAccessor>
00858 struct FixedMMSub {
00859   inline static void eval(Matrix<Rows,Cols>& ret,
00860                           const FixedMatrix<Rows,Cols,LHAccessor>& lhs,
00861                           const FixedMatrix<Rows,Cols,RHAccessor>& rhs){
00862     for(int r=0; r<Rows; r++){
00863       for(int c=0; c<Cols; c++){
00864         ret[r][c]= lhs[r][c]-rhs[r][c];
00865       }
00866     }
00867   }
00868 };
00869 
00870 template <int Rows, int Cols, class LHAccessor, class RHAccessor> inline
00871 Matrix<Rows,Cols> operator-(const FixedMatrix<Rows,Cols,LHAccessor>& lhs,
00872                             const FixedMatrix<Rows,Cols,RHAccessor>& rhs){
00873   return Matrix<Rows,Cols>(lhs,rhs, Operator<FixedMMSub<Rows,Cols,LHAccessor,RHAccessor> >());
00874 }
00875 
00876 template <class LHS, class RHS>
00877 struct DynamicMMSub : public MSizer {
00878   inline static void eval(Matrix<>& ret, const LHS& lhs, const RHS& rhs){
00879     set_size(ret,lhs.num_rows(),lhs.num_cols());
00880     for(int r=0; r<lhs.num_rows(); r++){
00881       for(int c=0; c<lhs.num_cols(); c++){
00882         ret[r][c]= lhs[r][c]-rhs[r][c];
00883       }
00884     }
00885   }
00886 };
00887 
00888 
00889 template <int Rows, int Cols, class LHAccessor, class RHAccessor>
00890 Matrix<> operator-(const FixedMatrix<Rows,Cols,LHAccessor>& lhs,
00891                    const DynamicMatrix<RHAccessor>& rhs){
00892   assert(rhs.num_rows()==Rows && rhs.num_cols()==Cols);
00893   return Matrix<> (lhs,rhs,
00894                    Operator<DynamicMMSub<
00895                    FixedMatrix<Rows,Cols,LHAccessor>,
00896                    DynamicMatrix<RHAccessor> > >());
00897 }
00898 
00899 
00900 template <int Rows, int Cols, class LHAccessor, class RHAccessor>
00901 Matrix<> operator-(const DynamicMatrix<LHAccessor>& lhs,
00902                    const FixedMatrix<Rows,Cols,RHAccessor>& rhs){
00903   assert(lhs.num_rows()==Rows && lhs.num_cols()==Cols);
00904   return Matrix<> (lhs,rhs,
00905                    Operator<DynamicMMSub<
00906                    DynamicMatrix<LHAccessor>,
00907                    FixedMatrix<Rows,Cols,RHAccessor> > >());
00908 }
00909 
00910 template <class LHAccessor, class RHAccessor>
00911 Matrix<> operator-(const DynamicMatrix<LHAccessor>& lhs,
00912                    const DynamicMatrix<RHAccessor>& rhs){
00913   assert(lhs.num_rows()==rhs.num_rows() && lhs.num_cols()==rhs.num_cols());
00914   return Matrix<> (lhs,rhs,
00915                    Operator<DynamicMMSub<
00916                    DynamicMatrix<LHAccessor>,
00917                    DynamicMatrix<RHAccessor> > >());
00918 }
00919 
00921 // operator -=      //
00922 // Matrix -= Matrix //
00924 
00925 template <int Rows, int Cols, class MAccessor1, class MAccessor2>
00926 FixedMatrix<Rows,Cols,MAccessor1>& operator -= ( FixedMatrix<Rows,Cols,MAccessor1>& lhs,
00927                                                  const FixedMatrix<Rows,Cols,MAccessor2>& rhs){
00928   for(int r=0; r<Rows; r++){
00929     for(int c=0; c<Cols; c++){
00930       lhs(r,c)-=rhs(r,c);
00931     }
00932   }
00933   return lhs;
00934 }
00935 
00936 template <int Rows, int Cols, class MAccessor1, class MAccessor2>
00937 FixedMatrix<Rows,Cols,MAccessor1>& operator -= ( FixedMatrix<Rows,Cols,MAccessor1>& lhs,
00938                                                  const DynamicMatrix<MAccessor2>& rhs){
00939   assert(rhs.num_rows == Rows && rhs.num_cols() == Cols);
00940   for(int r=0; r<Rows; r++){
00941     for(int c=0; c<Cols; c++){
00942       lhs(r,c)-=rhs(r,c);
00943     }
00944   }
00945   return lhs;
00946 }
00947 
00948 
00949 template <int Rows, int Cols, class MAccessor1, class MAccessor2>
00950 DynamicMatrix<MAccessor1>& operator -= ( DynamicMatrix<MAccessor1>& lhs,
00951                                          const FixedMatrix<Rows,Cols,MAccessor2>& rhs){
00952   assert(lhs.num_rows() == Rows && lhs.num_cols() == Cols);
00953   for(int r=0; r<Rows; r++){
00954     for(int c=0; c<Cols; c++){
00955       lhs(r,c)-=rhs(r,c);
00956     }
00957   }
00958   return lhs;
00959 }
00960 
00961 template <class MAccessor1, class MAccessor2>
00962 DynamicMatrix<MAccessor1>& operator -= ( DynamicMatrix<MAccessor1>& lhs,
00963                                          const DynamicMatrix<MAccessor2>& rhs){
00964   assert(lhs.num_rows() == rhs.num_rows() && lhs.num_cols() == rhs.num_cols());
00965   for(int r=0; r<lhs.num_rows(); r++){
00966     for(int c=0; c<lhs.num_cols(); c++){
00967       lhs(r,c)-=rhs(r,c);
00968     }
00969   }
00970   return lhs;
00971 }
00972 
00974 // operator *      //
00975 // Matrix * Matrix //
00977 
00978 template <class RET, class LHS, class RHS>
00979 inline void cppmmmult (RET& ret, const LHS& lhs, const RHS& rhs){
00980   const int Rows = lhs.num_rows();
00981   const int Cols = rhs.num_cols();
00982   const int Inter = lhs.num_cols();
00983   for(int r=0; r<Rows; r++){
00984     for(int c=0; c<Cols; c++){
00985       double temp=0;
00986       for(int i=0; i<Inter; i++){
00987         temp+=lhs(r,i)*rhs(i,c);
00988       }
00989       ret(r,c)=temp;
00990     }
00991   }
00992 }
00993 
00994 
00995 template <int Rows, int Inter, int Cols, class LHS, class RHS, int MultPolicy>
00996 struct FixedMMMult;
00997 
00998 template <int Rows, int Inter, int Cols, class LHS, class RHS>
00999 struct FixedMMMult<Rows,Inter,Cols,LHS,RHS,NUMERICS::BlasMult> {
01000   inline static void eval(Matrix<Rows,Cols>& ret, const LHS& lhs, const RHS& rhs){
01001       
01002     //blasmmmult(ret,lhs,rhs);
01003       //cppmmmult(ret, lhs, rhs);
01004       util::matrix_multiply<Rows,Inter,Cols>(lhs, rhs, ret);
01005   }
01006 };
01007 
01008 template <int Rows, int Inter, int Cols, class LHS, class RHS>
01009 struct FixedMMMult<Rows,Inter,Cols,LHS,RHS,NUMERICS::CPPMult> {
01010   inline static void eval(Matrix<Rows,Cols>& ret, const LHS& lhs, const RHS& rhs){
01011       //cppmmmult(ret,lhs,rhs);
01012       util::matrix_multiply<Rows,Inter,Cols>(lhs, rhs, ret);
01013   }
01014 };
01015 
01016 
01017 template <int Rows, int Inter, int Cols, class LMAccessor, class RMAccessor>
01018 inline Matrix<Rows,Cols> operator*(const FixedMatrix<Rows,Inter,LMAccessor>& lhs,
01019                                    const FixedMatrix<Inter,Cols,RMAccessor>& rhs){
01020   return Matrix<Rows,Cols>(lhs,rhs,
01021                            Operator<FixedMMMult<Rows,Inter,Cols,
01022                            FixedMatrix<Rows,Inter,LMAccessor>,
01023                            FixedMatrix<Inter,Cols,RMAccessor>,
01024                            (Rows*Inter*Cols>NUMERICS::MaxCPPMultCount ? NUMERICS::BlasMult : NUMERICS::CPPMult) > >());
01025 }
01026 
01027 
01028 template<class LHS, class RHS>
01029 struct DynamicMMMult : public MSizer{
01030   inline static void eval(Matrix<>& ret, const LHS& lhs, const RHS& rhs){
01031     set_size(ret,lhs.num_rows(),rhs.num_cols());
01032     //if(lhs.num_rows()*lhs.num_cols()*rhs.num_cols() > NUMERICS::MaxCPPMultCount){
01033      // blasmmmult(ret,lhs,rhs);
01034     //} else {
01035       cppmmmult(ret,lhs,rhs);
01036     //}
01037   }
01038 };
01039 
01040 template<int Rows, int Cols, class LMAccessor, class RMAccessor>
01041 inline Matrix<> operator*(const FixedMatrix<Rows,Cols,LMAccessor>& lhs,
01042                           const DynamicMatrix<RMAccessor>& rhs){
01043   assert(rhs.num_rows()==Cols);
01044   return Matrix<>(lhs,rhs,
01045                   Operator<DynamicMMMult<
01046                   FixedMatrix<Rows,Cols,LMAccessor>,
01047                   DynamicMatrix<RMAccessor> > > ());
01048 }
01049 
01050 
01051 template<int Rows, int Cols, class LMAccessor, class RMAccessor>
01052 inline Matrix<> operator*(const DynamicMatrix<LMAccessor>& lhs,
01053                           const FixedMatrix<Rows,Cols,RMAccessor>& rhs){
01054   assert(lhs.num_cols()==Rows);
01055   return Matrix<>(lhs,rhs,
01056                   Operator<DynamicMMMult<
01057                   DynamicMatrix<LMAccessor>,
01058                   FixedMatrix<Rows,Cols,RMAccessor> > > ());
01059 }
01060 
01061 template <class LMAccessor, class RMAccessor>
01062 inline Matrix<> operator*(const DynamicMatrix<LMAccessor>& lhs,
01063                           const DynamicMatrix<RMAccessor>& rhs){
01064   assert(lhs.num_cols() == rhs.num_rows());
01065   return Matrix<>(lhs,rhs,
01066                   Operator<DynamicMMMult<
01067                   DynamicMatrix<LMAccessor>,
01068                   DynamicMatrix<RMAccessor> > >());
01069 }
01070 
01071 
01072 
01074 // Multiplication treating a vector as a diagonal matrix
01075 
01077 //                     //
01078 // diagmult()          //
01079 // Vector * Vector     //
01080 //                     //
01082 
01083 template <class LHS, class RHS, int Size>
01084 struct DiagVVMult {
01085   inline static void eval(Vector<Size>& ret, const LHS& lhs, const RHS& rhs){
01086     for(int i=0; i<Size; i++){
01087       ret[i] = lhs[i]*rhs[i];
01088     }
01089   }
01090 };
01091 
01092 template <class Accessor1, class Accessor2, int Size>
01093 Vector<Size> diagmult(const FixedVector<Size,Accessor1>& lhs, const FixedVector<Size,Accessor2>& rhs){
01094   return Vector<Size>(lhs,rhs,Operator<DiagVVMult<FixedVector<Size,Accessor1>,FixedVector<Size,Accessor2>,Size> >());
01095 }
01096 
01097 
01098 template<class LHS, class RHS>
01099 struct DynamicDiagVVMult : public VSizer {
01100   inline static void eval(Vector<>& ret, const LHS& lhs, const RHS& rhs){
01101     assert(lhs.size() == rhs.size());
01102     const int Size = lhs.size();
01103     set_size(ret,Size);
01104     for(int i=0; i<Size; i++){
01105       ret[i] = lhs[i] * rhs[i];
01106     }
01107   }
01108 };
01109 
01110 template<class Accessor1, class Accessor2>
01111 Vector<> diagmult(const DynamicVector<Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
01112   return Vector<>(lhs,rhs,Operator<DynamicDiagVVMult<DynamicVector<Accessor1>,DynamicVector<Accessor2> > >());
01113 }
01114 
01115 template<class Accessor1, class Accessor2, int Size>
01116 Vector<> diagmult(const FixedVector<Size,Accessor1>& lhs, const DynamicVector<Accessor2>& rhs){
01117   return Vector<>(lhs,rhs,Operator<DynamicDiagVVMult<FixedVector<Size,Accessor1>,DynamicVector<Accessor2> > >());
01118 }
01119 
01120 template<class Accessor1, class Accessor2, int Size>
01121 Vector<> diagmult(const DynamicVector<Accessor1>& lhs, const FixedVector<Size,Accessor2>& rhs){
01122   return Vector<>(lhs,rhs,Operator<DynamicDiagVVMult<DynamicVector<Accessor1>,FixedVector<Size,Accessor2> > >());
01123 }
01124 
01126 //                     //
01127 // diagmult()          //
01128 // Vector * Matrix     //
01129 //                     //
01131 
01132 
01133 template <class LHS, class RHS, int Rows, int Cols>
01134 struct DiagVMMult {
01135   inline static void eval(Matrix<Rows,Cols>& ret, const LHS& lhs, const RHS& rhs){
01136     for(int c=0; c<Cols; c++){
01137       ret.T()[c] = diagmult(lhs,rhs.T()[c]);
01138     }
01139   }
01140 };
01141 
01142 template <class Accessor1, class Accessor2, int Rows, int Cols>
01143 inline Matrix<Rows,Cols> diagmult(const FixedVector<Rows, Accessor1>& lhs, const FixedMatrix<Rows,Cols,Accessor2>& rhs){
01144   return Matrix<Rows,Cols> (lhs,rhs,Operator<DiagVMMult<FixedVector<Rows, Accessor1>,FixedMatrix<Rows,Cols,Accessor2>,Rows,Cols> >());
01145 }
01146 
01147 
01148 
01149 template<class LHS, class RHS>
01150 struct DynamicDiagVMMult : public MSizer {
01151   inline static void eval(Matrix<>& ret, const LHS& lhs, const RHS& rhs){
01152     assert(lhs.size() == rhs.num_rows());
01153     const int Rows = rhs.num_rows();
01154     const int Cols = rhs.num_cols();
01155     set_size(ret,Rows,Cols);
01156     for(int r=0; r<Rows; r++){
01157       for(int c=0; c<Cols; c++){
01158         ret(r,c) = lhs[r] * rhs(r,c);
01159       }
01160     }
01161   }
01162 };
01163 
01164 template<class Accessor1, class Accessor2>
01165 inline Matrix<> diagmult(const DynamicVector<Accessor1>& lhs, const DynamicMatrix<Accessor2>& rhs){
01166   return Matrix<>(lhs,rhs,Operator<DynamicDiagVMMult<DynamicVector<Accessor1>,DynamicMatrix<Accessor2> > >());
01167 }
01168 
01169 template<class Accessor1, class Accessor2, int Size>
01170 inline Matrix<> diagmult(const FixedVector<Size,Accessor1>& lhs, const DynamicMatrix<Accessor2>& rhs){
01171   return Matrix<>(lhs,rhs,Operator<DynamicDiagVMMult<FixedVector<Size,Accessor1>,DynamicMatrix<Accessor2> > >());
01172 }
01173 
01174 template<class Accessor1, class Accessor2, int Rows, int Cols>
01175 inline Matrix<> diagmult(const DynamicVector<Accessor1>& lhs, const FixedMatrix<Rows,Cols,Accessor2>& rhs){
01176   return Matrix<>(lhs,rhs,Operator<DynamicDiagVMMult<DynamicVector<Accessor1>,FixedMatrix<Rows,Cols,Accessor2> > >());
01177 }
01178 
01180 //                     //
01181 // diagmult()          //
01182 // Matrix * Vector     //
01183 //                     //
01185 
01186 
01187 template <class LHS, class RHS, int Rows, int Cols>
01188 struct DiagMVMult {
01189   inline static void eval(Matrix<Rows,Cols>& ret, const LHS& lhs, const RHS& rhs){
01190     for(int r=0; r<Rows; r++){
01191       ret[r] = diagmult(lhs[r],rhs);
01192     }
01193   }
01194 };
01195 
01196 template <class Accessor1, class Accessor2, int Rows, int Cols>
01197 inline Matrix<Rows,Cols> diagmult(const FixedMatrix<Rows,Cols,Accessor1>& lhs, const FixedVector<Cols,Accessor2>& rhs){
01198   return Matrix<Rows,Cols> (lhs,rhs,Operator<DiagMVMult<FixedMatrix<Rows,Cols,Accessor1>,FixedVector<Cols,Accessor2>,Rows,Cols > >());
01199 }
01200 
01201 
01202 
01203 template<class LHS, class RHS>
01204 struct DynamicDiagMVMult : public MSizer {
01205   inline static void eval(Matrix<>& ret, const LHS& lhs, const RHS& rhs){
01206     assert(rhs.size() == lhs.num_cols());
01207     const int Rows = lhs.num_rows();
01208     const int Cols = lhs.num_cols();
01209     set_size(ret,Rows,Cols);
01210     for(int r=0; r<Rows; r++){
01211       for(int c=0; c<Cols; c++){
01212         ret(r,c) = lhs(r,c) * rhs[c];
01213       }
01214     }
01215   }
01216 };
01217 
01218 template<class Accessor1, class Accessor2>
01219 inline Matrix<> diagmult(const DynamicMatrix<Accessor1>& lhs,  const DynamicVector<Accessor2>& rhs){
01220   return Matrix<>(lhs,rhs,Operator<DynamicDiagMVMult<DynamicMatrix<Accessor1>, DynamicVector<Accessor2> > >());
01221 }
01222 
01223 template<class Accessor1, class Accessor2, int Size>
01224 inline Matrix<> diagmult(const DynamicMatrix<Accessor1>& lhs,  const FixedVector<Size,Accessor2>& rhs){
01225   return Matrix<>(lhs,rhs,Operator<DynamicDiagMVMult<DynamicMatrix<Accessor1>, FixedVector<Size,Accessor2> > >());
01226 }
01227 
01228 template<class Accessor1, class Accessor2, int Rows, int Cols>
01229 inline Matrix<> diagmult(const FixedMatrix<Rows,Cols,Accessor1>& lhs,  const DynamicVector<Accessor2>& rhs){
01230   return Matrix<>(lhs,rhs,Operator<DynamicDiagMVMult<FixedMatrix<Rows,Cols,Accessor1>, DynamicVector<Accessor2> > >());
01231 }
01232 
01233 #endif

Generated on Fri Feb 22 18:26:54 2008 for QVision by  doxygen 1.5.3