00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
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
00044
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
00081
00082
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
00164
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
00203
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
00232
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
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
00312
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
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
00387
00388
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
00434
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
00456
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
00474
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
00489
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
00521
00522
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
00543
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
00613
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
00648
00649
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
00700
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
00715
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
00731
00733
00734 template <class Accessor>
00735 inline void operator/=(MatrixBase<Accessor>& lhs, double rhs){
00736 lhs*=(1.0/rhs);
00737 }
00738
00740
00741
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
00809
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
00854
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
00922
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
00975
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
01003
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
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
01033
01034
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
01075
01077
01078
01079
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
01128
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
01182
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