00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00041 #ifndef MAT_MATRIX_PROXY
00042 #define MAT_MATRIX_PROXY
00043
00044 namespace mat {
00045
00050 template<typename TX, typename TY>
00051 struct XY {
00052 TX const & A;
00053 TY const & B;
00054 bool const tA;
00055 bool const tB;
00056 XY(TX const & AA, TY const & BB,
00057 bool const tAA = false, bool const tBB = false)
00058 :A(AA), B(BB), tA(tAA), tB(tBB)
00059 {}
00060 };
00061
00066 template<typename TX, typename TY, typename TZ>
00067 struct XYZ {
00068 TX const & A;
00069 TY const & B;
00070 TZ const & C;
00071 bool const tA;
00072 bool const tB;
00073 bool const tC;
00074 XYZ(TX const & AA, TY const & BB, TZ const & CC,
00075 bool const tAA = false,
00076 bool const tBB = false,
00077 bool const tCC = false)
00078 :A(AA), B(BB), C(CC), tA(tAA), tB(tBB), tC(tCC)
00079 {}
00080 };
00081
00087 template<typename TX, typename TY, typename TZ, typename TU, typename TV>
00088 struct XYZpUV {
00089 TX const & A;
00090 TY const & B;
00091 TZ const & C;
00092 TU const & D;
00093 TV const & E;
00094 bool const tA;
00095 bool const tB;
00096 bool const tC;
00097 bool const tD;
00098 bool const tE;
00099 XYZpUV(TX const & AA, TY const & BB, TZ const & CC,
00100 TU const & DD, TV const & EE,
00101 bool const tAA = false,
00102 bool const tBB = false,
00103 bool const tCC = false,
00104 bool const tDD = false,
00105 bool const tEE = false)
00106 :A(AA), B(BB), C(CC), D(DD), E(EE),
00107 tA(tAA), tB(tBB), tC(tCC), tD(tDD), tE(tEE)
00108 {}
00109 };
00110
00111
00117 template<typename TX>
00118 struct Xtrans {
00119 TX const & A;
00120 bool const tA;
00121 explicit Xtrans(TX const & AA, bool const tAA = false)
00122 :A(AA), tA(tAA)
00123 {}
00124 };
00125
00130 template<typename TX>
00131 inline Xtrans<TX> transpose(TX const & A) {
00132 return Xtrans<TX>(A,true);
00133 }
00141 template<typename TX>
00142 inline Xtrans<TX> transpose(const Xtrans<TX>& xtrans) {
00143 return Xtrans<TX>(xtrans.A, !xtrans.tA);
00144 }
00145
00146
00156 template<typename TX, typename TY>
00157 inline XY<TX, TY> operator*(Xtrans<TX> const & trAA,
00158 Xtrans<TY> const & trBB) {
00159 return XY<TX, TY>(trAA.A, trBB.A, trAA.tA, trBB.tA);
00160 }
00161
00171 template<typename TX, typename TY>
00172 inline XY<TX, TY> operator*(TX const & AA,
00173 Xtrans<TY> const & trBB) {
00174 return XY<TX, TY>(AA, trBB.A, false, trBB.tA);
00175 }
00176
00186 template<typename TX, typename TY>
00187 inline XY<TX, TY> operator*(Xtrans<TX> const & trAA,
00188 TY const & BB) {
00189 return XY<TX, TY>(trAA.A, BB, trAA.tA, false);
00190 }
00191
00199 template<typename TX, typename TY>
00200 inline XY<TX, TY> operator*(TX const & AA,
00201 TY const & BB) {
00202 return XY<TX, TY>(AA, BB, false, false);
00203 }
00204
00212 template<typename TX, typename TY, typename TZ>
00213 inline XYZ<TX, TY, TZ>
00214 operator*(XY<TX, TY> const & AB, Xtrans<TZ> const & trCC) {
00215 return XYZ<TX, TY, TZ>(AB.A, AB.B, trCC.A, AB.tA, AB.tB, trCC.tA);
00216 }
00217
00223 template<typename TX, typename TY, typename TZ>
00224 inline XYZ<TX, TY, TZ>
00225 operator*(XY<TX, TY> const & AB, TZ const & CC) {
00226 return XYZ<TX, TY, TZ>(AB.A, AB.B, CC, AB.tA, AB.tB, false);
00227 }
00228
00235 template<typename TX, typename TY, typename TZ, typename TU, typename TV>
00236 inline XYZpUV<TX, TY, TZ, TU, TV>
00237 operator+(XYZ<TX, TY, TZ> const & ABC, XY<TU, TV> const & DE) {
00238 return XYZpUV<TX, TY, TZ, TU, TV>(ABC.A, ABC.B, ABC.C, DE.A, DE.B, ABC.tA, ABC.tB, ABC.tC, DE.tA, DE.tB);
00239 }
00240
00245 template<typename TX, typename TY>
00246 struct XpY {
00247 const TX& A;
00248 const TY& B;
00249 XpY(const TX& AA,const TY& BB)
00250 :A(AA),B(BB)
00251 {}
00252 };
00256 template<typename TX, typename TY>
00257 inline XpY<TX, TY> operator+(TX const & AA, TY const & BB) {
00258 return XpY<TX, TY>(AA, BB);
00259 }
00260
00265 template<typename TX, typename TY>
00266 struct XmY {
00267 const TX& A;
00268 const TY& B;
00269 XmY(const TX& AA,const TY& BB)
00270 :A(AA),B(BB)
00271 {}
00272 };
00276 template<typename TX, typename TY>
00277 inline XmY<TX, TY> operator-(TX const & AA, TY const & BB) {
00278 return XmY<TX, TY>(AA, BB);
00279 }
00280
00281
00282
00283
00284
00285 #if 0
00286 template<class MAT>
00287 struct M2 {
00288 const MAT& A;
00289 M2(const MAT& AA)
00290 :A(AA)
00291 {}
00292 };
00293
00294 template<class MAT>
00295 inline M2<MAT> square(const MAT& A) {
00296 return M2<MAT>(A);
00297 }
00298
00299 template<class SCAL, class MAT>
00300 struct SM2 {
00301 const SCAL alpha;
00302 const MAT& A;
00303 SM2(const MAT& AA, const SCAL a = 1)
00304 : A(AA), alpha(a)
00305 {}
00306 SM2(const M2<MAT>& m2)
00307 :A(m2.A), alpha(1)
00308 {}
00309 };
00310
00311 template<class SCAL, class MAT>
00312 inline SM2<SCAL, MAT>
00313 operator*(const SCAL s, const M2<MAT>& m2) {
00314 return SM2<SCAL, MAT>(m2.A, s);
00315 }
00316
00317
00318
00319
00320 template<class MAT>
00321 struct MT {
00322 const MAT& A;
00323 const bool tA;
00324 MT(const MAT& AA, const bool tAA = false)
00325 :A(AA), tA(tAA)
00326 {}
00327 };
00328
00329 template<class MAT>
00330 inline MT<MAT> transpose(const MAT& A) {
00331 return MT<MAT>(A,true);
00332 }
00333 template<class MAT>
00334 inline MT<MAT> transpose(const MT<MAT>& mt) {
00335 return MT<MAT>(mt.A, !mt.tA);
00336 }
00337
00338
00339 template<class SCAL, class MAT>
00340 struct SM {
00341 const SCAL alpha;
00342 const MAT& A;
00343 const bool tA;
00344 SM(const MAT& AA, const SCAL scalar = 1, const bool tAA = false)
00345 :A(AA),alpha(scalar), tA(tAA)
00346 {}
00347 };
00348
00349 template<class SCAL, class MAT>
00350 inline SM<SCAL, MAT> operator*(const SCAL scalar, const MT<MAT>& mta) {
00351 return SM<SCAL, MAT>(mta.A,scalar, mta.tA);
00352 }
00353
00354 template<class SCAL, class MAT>
00355 inline SM<SCAL, MAT> operator*(const SCAL scalar, const MAT& AA) {
00356 return SM<SCAL, MAT>(AA, scalar, false);
00357 }
00358
00359
00360
00361 template<class MAT, class MATB = MAT>
00362 struct MM {
00363 const MAT& A;
00364 const MATB& B;
00365 const bool tA;
00366 const bool tB;
00367 MM(const MAT& AA,const MATB& BB, const bool tAA, const bool tBB)
00368 :A(AA),B(BB), tA(tAA), tB(tBB)
00369 {}
00370 };
00371
00372 template<class MAT, class MATB = MAT>
00373 struct MpM {
00374 const MAT& A;
00375 const MATB& B;
00376 MpM(const MAT& AA,const MATB& BB)
00377 :A(AA),B(BB)
00378 {}
00379 };
00380
00381 template<class MAT, class MATB>
00382 inline MpM<MAT, MATB> operator+(const MAT& AA, const MATB& BB) {
00383 return MpM<MAT, MATB>(AA, BB);
00384 }
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407 template<class SCAL, class MAT, class MATB = MAT>
00408 struct SMM {
00409 const SCAL alpha;
00410 const MAT& A;
00411 const MATB& B;
00412 const bool tA;
00413 const bool tB;
00414 SMM(const MM<MAT, MATB>& mm)
00415 :A(mm.A),B(mm.B),alpha(1), tA(mm.tA), tB(mm.tB)
00416 {}
00417 SMM(const MAT& AA,const MATB& BB,
00418 const bool tAA, const bool tBB,
00419 const SCAL a = 1)
00420 :A(AA), B(BB), tA(tAA), tB(tBB), alpha(a)
00421 {}
00422 };
00423
00424 template<class SCAL, class MAT, class MATB>
00425 inline SMM<SCAL, MAT, MATB>
00426 operator*(const SM<SCAL, MAT>& sm,const MT<MATB>& mtb) {
00427 return SMM<SCAL, MAT, MATB>(sm.A, mtb.A, sm.tA, mtb.tA, sm.alpha);
00428 }
00429
00430 template<class SCAL, class MAT, class MATB>
00431 inline SMM<SCAL, MAT, MATB>
00432 operator*(const SM<SCAL, MAT>& sm,const MATB& BB) {
00433 return SMM<SCAL, MAT, MATB>(sm.A, BB, sm.tA, false, sm.alpha);
00434 }
00435
00436 template<class SCAL, class MATC, class MATA = MATC, class MATB = MATC>
00437 struct SMMpSM {
00438 const SCAL alpha;
00439 const MATA& A;
00440 const MATB& B;
00441 const SCAL beta;
00442 const MATC& C;
00443 const bool tA;
00444 const bool tB;
00445 SMMpSM(const MATA& AA, const MATB& BB, const MATC& CC,
00446 const bool tAA, const bool tBB,
00447 const SCAL a=1, const SCAL b=1)
00448 :A(AA), B(BB), C(CC), alpha(a), beta(b), tA(tAA), tB(tBB)
00449 {}
00450 };
00451
00452 template<class SCAL, class MATC, class MATA, class MATB>
00453 inline SMMpSM<SCAL, MATC, MATA, MATB>
00454 operator+(const SMM<SCAL, MATA, MATB>& smm, const SM<SCAL, MATC>& sm) {
00455 return SMMpSM<SCAL, MATC, MATA, MATB>
00456 (smm.A, smm.B, sm.A, smm.tA, smm.tB, smm.alpha, sm.alpha);
00457 }
00458 #if 0
00459
00460 template<class SCAL, class MATC, class MATA, class MATB>
00461 inline SMMpSM<SCAL, MATC, MATA, MATB>
00462 operator+(const SMM<SCAL, MATA, MATB>& smm, MATC& CC) {
00463 return SMMpSM<SCAL, MATC, MATA, MATB>
00464 (smm.A, smm.B, CC, smm.tA, smm.tB, smm.alpha, 1);
00465 }
00466 template<class SCAL, class MATC, class MATA, class MATB>
00467 inline SMMpSM<SCAL, MATC, MATA, MATB>
00468 operator+(const MM<MATA, MATB>& mm, const SM<SCAL, MATC>& sm) {
00469 return SMMpSM<SCAL, MATC, MATA, MATB>
00470 (mm.A, mm.B, sm.A, mm.tA, mm.tB, 1, sm.alpha);
00471 }
00472 #endif
00473
00474
00475 template<class SCAL, class MAT>
00476 struct SM2pSM {
00477 const SCAL alpha;
00478 const MAT& A;
00479 const SCAL beta;
00480 const MAT& C;
00481 SM2pSM(const MAT& AA, const MAT& CC, const SCAL a = 1, const SCAL b = 0)
00482 : A(AA), alpha(a), C(CC), beta(b)
00483 {}
00484 };
00485
00486 template<class SCAL, class MAT>
00487 inline SM2pSM<SCAL, MAT>
00488 operator+(const SM2<SCAL, MAT>& sm2, const SM<SCAL, MAT> sm) {
00489 return SM2pSM<SCAL, MAT>(sm2.A, sm.A, sm2.alpha, sm.alpha);
00490 }
00491
00492
00493
00494
00495
00496 template<class MAT>
00497 struct MMpM {
00498 const MAT& A;
00499 const MAT& B;
00500 const MAT& C;
00501 MMpM(const MAT& AA, const MAT& BB, const MAT& CC)
00502 :A(AA),B(BB),C(CC)
00503 {}
00504 };
00505
00506
00507 template<class SCAL, class MAT>
00508 struct SMpSM {
00509 const SCAL alpha, beta;
00510 const MAT& A, B;
00511 SMpSM(const MAT& AA, const MAT& BB,
00512 const SCAL scalar_a=1, const SCAL scalar_b=1)
00513 :A(AA), B(BB), alpha(scalar_a), beta(scalar_b)
00514 {}
00515 };
00516
00517 template<class SCAL, class MAT>
00518 inline SMpSM<SCAL, MAT>
00519 operator+(const SM<SCAL, MAT> sm1, const SM<SCAL, MAT> sm2 ) {
00520 return SMpSM<SCAL, MAT>(sm1.A, sm2.A, sm1.alpha, sm2.alpha);
00521 }
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538 template<class MAT>
00539 struct MmM {
00540 const MAT& A;
00541 const MAT& B;
00542 MmM(const MAT& AA,const MAT& BB)
00543 :A(AA),B(BB)
00544 {}
00545 };
00546
00547 template<class MAT>
00548 inline MmM<MAT> operator-(const MAT& A, const MAT& B) {
00549 return MmM<MAT>(A,B);
00550 }
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579 #endif
00580 }
00581 #endif