src/OpenFOAM/primitives/VectorSpace/VectorSpaceI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "error.H"
  27 #include "products.H"
  28 #include "VectorSpaceM.H"
  29 #include "ops.H"
  30
  31 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  32
  33 namespace Foam
  34 {
  35
  36 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  37
  38 template<class Form, class Cmpt, int nCmpt>
  39 inline VectorSpace<Form, Cmpt, nCmpt>::VectorSpace()
  40 {}
  41
  42
  43 template<class Form, class Cmpt, int nCmpt>
  44 inline VectorSpace<Form, Cmpt, nCmpt>::VectorSpace
  45 (
  46     const VectorSpace<Form, Cmpt, nCmpt>& vs
  47 )
  48 {
  49     VectorSpaceOps<nCmpt,0>::eqOp(*this, vs, eqOp<Cmpt>());
  50 }
  51
  52
  53 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  54
  55 template<class Form, class Cmpt, int nCmpt>
  56 inline label VectorSpace<Form, Cmpt, nCmpt>::size() const
  57 {
  58     return nCmpt;
  59 }
  60
  61
  62 template<class Form, class Cmpt, int nCmpt>
  63 inline const Cmpt& VectorSpace<Form, Cmpt, nCmpt>::component
  64 (
  65     const direction d
  66 ) const
  67 {
  68 #   ifdef FULLDEBUG
  69     if (d >= nCmpt)
  70     {
  71         FatalErrorIn
  72         (
  73             "VectorSpace<Form, Cmpt, nCmpt>::component(direction) const"
  74         )   << "index out of range"
  75             << abort(FatalError);
  76     }
  77 #   endif
  78
  79     return v_[d];
  80 }
  81
  82
  83 template<class Form, class Cmpt, int nCmpt>
  84 inline Cmpt& VectorSpace<Form, Cmpt, nCmpt>::component
  85 (
  86     const direction d
  87 )
  88 {
  89 #   ifdef FULLDEBUG
  90     if (d >= nCmpt)
  91     {
  92         FatalErrorIn("VectorSpace<Form, Cmpt, nCmpt>::component(direction)")
  93             << "index out of range"
  94             << abort(FatalError);
  95     }
  96 #   endif
  97
  98     return v_[d];
  99 }
 100
 101
 102 template<class Form, class Cmpt, int nCmpt>
 103 inline void VectorSpace<Form, Cmpt, nCmpt>::component
 104 (
 105     Cmpt& c,
 106     const direction d
 107 ) const
 108 {
 109 #   ifdef FULLDEBUG
 110     if (d >= nCmpt)
 111     {
 112         FatalErrorIn
 113         (
 114             "VectorSpace<Form, Cmpt, nCmpt>::component(Cmpt&, direction) const"
 115         )   << "index out of range"
 116             << abort(FatalError);
 117     }
 118 #   endif
 119
 120     c = v_[d];
 121 }
 122
 123
 124 template<class Form, class Cmpt, int nCmpt>
 125 inline void VectorSpace<Form, Cmpt, nCmpt>::replace
 126 (
 127     const direction d,
 128     const Cmpt& c
 129 )
 130 {
 131 #   ifdef FULLDEBUG
 132     if (d >= nCmpt)
 133     {
 134         FatalErrorIn
 135         (
 136             "VectorSpace<Form, Cmpt, nCmpt>::"
 137             "replace(direction, const Cmpt&) const"
 138         )   << "index out of range"
 139             << abort(FatalError);
 140     }
 141 #   endif
 142
 143     v_[d] = c;
 144 }
 145
 146
 147 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 148
 149 template<class Form, class Cmpt, int nCmpt>
 150 inline const Cmpt& VectorSpace<Form, Cmpt, nCmpt>::operator[]
 151 (
 152     const direction d
 153 ) const
 154 {
 155 #   ifdef FULLDEBUG
 156     if (d >= nCmpt)
 157     {
 158         FatalErrorIn
 159         (
 160             "VectorSpace<Form, Cmpt, nCmpt>::operator[](direction d) const"
 161         )   << "index out of range"
 162             << abort(FatalError);
 163     }
 164 #   endif
 165
 166     return v_[d];
 167 }
 168
 169
 170 template<class Form, class Cmpt, int nCmpt>
 171 inline Cmpt& VectorSpace<Form, Cmpt, nCmpt>::operator[]
 172 (
 173     const direction d
 174 )
 175 {
 176 #   ifdef FULLDEBUG
 177     if (d >= nCmpt)
 178     {
 179         FatalErrorIn("VectorSpace<Form, Cmpt, nCmpt>::operator[](direction d)")
 180             << "index out of range"
 181             << abort(FatalError);
 182     }
 183 #   endif
 184
 185     return v_[d];
 186 }
 187
 188
 189 template<class Form, class Cmpt, int nCmpt>
 190 inline void VectorSpace<Form, Cmpt, nCmpt>::operator=
 191 (
 192     const VectorSpace<Form, Cmpt, nCmpt>& vs
 193 )
 194 {
 195     VectorSpaceOps<nCmpt,0>::eqOp(*this, vs, eqOp<Cmpt>());
 196 }
 197
 198
 199 template<class Form, class Cmpt, int nCmpt>
 200 inline void VectorSpace<Form, Cmpt, nCmpt>::operator+=
 201 (
 202     const VectorSpace<Form, Cmpt, nCmpt>& vs
 203 )
 204 {
 205     VectorSpaceOps<nCmpt,0>::eqOp(*this, vs, plusEqOp<Cmpt>());
 206 }
 207
 208
 209 template<class Form, class Cmpt, int nCmpt>
 210 inline void VectorSpace<Form, Cmpt, nCmpt>::operator-=
 211 (
 212     const VectorSpace<Form, Cmpt, nCmpt>& vs
 213 )
 214 {
 215     VectorSpaceOps<nCmpt,0>::eqOp(*this, vs, minusEqOp<Cmpt>());
 216 }
 217
 218
 219 template<class Form, class Cmpt, int nCmpt>
 220 inline void VectorSpace<Form, Cmpt, nCmpt>::operator*=
 221 (
 222     const scalar s
 223 )
 224 {
 225     VectorSpaceOps<nCmpt,0>::eqOpS(*this, s, multiplyEqOp2<Cmpt, scalar>());
 226 }
 227
 228
 229 template<class Form, class Cmpt, int nCmpt>
 230 inline void VectorSpace<Form, Cmpt, nCmpt>::operator/=
 231 (
 232     const scalar s
 233 )
 234 {
 235     VectorSpaceOps<nCmpt,0>::eqOpS(*this, s, divideEqOp2<Cmpt, scalar>());
 236 }
 237
 238
 239 // * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
 240
 241 template<class Form, class Cmpt, int nCmpt>
 242 inline Cmpt& setComponent
 243 (
 244     VectorSpace<Form, Cmpt, nCmpt>& vs,
 245     const direction d
 246 )
 247 {
 248     return vs.component(d);
 249 }
 250
 251
 252 template<class Form, class Cmpt, int nCmpt>
 253 inline const Cmpt& component
 254 (
 255     const VectorSpace<Form, Cmpt, nCmpt>& vs,
 256     const direction d
 257 )
 258 {
 259     return vs.component(d);
 260 }
 261
 262
 263 // Powers of a Form
 264 // Equivalent to outer-products between the Form and itself
 265 // Form^0 = 1.0
 266 template<class Form, class Cmpt, int nCmpt>
 267 inline typename powProduct<Form, 0>::type pow
 268 (
 269     const VectorSpace<Form, Cmpt, nCmpt>&,
 270     typename powProduct<Form, 0>::type
 271     = pTraits<typename powProduct<Form, 0>::type>::zero
 272 )
 273 {
 274     return 1.0;
 275 }
 276
 277 // Form^1 = Form
 278 template<class Form, class Cmpt, int nCmpt>
 279 inline typename powProduct<Form, 1>::type pow
 280 (
 281     const VectorSpace<Form, Cmpt, nCmpt>& v,
 282     typename powProduct<Form, 1>::type
 283   = pTraits<typename powProduct<Form, 1>::type>::zero
 284 )
 285 {
 286     return static_cast<const Form&>(v);
 287 }
 288
 289
 290 // Form^2 = sqr(Form)
 291 template<class Form, class Cmpt, int nCmpt>
 292 inline typename powProduct<Form, 2>::type pow
 293 (
 294     const VectorSpace<Form, Cmpt, nCmpt>& v,
 295     typename powProduct<Form, 2>::type
 296   = pTraits<typename powProduct<Form, 2>::type>::zero
 297 )
 298 {
 299     return sqr(static_cast<const Form&>(v));
 300 }
 301
 302
 303 template<class Form, class Cmpt, int nCmpt>
 304 inline scalar magSqr
 305 (
 306     const VectorSpace<Form, Cmpt, nCmpt>& vs
 307 )
 308 {
 309     scalar ms = magSqr(vs.v_[0]);
 310     VectorSpaceOps<nCmpt,1>::SeqOp(ms, vs, plusEqMagSqrOp2<scalar, Cmpt>());
 311     return ms;
 312 }
 313
 314
 315 template<class Form, class Cmpt, int nCmpt>
 316 inline scalar mag
 317 (
 318     const VectorSpace<Form, Cmpt, nCmpt>& vs
 319 )
 320 {
 321     return ::sqrt(magSqr(static_cast<const Form&>(vs)));
 322 }
 323
 324
 325 template<class Form, class Cmpt, int nCmpt>
 326 inline VectorSpace<Form, Cmpt, nCmpt> cmptMultiply
 327 (
 328     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 329     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 330 )
 331 {
 332     Form v;
 333     VectorSpaceOps<nCmpt,0>::op(v, vs1, vs2, cmptMultiplyOp<Cmpt>());
 334     return v;
 335 }
 336
 337
 338 template<class Form, class Cmpt, int nCmpt>
 339 inline VectorSpace<Form, Cmpt, nCmpt> cmptDivide
 340 (
 341     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 342     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 343 )
 344 {
 345     Form v;
 346     VectorSpaceOps<nCmpt,0>::op(v, vs1, vs2, cmptDivideOp<Cmpt>());
 347     return v;
 348 }
 349
 350
 351 template<class Form, class Cmpt, int nCmpt>
 352 inline VectorSpace<Form, Cmpt, nCmpt> stabilise
 353 (
 354     const VectorSpace<Form, Cmpt, nCmpt>& vs,
 355     const Cmpt& small
 356 )
 357 {
 358     Form v;
 359     VectorSpaceOps<nCmpt,0>::opVS(v, vs, small, stabiliseOp<Cmpt>());
 360     return v;
 361 }
 362
 363
 364 template<class Form, class Cmpt, int nCmpt>
 365 inline Cmpt cmptMax
 366 (
 367     const VectorSpace<Form, Cmpt, nCmpt>& vs
 368 )
 369 {
 370     Cmpt cMax = vs.v_[0];
 371     VectorSpaceOps<nCmpt,1>::SeqOp(cMax, vs, maxEqOp<Cmpt>());
 372     return cMax;
 373 }
 374
 375
 376 template<class Form, class Cmpt, int nCmpt>
 377 inline Cmpt cmptMin
 378 (
 379     const VectorSpace<Form, Cmpt, nCmpt>& vs
 380 )
 381 {
 382     Cmpt cMin = vs.v_[0];
 383     VectorSpaceOps<nCmpt,1>::SeqOp(cMin, vs, minEqOp<Cmpt>());
 384     return cMin;
 385 }
 386
 387
 388 template<class Form, class Cmpt, int nCmpt>
 389 inline Cmpt cmptSum
 390 (
 391     const VectorSpace<Form, Cmpt, nCmpt>& vs
 392 )
 393 {
 394     Cmpt sum = vs.v_[0];
 395     VectorSpaceOps<nCmpt,1>::SeqOp(sum, vs, plusEqOp<Cmpt>());
 396     return sum;
 397 }
 398
 399
 400 template<class Form, class Cmpt, int nCmpt>
 401 inline Cmpt cmptAv
 402 (
 403     const VectorSpace<Form, Cmpt, nCmpt>& vs
 404 )
 405 {
 406     return cmptSum(vs)/nCmpt;
 407 }
 408
 409 template<class Form, class Cmpt, int nCmpt>
 410 inline Cmpt cmptProduct
 411 (
 412     const VectorSpace<Form, Cmpt, nCmpt>& vs
 413 )
 414 {
 415     Cmpt product = vs.v_[0];
 416     VectorSpaceOps<nCmpt,1>::SeqOp(product, vs, multiplyEqOp<Cmpt>());
 417     return product;
 418 }
 419
 420
 421 template<class Form, class Cmpt, int nCmpt>
 422 inline Form cmptMag
 423 (
 424     const VectorSpace<Form, Cmpt, nCmpt>& vs
 425 )
 426 {
 427     Form v;
 428     VectorSpaceOps<nCmpt,0>::eqOp(v, vs, eqMagOp<Cmpt>());
 429     return v;
 430 }
 431
 432
 433 template<class Form, class Cmpt, int nCmpt>
 434 inline Form max
 435 (
 436     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 437     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 438 )
 439 {
 440     Form v;
 441     VectorSpaceOps<nCmpt,0>::op(v, vs1, vs2, maxOp<Cmpt>());
 442     return v;
 443 }
 444
 445
 446 template<class Form, class Cmpt, int nCmpt>
 447 inline Form min
 448 (
 449     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 450     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 451 )
 452 {
 453     Form v;
 454     VectorSpaceOps<nCmpt,0>::op(v, vs1, vs2, minOp<Cmpt>());
 455     return v;
 456 }
 457
 458
 459 template<class Form, class Cmpt, int nCmpt>
 460 inline Form minMod
 461 (
 462     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 463     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 464 )
 465 {
 466     Form v;
 467     VectorSpaceOps<nCmpt,0>::op(v, vs1, vs2, minModOp<Cmpt>());
 468     return v;
 469 }
 470
 471
 472 template<class Type>
 473 inline Type dot(const scalar s, const Type& t)
 474 {
 475     return s * t;
 476 }
 477
 478
 479 template<class Type>
 480 inline Type dot(const Type& t, const scalar s)
 481 {
 482     return t * s;
 483 }
 484
 485
 486 template
 487 <
 488     class Form1, class Cmpt1, int nCmpt1,
 489     class Form2, class Cmpt2, int nCmpt2
 490 >
 491 inline typename innerProduct<Form1, Form2>::type dot
 492 (
 493     const VectorSpace<Form1, Cmpt1, nCmpt1>& t1,
 494     const VectorSpace<Form2, Cmpt2, nCmpt2>& t2
 495 )
 496 {
 497     return static_cast<const Form1&>(t1) & static_cast<const Form2&>(t2);
 498 }
 499
 500
 501 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 502
 503 template<class Form, class Cmpt, int nCmpt>
 504 inline Form operator-
 505 (
 506     const VectorSpace<Form, Cmpt, nCmpt>& vs
 507 )
 508 {
 509     Form v;
 510     VectorSpaceOps<nCmpt,0>::eqOp(v, vs, eqMinusOp<Cmpt>());
 511     return v;
 512 }
 513
 514
 515 template<class Form, class Cmpt, int nCmpt>
 516 inline Form operator+
 517 (
 518     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 519     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 520 )
 521 {
 522     Form v;
 523     VectorSpaceOps<nCmpt,0>::op(v, vs1, vs2, plusOp<Cmpt>());
 524     return v;
 525 }
 526
 527 template<class Form, class Cmpt, int nCmpt>
 528 inline Form operator-
 529 (
 530     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 531     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 532 )
 533 {
 534     Form v;
 535     VectorSpaceOps<nCmpt,0>::op(v, vs1, vs2, minusOp<Cmpt>());
 536     return v;
 537 }
 538
 539
 540 template<class Form, class Cmpt, int nCmpt>
 541 inline Form operator*
 542 (
 543     scalar s,
 544     const VectorSpace<Form, Cmpt, nCmpt>& vs
 545 )
 546 {
 547     Form v;
 548     VectorSpaceOps<nCmpt,0>::opSV(v, s, vs, multiplyOp3<Cmpt, scalar, Cmpt>());
 549     return v;
 550 }
 551
 552
 553 template<class Form, class Cmpt, int nCmpt>
 554 inline Form operator*
 555 (
 556     const VectorSpace<Form, Cmpt, nCmpt>& vs,
 557     scalar s
 558 )
 559 {
 560     Form v;
 561     VectorSpaceOps<nCmpt,0>::opVS(v, vs, s, multiplyOp3<Cmpt, Cmpt, scalar>());
 562     return v;
 563 }
 564
 565
 566 template<class Form, class Cmpt, int nCmpt>
 567 inline Form operator/
 568 (
 569     const VectorSpace<Form, Cmpt, nCmpt>& vs,
 570     scalar s
 571 )
 572 {
 573     Form v;
 574     VectorSpaceOps<nCmpt,0>::opVS(v, vs, s, divideOp3<Cmpt, Cmpt, scalar>());
 575     return v;
 576 }
 577
 578 /*
 579 template<class Form, class Cmpt, int nCmpt>
 580 inline Form operator/
 581 (
 582     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 583     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 584 )
 585 {
 586     Form v;
 587     VectorSpaceOps<nCmpt,0>::op(v, vs1, vs2, divideOp<Cmpt>());
 588     return v;
 589 }
 590
 591
 592 template<class Form, class Cmpt, int nCmpt>
 593 inline Form operator/
 594 (
 595     scalar s,
 596     const VectorSpace<Form, Cmpt, nCmpt>& vs
 597 )
 598 {
 599     Form v;
 600     VectorSpaceOps<nCmpt,0>::opSV(v, s, vs, divideOp2<scalar, Cmpt>());
 601     return v;
 602 }
 603 */
 604
 605
 606 template<class Form, class Cmpt, int nCmpt>
 607 inline Cmpt operator&&
 608 (
 609     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 610     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 611 )
 612 {
 613     Cmpt ddProd = vs1.v_[0]*vs2.v_[0];
 614     for (int i=1; i<nCmpt; ++i)
 615     {
 616         ddProd += vs1.v_[i]*vs2.v_[i];
 617     }
 618     return ddProd;
 619 }
 620
 621
 622 template<class Form, class Cmpt, int nCmpt>
 623 inline bool operator==
 624 (
 625     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 626     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 627 )
 628 {
 629     bool eq = true;
 630     for (int i=0; i<nCmpt; ++i)
 631     {
 632         if (!(eq &= (equal(vs1.v_[i], vs2.v_[i])))) break;
 633     }
 634     return eq;
 635 }
 636
 637
 638 template<class Form, class Cmpt, int nCmpt>
 639 inline bool operator!=
 640 (
 641     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 642     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 643 )
 644 {
 645     return !(vs1 == vs2);
 646 }
 647
 648
 649 template<class Form, class Cmpt, int nCmpt>
 650 inline bool operator>
 651 (
 652     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 653     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 654 )
 655 {
 656     bool gt = true;
 657     for (int i=0; i<nCmpt; ++i)
 658     {
 659         if (!(gt &= vs1.v_[i] > vs2.v_[i])) break;
 660     }
 661     return gt;
 662 }
 663
 664
 665 template<class Form, class Cmpt, int nCmpt>
 666 inline bool operator<
 667 (
 668     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 669     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 670 )
 671 {
 672     bool lt = true;
 673     for (int i=0; i<nCmpt; ++i)
 674     {
 675         if (!(lt &= vs1.v_[i] < vs2.v_[i])) break;
 676     }
 677     return lt;
 678 }
 679
 680
 681 template<class Form, class Cmpt, int nCmpt>
 682 inline bool operator>=
 683 (
 684     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 685     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 686 )
 687 {
 688     return !(vs1 < vs2);
 689 }
 690
 691
 692 template<class Form, class Cmpt, int nCmpt>
 693 inline bool operator<=
 694 (
 695     const VectorSpace<Form, Cmpt, nCmpt>& vs1,
 696     const VectorSpace<Form, Cmpt, nCmpt>& vs2
 697 )
 698 {
 699     return !(vs1 > vs2);
 700 }
 701
 702
 703 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 704
 705 } // End namespace Foam
 706
 707 // ************************************************************************* //