JMatrix3S.hh

Go to the documentation of this file.

#ifndef __JMATRIX3S__
#define __JMATRIX3S__
 
#include <cmath>
#include <algorithm>
 
#include "JMath/JMatrix3D.hh"
#include "JLang/JException.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JMATH {}
namespace JPP { using namespace JMATH; }
 
namespace JMATH {
 
  using JLANG::JDivisionByZero;
 
 
  /**
   * 3 x 3 symmetric matrix
   */
  class JMatrix3S :
    public JMatrix3D
  {
  public:
    /**
     * Default constructor.
     */
    JMatrix3S() :
      JMatrix3D()
    {}
 
 
    /**
     * Contructor.
     *
     * \param   A      matrix
     */
    JMatrix3S(const JMatrix3D& A) :
      JMatrix3D(A)
    {}
 
 
    /**
     * Contructor.
     *
     * \param   __a00   (0,0)
     * \param   __a01   (0,1)
     * \param   __a02   (0,2)
     * \param   __a11   (1,1)
     * \param   __a12   (1,2)
     * \param   __a22   (2,2)
     */
    JMatrix3S(const double __a00, const double __a01, const double __a02,
              /*               */ const double __a11, const double __a12,
              /*                                   */ const double __a22) :
      JMatrix3D(__a00, __a01, __a02,
                __a01, __a11, __a12,
                __a02, __a12, __a22)
    {}
 
    
    /**
     * Invert matrix.
     */
    void invert()
    {
      using std::swap;
 
      // LDU decomposition
 
      int    p0 = 0; // permute row 0
      int    p1 = 0; // permute row 1
 
      double val;
 
      val = a00;
 
      if (fabs(a10) > fabs(val)) {
        p0  = 1;
        val = a10;
      }
 
      if (fabs(a20) > fabs(val)) {
        p0  = 2;
        val = a20;
      }
 
      switch (p0) {
 
      case 1:
        swap(a00,a10);
        swap(a01,a11);
        swap(a02,a12);
        break;
 
      case 2:
        swap(a00,a20);
        swap(a01,a21);
        swap(a02,a22);
        break;
      }
 
      if (val == 0) {
        throw JDivisionByZero("LDU decomposition zero pivot");  
      }
 
      a10 /= val;
      a11 -= a10 * a01;
      a12 -= a10 * a02;
 
      a20 /= val;
      a21 -= a20 * a01;
      a22 -= a20 * a02;
 
      val = a11;
 
      if (fabs(a21) > fabs(val)) {
        p1  = 2;
        val = a21;
      }
 
      switch (p1) {
 
      case 2:
        swap(a10,a20);
        swap(a11,a21);
        swap(a12,a22);
        break;
      }
 
      if (val == 0) {
        throw JDivisionByZero("LDU decomposition zero pivot");
      }
 
      a21 /= val;
      a22 -= a21 * a12;
 
      // invert D
 
      if (a22 == 0) {
        throw JDivisionByZero("D matrix not invertable");
      }
 
      a00  = 1.0 / a00;
      a11  = 1.0 / a11;
      a22  = 1.0 / a22;
 
      // invert U
 
      a01 *= -a00;
      a01 *=  a11;
 
      a02 *= -a00;
      a02 -=  a01 * a12;
      a02 *=  a22;
 
      a12 *= -a11;
      a12 *=  a22;
 
      // invert L
 
      a21  = -a21;
      a20  = -a20;
      a20 -=  a21 * a10;
      a10  = -a10;
 
      // U^-1 x L^-1
 
      a00 += a01 * a10  +  a02 * a20;
      a01 += a02 * a21;
      a10 *= a11;
      a10 += a12 * a20;
      a11 += a12 * a21;
      a20 *= a22;
      a21 *= a22;
 
      switch (p1) {
 
      case 2:
        swap(a01,a02);
        swap(a11,a12);
        swap(a21,a22);
        break;
      }
 
      switch (p0) {
 
      case 1:
        swap(a00,a01);
        swap(a10,a11);
        swap(a20,a21);
        break;
 
      case 2:
        swap(a00,a02);
        swap(a10,a12);
        swap(a20,a22);
        break;
      }
    }
  };
}
 
#endif