#include <matvec3.h>

Collaboration diagram for Mat3x3:

Public Member Functions
	Mat3x3 (void)

	Mat3x3 (const doublereal &m11, const doublereal &m21, const doublereal &m31, const doublereal &m12, const doublereal &m22, const doublereal &m32, const doublereal &m13, const doublereal &m23, const doublereal &m33)

	Mat3x3 (const Mat3x3 &m)

	Mat3x3 (const Vec3 &v1, const Vec3 &v2, const Vec3 &v3)

	Mat3x3 (const doublereal *pd, integer iSize)

	Mat3x3 (const Mat3x3_Manip &Manip)

	Mat3x3 (const Mat3x3_Manip &Manip, const doublereal d)

	Mat3x3 (const Mat3x3_Manip &Manip, const Vec3 &v)

	Mat3x3 (const Mat3x3_Manip &Manip, const Vec3 &v1, const Vec3 &v2)

	Mat3x3 (const doublereal &d, const Vec3 &v)

	~Mat3x3 (void)

const doublereal *	pGetMat (void) const

doublereal *	pGetMat (void)

void	Put (unsigned short int iRow, unsigned short int iCol, const doublereal &dCoef)

const doublereal &	dGet (unsigned short int iRow, unsigned short int iCol) const

doublereal &	operator() (unsigned short int iRow, unsigned short int iCol)

const doublereal &	operator() (unsigned short int iRow, unsigned short int iCol) const

const Mat3x3 &	Tens (const Vec3 &a, const Vec3 &b)

Mat3x3	Transpose (void) const

Vec3	Ax (void) const

doublereal	Trace (void) const

Mat3x3	Symm (void) const

Mat3x3	Symm2 (void) const

const Mat3x3 &	Symm (const Mat3x3 &m)

Mat3x3	Skew (void) const

const Mat3x3 &	Skew (const Mat3x3 &m)

Vec3	GetVec (unsigned short int i) const

Vec3	GetCol (unsigned short int i) const

Vec3	GetRow (unsigned short int i) const

void	PutVec (unsigned short int i, const Vec3 &v)

void	AddVec (unsigned short int i, const Vec3 &v)

void	SubVec (unsigned short int i, const Vec3 &v)

doublereal	dDet (void) const

Mat3x3	Inv (const doublereal &ddet) const

Mat3x3	Inv (void) const

Vec3	Solve (const Vec3 &v) const

Vec3	Solve (const doublereal &d, const Vec3 &v) const

Vec3	LDLSolve (const Vec3 &v) const

bool	EigSym (Vec3 &EigenValues) const

bool	EigSym (Vec3 &EigenValues, Mat3x3 &EigenVectors) const

void	GetFrom (const doublereal *pd, integer iSize)

void	AddTo (doublereal *pd, integer iNRows) const

void	PutTo (doublereal *pd, integer iNRows) const

Mat3x3 &	operator= (const Mat3x3 &m)

Mat3x3	operator+ (const Mat3x3 &m) const

Mat3x3 &	operator+= (const Mat3x3 &m)

Mat3x3	operator- (const Mat3x3 &m) const

Mat3x3 &	operator-= (const Mat3x3 &m)

Mat3x3	operator* (const doublereal &d) const

Mat3x3 &	operator*= (const doublereal &d)

Mat3x3	operator/ (const doublereal &d) const

Mat3x3 &	operator/= (const doublereal &d)

Vec3	operator* (const Vec3 &v) const

bool	IsNull (void) const

bool	IsExactlySame (const Mat3x3 &m) const

bool	IsSame (const Mat3x3 &m, const doublereal &dTol) const

bool	IsSymmetric (void) const

bool	IsSymmetric (const doublereal &dTol) const

bool	IsDiag (void) const

bool	IsDiag (const doublereal &dTol) const

Mat3x3	operator* (const Mat3x3 &m) const

Mat3x3	MulMT (const Mat3x3 &m) const

Vec3	MulTV (const Vec3 &v) const

Mat3x3	MulTM (const Mat3x3 &m) const

Mat3x3	MulTMT (const Mat3x3 &m) const

Mat3x3	MulVCross (const Vec3 &v) const

Mat3x3	MulTVCross (const Vec3 &v) const

doublereal	Tr (void) const

void	Reset (void)

std::ostream &	Write (std::ostream &out, const char sFill=" ", const char sFill2=NULL) const

Protected Attributes
doublereal	pdMat [9]

Friends
class	Vec3

class	SparseSubMatrixHandler

class	Mat3x3_Manip

class	Mat3xN

class	MatNx3

Detailed Description

Definition at line 550 of file matvec3.h.

Constructor & Destructor Documentation

Mat3x3::Mat3x3 ( void )

inline

Definition at line 568 of file matvec3.h.

References NO_OP.

Referenced by Inv(), MulMT(), MulTM(), MulTMT(), MulTVCross(), MulVCross(), operator*(), operator+(), operator-(), operator/(), Skew(), Symm(), Symm2(), and Transpose().

                 {
       NO_OP;
    };

Mat3x3::Mat3x3	(	const doublereal &	m11,
		const doublereal &	m21,
		const doublereal &	m31,
		const doublereal &	m12,
		const doublereal &	m22,
		const doublereal &	m32,
		const doublereal &	m13,
		const doublereal &	m23,
		const doublereal &	m33
	)

inline

Definition at line 581 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

                                                                                {
       pdMat[M11] = m11;
       pdMat[M21] = m21;
       pdMat[M31] = m31;
       pdMat[M12] = m12;
       pdMat[M22] = m22;
       pdMat[M32] = m32;
       pdMat[M13] = m13;
       pdMat[M23] = m23;
       pdMat[M33] = m33;      
    };

Mat3x3::Mat3x3 ( const Mat3x3 & m )

inline

Definition at line 598 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

                            {
       pdMat[M11] = m.pdMat[M11];
       pdMat[M21] = m.pdMat[M21];
       pdMat[M31] = m.pdMat[M31];
       pdMat[M12] = m.pdMat[M12];
       pdMat[M22] = m.pdMat[M22];
       pdMat[M32] = m.pdMat[M32];
       pdMat[M13] = m.pdMat[M13];
       pdMat[M23] = m.pdMat[M23];
       pdMat[M33] = m.pdMat[M33];
    };

Mat3x3::Mat3x3	(	const Vec3 &	v1,
		const Vec3 &	v2,
		const Vec3 &	v3
	)

inline

Definition at line 653 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, pdMat, Vec3::pdVec, V1, V2, and V3.

                                                           {
       pdMat[M11] = v1.pdVec[V1];
       pdMat[M21] = v1.pdVec[V2];
       pdMat[M31] = v1.pdVec[V3];
 
       pdMat[M12] = v2.pdVec[V1];
       pdMat[M22] = v2.pdVec[V2];
       pdMat[M32] = v2.pdVec[V3];
 
       pdMat[M13] = v3.pdVec[V1];
       pdMat[M23] = v3.pdVec[V2];
       pdMat[M33] = v3.pdVec[V3];
    };

Mat3x3::Mat3x3	(	const doublereal *	pd,
		integer	iSize
	)

inline

Definition at line 672 of file matvec3.h.

References ASSERT, and GetFrom().

                                                {
       ASSERT(pd != NULL);      
       GetFrom(pd, iSize);
    };   

Here is the call graph for this function:

Mat3x3::Mat3x3 ( const Mat3x3_Manip & Manip )

inline

Definition at line 682 of file matvec3.h.

References Mat3x3_Manip::Manipulate().

                                      {
       Manip.Manipulate(*this);
    };

Here is the call graph for this function:

Mat3x3::Mat3x3	(	const Mat3x3_Manip &	Manip,
		const doublereal	d
	)

inline

Definition at line 691 of file matvec3.h.

References Mat3x3_Manip::Manipulate().

                                                          {
       Manip.Manipulate(*this, d);
    };

Here is the call graph for this function:

Mat3x3::Mat3x3	(	const Mat3x3_Manip &	Manip,
		const Vec3 &	v
	)

inline

Definition at line 700 of file matvec3.h.

References Mat3x3_Manip::Manipulate().

                                                     {
       Manip.Manipulate(*this, v);
    };

Here is the call graph for this function:

Mat3x3::Mat3x3	(	const Mat3x3_Manip &	Manip,
		const Vec3 &	v1,
		const Vec3 &	v2
	)

inline

Definition at line 709 of file matvec3.h.

References Mat3x3_Manip::Manipulate().

                                                                      {
       Manip.Manipulate(*this, v1, v2);
    };

Here is the call graph for this function:

Mat3x3::Mat3x3	(	const doublereal &	d,
		const Vec3 &	v
	)

inline

Definition at line 718 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, pdMat, Vec3::pdVec, V1, V2, and V3.

                                               {
       pdMat[M11] = d;
       pdMat[M21] = v.pdVec[V3];
       pdMat[M31] = -v.pdVec[V2];
       pdMat[M12] = -v.pdVec[V3];
       pdMat[M22] = d;
       pdMat[M32] = v.pdVec[V1];
       pdMat[M13] = v.pdVec[V2];
       pdMat[M23] = -v.pdVec[V1];
       pdMat[M33] = d;
    };

Mat3x3::~Mat3x3 ( void )

inline

Definition at line 733 of file matvec3.h.

References NO_OP.

                  { 
       NO_OP;
    };

Member Function Documentation

void Mat3x3::AddTo	(	doublereal *	pd,
		integer	iNRows
	)		const

inline

Definition at line 1002 of file matvec3.h.

References ASSERT, M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

                                                     {
       ASSERT(pd != NULL);
       ASSERT(iNRows >= 3);
       
       doublereal* pdTo = pd;
       
       pdTo[0] += pdMat[M11];
       pdTo[1] += pdMat[M21];
       pdTo[2] += pdMat[M31];
       
       pdTo += iNRows;
       pdTo[0] += pdMat[M12];
       pdTo[1] += pdMat[M22];
       pdTo[2] += pdMat[M32];
       
       pdTo += iNRows;
       pdTo[0] += pdMat[M13];
       pdTo[1] += pdMat[M23];
       pdTo[2] += pdMat[M33];      
    };

void Mat3x3::AddVec	(	unsigned short int	i,
		const Vec3 &	v
	)

inline

Definition at line 927 of file matvec3.h.

References ASSERT, pdMat, Vec3::pdVec, V1, V2, and V3.

                                                     {
       ASSERT(i >= 1 && i <= 3);
 
       i--; i = 3*i;
       pdMat[i++] += v.pdVec[V1];
       pdMat[i++] += v.pdVec[V2];
       pdMat[i] += v.pdVec[V3];
    };

Vec3 Mat3x3::Ax ( void ) const

inline

Definition at line 827 of file matvec3.h.

References M12, M13, M21, M23, M31, M32, pdMat, and Vec3.

Referenced by MatExp::Ax(), CGR_Rot::Param_Manip::Manipulate(), MatR2gparam(), MatR2LinParam(), Skew(), and RotManip::VecRot().

                        {
       /* assumendo che sia una matrice di rotazione ?!? */
       return Vec3(
                       .5*(pdMat[M32]-pdMat[M23]),
                       .5*(pdMat[M13]-pdMat[M31]),
                       .5*(pdMat[M21]-pdMat[M12])
                       );
    };

doublereal Mat3x3::dDet ( void ) const

Definition at line 122 of file matvec3.cc.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

Referenced by EigSym(), Inv(), main(), and Solve().

 {
    doublereal* p = (doublereal*)pdMat;
 
    return p[M11]*(p[M22]*p[M33]-p[M23]*p[M32])
      +p[M12]*(p[M23]*p[M31]-p[M21]*p[M33])
      +p[M13]*(p[M21]*p[M32]-p[M22]*p[M31]);
 }

const doublereal& Mat3x3::dGet	(	unsigned short int	iRow,
		unsigned short int	iCol
	)		const

inline

Definition at line 770 of file matvec3.h.

References ASSERT, and pdMat.

Referenced by Mat6x6::dGet(), MatR2EulerParams(), operator<<(), MatExp::Write(), and Mat6x6::Write().

                                                                 {
       ASSERT(iRow >= 1 && iRow <= 3);
       ASSERT(iCol >= 1 && iCol <= 3);      
       return pdMat[--iRow+3*--iCol];
    };

bool Mat3x3::EigSym ( Vec3 & EigenValues ) const

Definition at line 255 of file matvec3.cc.

Referenced by Inertia::Collect_int().

 {
         Mat3x3 EigenVectors;
 
         return EigSym(EigenValues, EigenVectors);
 }

bool Mat3x3::EigSym	(	Vec3 &	EigenValues,
		Mat3x3 &	EigenVectors
	)		const

Definition at line 279 of file matvec3.cc.

References grad::acos(), copysign(), grad::cos(), Vec3::Cross(), dDet(), Eye3, grad::fabs(), GetVec(), IsDiag(), IsSymmetric(), M11, M22, M33, M_PI, Vec3::Norm(), pdMat, PutVec(), grad::sqrt(), Trace(), and Vec3.

 {
         // From:
         // W.M. Scherzinger, C.R. Dohrmann,
         // `A robust algorithm for finding the eigenvalues and eigenvectors
         // of 3x3 symmetric matrices'
         // Comput. Methods Appl. Mech. Engrg. 2008
         // doi:10.1016/j.cma.2008.03.031
 
         if (!IsSymmetric(std::numeric_limits<doublereal>::epsilon())) {
                 return false;
         }
 
         if (IsDiag(std::numeric_limits<doublereal>::epsilon())) {
                 EigenVectors = Eye3;
                 EigenValues = Vec3(pdMat[M11], pdMat[M22], pdMat[M33]);
 
                 return true;
         }
 
         Mat3x3 AA = *this;
 
         doublereal trA_3 = Trace()/3;
 
         AA(1, 1) -= trA_3;
         AA(2, 2) -= trA_3;
         AA(3, 3) -= trA_3;
 
         doublereal J2 = (AA*AA).Trace()/2;
 
         if (fabs(J2) < std::numeric_limits<doublereal>::epsilon()) {
                 EigenVectors = Eye3;
                 EigenValues = Vec3(pdMat[M11], pdMat[M22], pdMat[M33]);
 
                 return true;
         }
 
         doublereal J2_dmy = sqrt(J2/3.);
         doublereal J3 = AA.dDet();
         doublereal dmy = J3/2/(J2_dmy*J2_dmy*J2_dmy);
         doublereal alpha;
 
         // NOTE: we want real eigenvalues; this requires the matrix to be
         // positive definite or semi-definite
         if (dmy < -1.) {
                 dmy = -1.;
                 alpha = M_PI;
 
         } else if (dmy > 1.) {
                 dmy = 1.;
                 alpha = 0.;
 
         } else {
                 alpha = acos(dmy)/3;
         }
 
         int idx1;
         if (alpha < M_PI/6.) {
                 idx1 = 1;
 
         } else {
                 idx1 = 3;
         }
 
         doublereal eta1 = 2*J2_dmy*cos(alpha + 2./3.*M_PI*(idx1 - 1));
         EigenValues(idx1) = eta1 + trA_3;
 
         // NOTE: there's a typo in the original paper;
         // AA must be used instead of A
         Vec3 r1 = AA.GetVec(1);
         r1(1) -= eta1;
         Vec3 r2 = AA.GetVec(2);
         r2(2) -= eta1;
         Vec3 r3 = AA.GetVec(3);
         r3(3) -= eta1;
 
         doublereal
                 nr1 = r1.Norm(),
                 nr2 = r2.Norm(),
                 nr3 = r3.Norm();
 
         int irmax = 1;
         doublereal nrmax = nr1;
 
         if (nr2 > nrmax) {
                 irmax = 2;
                 nrmax = nr2;
         }
 
         if (nr3 > nrmax) {
                 irmax = 3;
                 nrmax = nr3;
         }
 
         if (irmax == 2) {
                 Vec3 rtmp = r2;
                 r2 = r1;
                 nr2 = nr1;
                 r1 = rtmp;
                 nr1 = nrmax;
 
         } else if (irmax == 3) {
                 Vec3 rtmp = r3;
                 r3 = r1;
                 nr3 = nr1;
                 r1 = rtmp;
                 nr1 = nrmax;
         }
 
         Vec3 s1, s2;
         s1 = r1/nr1;
         Vec3 t2 = r2 - s1*(s1*r2);
         doublereal nt2 = t2.Norm();
         Vec3 t3 = r3 - s1*(s1*r3);
         doublereal nt3 = t3.Norm();
 
         if (nt2 > nt3) {
                 s2 = t2/nt2;
 
         } else {
                 s2 = t3/nt3;
         }
 
         Vec3 v1(s1.Cross(s2));
         EigenVectors.PutVec(idx1, v1);
 
         Mat3x3 AAA(eta1, 0., 0.,
                 0., s1*(AA*s1), s2*(AA*s1),
                 0., s1*(AA*s2), s2*(AA*s2));
 
         int idx2 = idx1%3 + 1;
         int idx3 = (idx1 + 1)%3 + 1;
 
         doublereal AAA22p33 = AAA(2, 2) + AAA(3, 3);
         doublereal AAA22m33 = AAA(2, 2) - AAA(3, 3);
         doublereal eta2 = (AAA22p33 - copysign(1., AAA22m33)*sqrt(AAA22m33*AAA22m33 + 4*AAA(2, 3)*AAA(3, 2)))/2;
         doublereal eta3 = AAA22p33 - eta2;
 
         EigenValues(idx2) = eta2 + trA_3;
         EigenValues(idx3) = eta3 + trA_3;
 
         Vec3 u1 = AA*s1 - s1*eta2;
         doublereal nu1 = u1.Norm();
         Vec3 u2 = AA*s2 - s2*eta2;
         doublereal nu2 = u2.Norm();
 
         Vec3 w1;
         if (nu1 > nu2) {
                 w1 = u1/nu1;
 
         } else {
                 w1 = u2/nu2;
         }
 
         Vec3 v2(w1.Cross(v1));
         EigenVectors.PutVec(idx2, v2);
         EigenVectors.PutVec(idx3, v1.Cross(v2));
 
         return true;
 }

Here is the call graph for this function:

Vec3 Mat3x3::GetCol ( unsigned short int i ) const

inline

Definition at line 903 of file matvec3.h.

References ASSERT, pdMat, and Vec3.

Referenced by HydrodynamicPlainBearing::AssJac(), InlineFriction::AssJac(), asynchronous_machine::AssJac(), Motor::AssJac(), InlineFriction::AssRes(), asynchronous_machine::AssRes(), Motor::AssRes(), asynchronous_machine::asynchronous_machine(), HydrodynamicPlainBearing::ComputeResidual(), Motor::dGetPhiMechanical(), Motor::GetAxisOfRotation(), InlineFriction::InitialAssJac(), InlineFriction::InitialAssRes(), grad::VecRotInit< T, MatrixExpr >::Initialize(), Membrane4EAS::Membrane4EAS(), ReadElectric(), Shell4EAS::Shell4EAS(), Shell4EASANS::Shell4EASANS(), and InlineFriction::SlidingVelocity().

                                            {
       ASSERT(i >= 1 && i <= 3);
       return Vec3(pdMat + 3*--i);
    };

void Mat3x3::GetFrom	(	const doublereal *	pd,
		integer	iSize
	)

inline

Definition at line 976 of file matvec3.h.

References ASSERT, M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

Referenced by Mat3x3().

                                                      {
       ASSERT(pd != NULL);
       ASSERT(iSize >= 3);
 
       doublereal* pdFrom = (doublereal*)pd;
       pdMat[M11] = pdFrom[0];
       pdMat[M21] = pdFrom[1];
       pdMat[M31] = pdFrom[2];
       
       pdFrom += iSize;
       pdMat[M12] = pdFrom[0];
       pdMat[M22] = pdFrom[1];
       pdMat[M32] = pdFrom[2];
       
       pdFrom += iSize;
       pdMat[M13] = pdFrom[0];
       pdMat[M23] = pdFrom[1];
       pdMat[M33] = pdFrom[2];
    };

Vec3 Mat3x3::GetRow ( unsigned short int i ) const

inline

Definition at line 912 of file matvec3.h.

References ASSERT, pdMat, and Vec3.

Referenced by HydrodynamicPlainBearing::AssJac().

                                            {
       ASSERT(i >= 1 && i <= 3);
       --i;
       return Vec3(pdMat[i], pdMat[3 + i], pdMat[6 + i]);
    };

Vec3 Mat3x3::GetVec ( unsigned short int i ) const

inline

Definition at line 893 of file matvec3.h.

References ASSERT, pdMat, and Vec3.

                                            {
       ASSERT(i >= 1 && i <= 3);
       return Vec3(pdMat+3*--i);
    };

Mat3x3 Mat3x3::Inv ( const doublereal & ddet ) const

Definition at line 133 of file matvec3.cc.

References ASSERT, grad::fabs(), M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

Referenced by main().

 {
    ASSERT(fabs(d) > std::numeric_limits<doublereal>::epsilon());
 
    doublereal* p = (doublereal*)pdMat;
 
    return Mat3x3((p[M22]*p[M33]-p[M23]*p[M32])/d,
                  (p[M23]*p[M31]-p[M21]*p[M33])/d,
                  (p[M21]*p[M32]-p[M22]*p[M31])/d,
                  (p[M13]*p[M32]-p[M12]*p[M33])/d,
                  (p[M11]*p[M33]-p[M13]*p[M31])/d,
                  (p[M12]*p[M31]-p[M11]*p[M32])/d,
                  (p[M12]*p[M23]-p[M13]*p[M22])/d,
                  (p[M13]*p[M21]-p[M11]*p[M23])/d,
                  (p[M11]*p[M22]-p[M12]*p[M21])/d);
 }

Here is the call graph for this function:

Mat3x3 Mat3x3::Inv ( void ) const

Definition at line 152 of file matvec3.cc.

References dDet(), grad::fabs(), and MBDYN_EXCEPT_ARGS.

 {
    doublereal d = dDet();
    if (fabs(d) < std::numeric_limits<doublereal>::epsilon()) {
       silent_cerr("matrix is singular" << std::endl);
       throw MatrixHandler::ErrMatrixIsSingular(MBDYN_EXCEPT_ARGS);
    }
    
    return Inv(d);
 }

Here is the call graph for this function:

bool Mat3x3::IsDiag ( void ) const

inline

Definition at line 1284 of file matvec3.h.

References M12, M13, M21, M23, M31, M32, and pdMat.

Referenced by EigSym().

                                 {
                 if (pdMat[M12] != 0.
                         || pdMat[M21] != 0.
                         || pdMat[M13] != 0.
                         || pdMat[M31] != 0.
                         || pdMat[M23] != 0.
                         || pdMat[M32] != 0.)
                 {
                         return false;
                 }
 
                 return true;
         };

bool Mat3x3::IsDiag ( const doublereal & dTol ) const

inline

Definition at line 1298 of file matvec3.h.

References ASSERT, grad::fabs(), M12, M13, M21, M23, M31, M32, and pdMat.

                                                   {
                 ASSERT(dTol > 0.);
 
                 if (fabs(pdMat[M12]) > dTol
                         || fabs(pdMat[M21]) > dTol
                         || fabs(pdMat[M13]) > dTol
                         || fabs(pdMat[M31]) > dTol
                         || fabs(pdMat[M23]) > dTol
                         || fabs(pdMat[M32]) > dTol)
                 {
                         return false;
                 }
 
                 return true;
         };

Here is the call graph for this function:

bool Mat3x3::IsExactlySame ( const Mat3x3 & m ) const

inline

Definition at line 1237 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

Referenced by DataManager::ReadControl().

                                              {
       return (pdMat[M11] == m.pdMat[M11]
            && pdMat[M12] == m.pdMat[M12]
            && pdMat[M13] == m.pdMat[M13]
            && pdMat[M21] == m.pdMat[M21]
            && pdMat[M22] == m.pdMat[M22]
            && pdMat[M23] == m.pdMat[M23]
            && pdMat[M31] == m.pdMat[M31]
            && pdMat[M32] == m.pdMat[M32]
            && pdMat[M33] == m.pdMat[M33]);
    };

bool Mat3x3::IsNull ( void ) const

inline

Definition at line 1231 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

                            {
       return (pdMat[M11] == 0. && pdMat[M12] == 0. && pdMat[M13] == 0.
            && pdMat[M21] == 0. && pdMat[M22] == 0. && pdMat[M23] == 0.
            && pdMat[M31] == 0. && pdMat[M32] == 0. && pdMat[M33] == 0.);
    };

bool Mat3x3::IsSame	(	const Mat3x3 &	m,
		const doublereal &	dTol
	)		const

inline

Definition at line 1249 of file matvec3.h.

References pdMat, and grad::sqrt().

Referenced by MBDynParser::GetMatR2vec(), ReadElectric(), and ReferenceFrame::ReferenceFrame().

                                                               {
       doublereal d2 = 0.;
 
       for (int i = 0; i < 9; i++) {
          doublereal d = pdMat[i] - m.pdMat[i];
          d2 += d*d;
       }
 
       return sqrt(d2) <= dTol;
    };

Here is the call graph for this function:

bool Mat3x3::IsSymmetric ( void ) const

inline

Definition at line 1260 of file matvec3.h.

References M12, M13, M21, M23, M31, M32, and pdMat.

Referenced by CenterOfMass::Collect_int(), AutomaticStructElem::ComputeAccelerations(), and EigSym().

                                      {
                 if (pdMat[M12] != pdMat[M21]
                         || pdMat[M13] != pdMat[M31]
                         || pdMat[M23] != pdMat[M32])
                 {
                         return false;
                 }
 
                 return true;
         };

bool Mat3x3::IsSymmetric ( const doublereal & dTol ) const

inline

Definition at line 1271 of file matvec3.h.

References ASSERT, grad::fabs(), M12, M13, M21, M23, M31, M32, and pdMat.

                                                        {
                 ASSERT(dTol > 0.);
 
                 if (fabs(pdMat[M12] - pdMat[M21]) > dTol
                         || fabs(pdMat[M13] - pdMat[M31]) > dTol
                         || fabs(pdMat[M23] - pdMat[M32]) > dTol)
                 {
                         return false;
                 }
 
                 return true;
         };

Here is the call graph for this function:

Vec3 Mat3x3::LDLSolve ( const Vec3 & v ) const

Definition at line 199 of file matvec3.cc.

References ASSERT, M11, M12, M13, M21, M22, M23, M31, M32, M33, pdMat, and Vec3.

Referenced by CenterOfMass::Collect_int(), AutomaticStructElem::ComputeAccelerations(), main(), and testSolve().

 {
         doublereal d1, d2, d3, l21 = 0., l31 = 0., l32 = 0.;
 
         d1 = pdMat[M11];
         ASSERT(d1 >= 0.);
         if (d1 > std::numeric_limits<doublereal>::epsilon()) {
                 l21 = (pdMat[M21] + pdMat[M12])/(2.*d1);
                 l31 = (pdMat[M31] + pdMat[M13])/(2.*d1);
         }
 
         d2 = pdMat[M22] - l21*l21*d1;
         ASSERT(d2 >= 0.);
         if (d2 > std::numeric_limits<doublereal>::epsilon()) {
                 l32 = ((pdMat[M32] + pdMat[M23])/2. - l21*l31*d1)/d2;
         }
 
         d3 = pdMat[M33] - l31*l31*d1 - l32*l32*d2;
 
         // L * D * L^T * x = v
         // L^T * x = y
         // D * y = z
         // L * z = v
 
         // z = L^-1 * v
         doublereal z1 = v(1);
         doublereal z2 = v(2) - l21*z1;
         doublereal z3 = v(3) - l31*z1 - l32*z2;
 
         // y = D^-1 * z
         if (d1 > std::numeric_limits<doublereal>::epsilon()) {
                 z1 /= d1;
         } else {
                 z1 = 0.;
         }
 
         if (d2 > std::numeric_limits<doublereal>::epsilon()) {
                 z2 /= d2;
         } else {
                 z2 = 0.;
         }
 
         if (d3 > std::numeric_limits<doublereal>::epsilon()) {
                 z3 /= d3;
         } else {
                 z3 = 0.;
         }
 
         // x = L^-T * y
         z2 -= l32*z3;
         z1 -= l21*z2 + l31*z3;
 
         return Vec3(z1, z2, z3);
 }

Mat3x3 Mat3x3::MulMT ( const Mat3x3 & m ) const

multiply by another matrix, transposed: this * m^T

Definition at line 444 of file matvec3.cc.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

Referenced by ElasticHingeJoint::AfterPredict(), StructDispNode::AfterPredict(), ElasticHingeJointInv::AfterPredict(), Body::AfterPredict(), ViscoElasticHingeJoint::AfterPredict(), ViscoElasticHingeJointInv::AfterPredict(), StructNode::AfterPredict(), DataManager::AssConstrRes(), Shell4EAS::AssJac(), AerodynamicBeam::AssJac(), ElasticAxialJoint::AssMat(), ElasticHingeJoint::AssMat(), LoadIncNorm::AssRes(), TotalJoint::AssRes(), ClampJoint::AssRes(), DynamicBody::AssRes(), TotalPinJoint::AssRes(), ModalBody::AssRes(), StaticBody::AssRes(), StructNode::BeforePredict(), Inertia::Collect_int(), Shell4EAS::ComputeIPCurvature(), Shell4EASANS::ComputeIPCurvature(), Modal::GetJ_int(), Body::GetJ_int(), ClampJoint::InitialAssRes(), DynamicBody::InitialAssRes(), TotalPinJoint::InitialAssRes(), DataManager::InitialJointAssembly(), Shell4EAS::InterpolateOrientation(), Shell4EASANS::InterpolateOrientation(), main(), MultMRt(), MultRMRt(), MultRMRtGammam1(), ReadBody(), DynamicBody::SetValue(), InvAngularConstitutiveLaw::Update(), and RelFrameDummyStructNode::Update_int().

 {
         return Mat3x3(
                 pdMat[M11]*m.pdMat[M11]
                         + pdMat[M12]*m.pdMat[M12]
                         + pdMat[M13]*m.pdMat[M13],
                 pdMat[M21]*m.pdMat[M11]
                         + pdMat[M22]*m.pdMat[M12]
                         + pdMat[M23]*m.pdMat[M13],
                 pdMat[M31]*m.pdMat[M11]
                         + pdMat[M32]*m.pdMat[M12]
                         + pdMat[M33]*m.pdMat[M13],
 
                 pdMat[M11]*m.pdMat[M21]
                         + pdMat[M12]*m.pdMat[M22]
                         + pdMat[M13]*m.pdMat[M23],
                 pdMat[M21]*m.pdMat[M21]
                         + pdMat[M22]*m.pdMat[M22]
                         + pdMat[M23]*m.pdMat[M23],
                 pdMat[M31]*m.pdMat[M21]
                         + pdMat[M32]*m.pdMat[M22]
                         + pdMat[M33]*m.pdMat[M23],
 
                 pdMat[M11]*m.pdMat[M31]
                         + pdMat[M12]*m.pdMat[M32]
                         + pdMat[M13]*m.pdMat[M33],
                 pdMat[M21]*m.pdMat[M31]
                         + pdMat[M22]*m.pdMat[M32]
                         + pdMat[M23]*m.pdMat[M33],
                 pdMat[M31]*m.pdMat[M31]
                         + pdMat[M32]*m.pdMat[M32]
                         + pdMat[M33]*m.pdMat[M33]);
 }

Here is the call graph for this function:

Mat3x3 Mat3x3::MulTM ( const Mat3x3 & m ) const

multiply self transposed by another matrix: this^T * m

Definition at line 500 of file matvec3.cc.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

Referenced by PlanePinJoint::AfterConvergence(), ElasticJoint::AfterPredict(), ElasticJointInv::AfterPredict(), ViscoElasticJoint::AfterPredict(), StructNode::AfterPredict(), anglerel(), HydrodynamicPlainBearing::AssJac(), Motor::AssJac(), AerodynamicBody::AssJac(), Shell4EAS::AssJac(), AerodynamicBeam::AssJac(), AerodynamicBeam2::AssJac(), TotalEquation::AssRes(), TotalJoint::AssRes(), ElasticJoint::AssVec(), AerodynamicBeam::AssVec(), ViscoElasticJoint::AssVec(), StructDispNode::BeforePredict(), StructNode::BeforePredict(), PlanePinJoint::dGetPrivData(), MBDynParser::GetMatR2vec(), MBDynParser::GetMatRel(), MBDynParser::GetRotRel(), TotalEquation::InitialAssRes(), TotalJoint::InitialAssRes(), ModalMappingExt::ModalMappingExt(), DeformableJoint::Output(), StructExtForce::Output(), TotalEquation::Output(), TotalJoint::Output(), TotalReaction::Output(), PlanePinJoint::Output(), Inertia::Output_int(), ReadBeam(), ReadBeam2(), ReferenceFrame::ReferenceFrame(), ModalMappingExt::Send(), StructExtForce::SendToFileDes(), StructExtForce::SendToStream(), StructMappingExtForce::SendToStream(), StructMembraneMappingExtForce::SendToStream(), PlaneHingeJoint::SetValue(), TotalEquation::SetValue(), TotalJoint::SetValue(), StructDispNode::SetValue(), PlaneRotationJoint::SetValue(), TotalReaction::SetValue(), TotalPinJoint::SetValue(), AxialRotationJoint::SetValue(), PlanePinJoint::SetValue(), StructNode::SetValue(), Shell4EAS::UpdateNodalAndAveragePosAndOrientation(), and Shell4EASANS::UpdateNodalAndAveragePosAndOrientation().

 {
         return Mat3x3(
                 pdMat[M11]*m.pdMat[M11]
                         + pdMat[M21]*m.pdMat[M21]
                         + pdMat[M31]*m.pdMat[M31],
                 pdMat[M12]*m.pdMat[M11]
                         + pdMat[M22]*m.pdMat[M21]
                         + pdMat[M32]*m.pdMat[M31],
                 pdMat[M13]*m.pdMat[M11]
                         + pdMat[M23]*m.pdMat[M21]
                         + pdMat[M33]*m.pdMat[M31],
 
                 pdMat[M11]*m.pdMat[M12]
                         + pdMat[M21]*m.pdMat[M22]
                         + pdMat[M31]*m.pdMat[M32],
                 pdMat[M12]*m.pdMat[M12]
                         + pdMat[M22]*m.pdMat[M22]
                         + pdMat[M32]*m.pdMat[M32],
                 pdMat[M13]*m.pdMat[M12]
                         + pdMat[M23]*m.pdMat[M22]
                         + pdMat[M33]*m.pdMat[M32],
 
                 pdMat[M11]*m.pdMat[M13]
                         + pdMat[M21]*m.pdMat[M23]
                         + pdMat[M31]*m.pdMat[M33],
                 pdMat[M12]*m.pdMat[M13]
                         + pdMat[M22]*m.pdMat[M23]
                         + pdMat[M32]*m.pdMat[M33],
                 pdMat[M13]*m.pdMat[M13]
                         + pdMat[M23]*m.pdMat[M23]
                         + pdMat[M33]*m.pdMat[M33]);
 }

Here is the call graph for this function:

Mat3x3 Mat3x3::MulTMT ( const Mat3x3 & m ) const

multiply self transposed by another matrix, transposed: this^T * m^T

Definition at line 538 of file matvec3.cc.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

Referenced by Shell4EAS::AssJac().

 {
         return Mat3x3(
                 pdMat[M11]*m.pdMat[M11]
                         + pdMat[M21]*m.pdMat[M12]
                         + pdMat[M31]*m.pdMat[M13],
                 pdMat[M12]*m.pdMat[M11]
                         + pdMat[M22]*m.pdMat[M12]
                         + pdMat[M32]*m.pdMat[M13],
                 pdMat[M13]*m.pdMat[M11]
                         + pdMat[M23]*m.pdMat[M12]
                         + pdMat[M33]*m.pdMat[M13],
 
                 pdMat[M11]*m.pdMat[M21]
                         + pdMat[M21]*m.pdMat[M22]
                         + pdMat[M31]*m.pdMat[M23],
                 pdMat[M12]*m.pdMat[M21]
                         + pdMat[M22]*m.pdMat[M22]
                         + pdMat[M32]*m.pdMat[M23],
                 pdMat[M13]*m.pdMat[M21]
                         + pdMat[M23]*m.pdMat[M22]
                         + pdMat[M33]*m.pdMat[M23],
 
                 pdMat[M11]*m.pdMat[M31]
                         + pdMat[M21]*m.pdMat[M32]
                         + pdMat[M31]*m.pdMat[M33],
                 pdMat[M12]*m.pdMat[M31]
                         + pdMat[M22]*m.pdMat[M32]
                         + pdMat[M32]*m.pdMat[M33],
                 pdMat[M13]*m.pdMat[M31]
                         + pdMat[M23]*m.pdMat[M32]
                         + pdMat[M33]*m.pdMat[M33]);
 }

Here is the call graph for this function:

Vec3 Mat3x3::MulTV ( const Vec3 & v ) const

multiply self transposed by a vector: this^T * v

Definition at line 482 of file matvec3.cc.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, pdMat, Vec3::pdVec, V1, V2, V3, and Vec3.

Referenced by AerodynamicModal::AerodynamicModal(), AeroDynModule::AeroDynModule(), ViscousBody::AfterPredict(), Beam2::AfterPredict(), ElasticJoint::AfterPredict(), ElasticJointInv::AfterPredict(), ViscoElasticBeam2::AfterPredict(), ViscousJoint::AfterPredict(), ViscousHingeJointInv::AfterPredict(), ViscoElasticJoint::AfterPredict(), ViscoElasticHingeJointInv::AfterPredict(), HydrodynamicPlainBearing::AssJac(), LoadIncNorm::AssJac(), AerodynamicBody::AssJac(), Shell4EAS::AssJac(), AerodynamicBeam::AssJac(), AerodynamicBeam2::AssJac(), ModalBody::AssMats(), ModuleIMU::AssRes(), InlineFriction::AssRes(), TotalEquation::AssRes(), TotalJoint::AssRes(), AeroDynModule::AssRes(), Shell4EAS::AssRes(), Shell4EASANS::AssRes(), ModuleIMUConstraint::AssRes(), TotalPinJoint::AssRes(), Beam2::AssStiffnessVec(), ViscoElasticBeam2::AssStiffnessVec(), ViscousBody::AssVec(), GenericAerodynamicForce::AssVec(), ElasticJoint::AssVec(), AerodynamicBody::AssVec(), ElasticDispJointInv::AssVec(), ElasticJointInv::AssVec(), AerodynamicBeam::AssVec(), ViscousJoint::AssVec(), AerodynamicBeam2::AssVec(), ViscousHingeJointInv::AssVec(), ViscoElasticJoint::AssVec(), StructDispNode::BeforePredict(), StructNode::BeforePredict(), HydrodynamicPlainBearing::ComputeResidual(), NodeDistDriveCaller::dGet(), NodeDistDriveCaller::dGetP(), Motor::dGetPhiMechanical(), PlaneHingeJoint::dGetPrivData(), TotalEquation::dGetPrivData(), TotalJoint::dGetPrivData(), PlaneRotationJoint::dGetPrivData(), Body::dGetPrivData(), TotalReaction::dGetPrivData(), Beam2::DsDxi(), Beam::DsDxi(), getelemparams(), DynamicBody::GetG_int(), MBDynParser::GetOmeRel(), MBDynParser::GetPosRel(), MBDynParser::GetVecRel(), AirProperties::GetVelocity(), MBDynParser::GetVelRel(), getvnvt(), InlineFriction::InitialAssRes(), DataManager::InitialJointAssembly(), ModalMappingExt::ModalMappingExt(), ModuleIMU::ModuleIMU(), ModuleIMUConstraint::ModuleIMUConstraint(), Inertia::Output(), StructExtForce::Output(), TotalEquation::Output(), TotalJoint::Output(), ClampJoint::Output(), TotalReaction::Output(), Inertia::Output_int(), ReadStructMappingExtForce(), ExtRigidForceEDGE::Send(), ModalMappingExt::Send(), StructExtForce::SendToFileDes(), StructMappingExtForce::SendToFileDes(), StructMembraneMappingExtForce::SendToFileDes(), StructExtEDGEForce::SendToStream(), StructExtForce::SendToStream(), StructMappingExtForce::SendToStream(), StructMembraneMappingExtForce::SendToStream(), TotalEquation::SetValue(), TotalJoint::SetValue(), StructDispNode::SetValue(), TotalReaction::SetValue(), ModuleIMUConstraint::SetValue(), PlanePinJoint::SetValue(), StructNode::SetValue(), Shell4EAS::Shell4EAS(), Shell4EASANS::Shell4EASANS(), InlineFriction::SlidingVelocity(), AircraftInstruments::Update(), DriveRigidBodyKinematics::Update(), and InvAngularConstitutiveLaw::Update().

 {
         return Vec3(
                 pdMat[M11]*v.pdVec[V1]
                         + pdMat[M21]*v.pdVec[V2]
                         + pdMat[M31]*v.pdVec[V3],
                 pdMat[M12]*v.pdVec[V1]
                         + pdMat[M22]*v.pdVec[V2]
                         + pdMat[M32]*v.pdVec[V3],
                 pdMat[M13]*v.pdVec[V1]
                         + pdMat[M23]*v.pdVec[V2]
                         + pdMat[M33]*v.pdVec[V3]);
 }

Mat3x3 Mat3x3::MulTVCross ( const Vec3 & v ) const

multiply self transposed times vCross

Definition at line 596 of file matvec3.cc.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), pdMat, Vec3::pdVec, V1, V2, and V3.

Referenced by ModalBody::AssMats().

 {
         return Mat3x3(
                 pdMat[M21]*v.pdVec[V3] - pdMat[M31]*v.pdVec[V2],
                 pdMat[M22]*v.pdVec[V3] - pdMat[M32]*v.pdVec[V2],
                 pdMat[M23]*v.pdVec[V3] - pdMat[M33]*v.pdVec[V2],
 
                 pdMat[M31]*v.pdVec[V1] - pdMat[M11]*v.pdVec[V3],
                 pdMat[M32]*v.pdVec[V1] - pdMat[M12]*v.pdVec[V3],
                 pdMat[M33]*v.pdVec[V1] - pdMat[M13]*v.pdVec[V3],
 
                 pdMat[M11]*v.pdVec[V2] - pdMat[M21]*v.pdVec[V1],
                 pdMat[M12]*v.pdVec[V2] - pdMat[M22]*v.pdVec[V1],
                 pdMat[M13]*v.pdVec[V2] - pdMat[M23]*v.pdVec[V1]);
 }

Here is the call graph for this function:

Mat3x3 Mat3x3::MulVCross ( const Vec3 & v ) const

multiply self times vCross

Definition at line 576 of file matvec3.cc.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), pdMat, Vec3::pdVec, V1, V2, and V3.

 {
         return Mat3x3(
                 pdMat[M12]*v.pdVec[V3] - pdMat[M13]*v.pdVec[V2],
                 pdMat[M22]*v.pdVec[V3] - pdMat[M23]*v.pdVec[V2],
                 pdMat[M32]*v.pdVec[V3] - pdMat[M33]*v.pdVec[V2],
 
                 pdMat[M13]*v.pdVec[V1] - pdMat[M11]*v.pdVec[V3],
                 pdMat[M23]*v.pdVec[V1] - pdMat[M21]*v.pdVec[V3],
                 pdMat[M33]*v.pdVec[V1] - pdMat[M31]*v.pdVec[V3],
 
                 pdMat[M11]*v.pdVec[V2] - pdMat[M12]*v.pdVec[V1],
                 pdMat[M21]*v.pdVec[V2] - pdMat[M22]*v.pdVec[V1],
                 pdMat[M31]*v.pdVec[V2] - pdMat[M32]*v.pdVec[V1]);
 }

Here is the call graph for this function:

doublereal& Mat3x3::operator()	(	unsigned short int	iRow,
		unsigned short int	iCol
	)

inline

Definition at line 777 of file matvec3.h.

References ASSERT, and pdMat.

                                             {
        ASSERT(iRow >= 1 && iRow <= 3);
        ASSERT(iCol >= 1 && iCol <= 3);
        return pdMat[--iRow+3*--iCol];
    };

const doublereal& Mat3x3::operator()	(	unsigned short int	iRow,
		unsigned short int	iCol
	)		const

inline

Definition at line 784 of file matvec3.h.

References ASSERT, and pdMat.

                                                   {
        ASSERT(iRow >= 1 && iRow <= 3);
        ASSERT(iCol >= 1 && iCol <= 3);
        return pdMat[--iRow+3*--iCol];
    };

Mat3x3 Mat3x3::operator* ( const doublereal & d ) const

inline

Definition at line 1142 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

                                                  {
       if (d != 1.) {
          return Mat3x3(pdMat[M11]*d,
                        pdMat[M21]*d,
                        pdMat[M31]*d,
                        pdMat[M12]*d,
                        pdMat[M22]*d,
                        pdMat[M32]*d,
                        pdMat[M13]*d,
                        pdMat[M23]*d,
                        pdMat[M33]*d);
       }
       return *this;
    };

Here is the call graph for this function:

Vec3 Mat3x3::operator* ( const Vec3 & v ) const

inline

Definition at line 1224 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, pdMat, Vec3::pdVec, V1, V2, V3, and Vec3.

                                          {
 
       return Vec3(pdMat[M11]*v.pdVec[V1]+pdMat[M12]*v.pdVec[V2]+pdMat[M13]*v.pdVec[V3],
                   pdMat[M21]*v.pdVec[V1]+pdMat[M22]*v.pdVec[V2]+pdMat[M23]*v.pdVec[V3],
                   pdMat[M31]*v.pdVec[V1]+pdMat[M32]*v.pdVec[V2]+pdMat[M33]*v.pdVec[V3]);
    };

Mat3x3 Mat3x3::operator* ( const Mat3x3 & m ) const

inline

Definition at line 1318 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

    {
        return Mat3x3(pdMat[M11]*m.pdMat[M11]+pdMat[M12]*m.pdMat[M21]+pdMat[M13]*m.pdMat[M31],
                  pdMat[M21]*m.pdMat[M11]+pdMat[M22]*m.pdMat[M21]+pdMat[M23]*m.pdMat[M31],
                  pdMat[M31]*m.pdMat[M11]+pdMat[M32]*m.pdMat[M21]+pdMat[M33]*m.pdMat[M31],
                  pdMat[M11]*m.pdMat[M12]+pdMat[M12]*m.pdMat[M22]+pdMat[M13]*m.pdMat[M32],
                  pdMat[M21]*m.pdMat[M12]+pdMat[M22]*m.pdMat[M22]+pdMat[M23]*m.pdMat[M32],
                  pdMat[M31]*m.pdMat[M12]+pdMat[M32]*m.pdMat[M22]+pdMat[M33]*m.pdMat[M32],
                  pdMat[M11]*m.pdMat[M13]+pdMat[M12]*m.pdMat[M23]+pdMat[M13]*m.pdMat[M33],
                  pdMat[M21]*m.pdMat[M13]+pdMat[M22]*m.pdMat[M23]+pdMat[M23]*m.pdMat[M33],
                  pdMat[M31]*m.pdMat[M13]+pdMat[M32]*m.pdMat[M23]+pdMat[M33]*m.pdMat[M33]);
     };      

Here is the call graph for this function:

Mat3x3& Mat3x3::operator*= ( const doublereal & d )

inline

Definition at line 1161 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

                                              {
       if (d != 1.) {
          pdMat[M11] *= d;
          pdMat[M21] *= d;
          pdMat[M31] *= d;
          pdMat[M12] *= d;
          pdMat[M22] *= d;
          pdMat[M32] *= d;
          pdMat[M13] *= d;
          pdMat[M23] *= d;
          pdMat[M33] *= d;
       }
       
       return *this;
    };

Mat3x3 Mat3x3::operator+ ( const Mat3x3 & m ) const

inline

Definition at line 1074 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

                                              {
       return Mat3x3(pdMat[M11]+m.pdMat[M11],
                     pdMat[M21]+m.pdMat[M21],
                     pdMat[M31]+m.pdMat[M31],
                     pdMat[M12]+m.pdMat[M12],
                     pdMat[M22]+m.pdMat[M22],
                     pdMat[M32]+m.pdMat[M32],
                     pdMat[M13]+m.pdMat[M13],
                     pdMat[M23]+m.pdMat[M23],
                     pdMat[M33]+m.pdMat[M33]);
    };

Here is the call graph for this function:

Mat3x3& Mat3x3::operator+= ( const Mat3x3 & m )

inline

Definition at line 1090 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

                                          {
       pdMat[M11] += m.pdMat[M11];
       pdMat[M21] += m.pdMat[M21];
       pdMat[M31] += m.pdMat[M31];
       pdMat[M12] += m.pdMat[M12];
       pdMat[M22] += m.pdMat[M22];
       pdMat[M32] += m.pdMat[M32];
       pdMat[M13] += m.pdMat[M13];
       pdMat[M23] += m.pdMat[M23];
       pdMat[M33] += m.pdMat[M33];
       
       return *this;
    };

Mat3x3 Mat3x3::operator- ( const Mat3x3 & m ) const

inline

Definition at line 1108 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

                                              {
       return Mat3x3(pdMat[M11]-m.pdMat[M11],
                     pdMat[M21]-m.pdMat[M21],
                     pdMat[M31]-m.pdMat[M31],
                     pdMat[M12]-m.pdMat[M12],
                     pdMat[M22]-m.pdMat[M22],
                     pdMat[M32]-m.pdMat[M32],
                     pdMat[M13]-m.pdMat[M13],
                     pdMat[M23]-m.pdMat[M23],
                     pdMat[M33]-m.pdMat[M33]);
    };

Here is the call graph for this function:

Mat3x3& Mat3x3::operator-= ( const Mat3x3 & m )

inline

Definition at line 1124 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

                                          {
       pdMat[M11] -= m.pdMat[M11];
       pdMat[M21] -= m.pdMat[M21];
       pdMat[M31] -= m.pdMat[M31];
       pdMat[M12] -= m.pdMat[M12];
       pdMat[M22] -= m.pdMat[M22];
       pdMat[M32] -= m.pdMat[M32];
       pdMat[M13] -= m.pdMat[M13];
       pdMat[M23] -= m.pdMat[M23];
       pdMat[M33] -= m.pdMat[M33];
 
       return *this;
    };

Mat3x3 Mat3x3::operator/ ( const doublereal & d ) const

inline

Definition at line 1181 of file matvec3.h.

References ASSERT, M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

                                                  {
       ASSERT(d != 0.);
       if (d != 1.) {
          return Mat3x3(pdMat[M11]/d,
                        pdMat[M21]/d,
                        pdMat[M31]/d,
                        pdMat[M12]/d,
                        pdMat[M22]/d,
                        pdMat[M32]/d,
                        pdMat[M13]/d,
                        pdMat[M23]/d,
                        pdMat[M33]/d);
       }
       
       return *this;
    };

Here is the call graph for this function:

Mat3x3& Mat3x3::operator/= ( const doublereal & d )

inline

Definition at line 1202 of file matvec3.h.

References ASSERT, M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

                                              {
       ASSERT(d != 0.);
       if (d != 1.) {
          pdMat[M11] /= d;
          pdMat[M21] /= d;
          pdMat[M31] /= d;
          pdMat[M12] /= d;
          pdMat[M22] /= d;
          pdMat[M32] /= d;
          pdMat[M13] /= d;
          pdMat[M23] /= d;
          pdMat[M33] /= d;
       }
       
       return *this;
    };

Mat3x3& Mat3x3::operator= ( const Mat3x3 & m )

inline

Definition at line 1055 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

                                         {
       
       pdMat[M11] = m.pdMat[M11];
       pdMat[M21] = m.pdMat[M21];
       pdMat[M31] = m.pdMat[M31];
       pdMat[M12] = m.pdMat[M12];
       pdMat[M22] = m.pdMat[M22];
       pdMat[M32] = m.pdMat[M32];
       pdMat[M13] = m.pdMat[M13];
       pdMat[M23] = m.pdMat[M23];
       pdMat[M33] = m.pdMat[M33];
       
       return *this;
    };

const doublereal* Mat3x3::pGetMat ( void ) const

inline

Definition at line 743 of file matvec3.h.

References pdMat.

Referenced by FullMatrixHandler::Add(), FullMatrixHandler::AddT(), grad::Mat3x3DirectExpr::bHaveReferenceTo(), grad::Mat3x3DirectExpr::GetCol(), grad::Mat3x3DirectExpr::GetRow(), GlauertRotor::Init(), ManglerRotor::Init(), DynamicInflowRotor::Init(), PetersHeRotor::Init(), Mat3x3Zero_Manip::Manipulate(), Mat3x3DEye_Manip::Manipulate(), Mat3x3Diag_Manip::Manipulate(), MatCross_Manip::Manipulate(), MatCrossCross_Manip::Manipulate(), operator-(), operator<<(), DeformableHingeJoint::Output(), DeformableJoint::Output(), StructDispNode::Output(), Beam2::Output(), StructNode::Output(), Mat6x6::pGetMat(), FullMatrixHandler::Put(), SparseSubMatrixHandler::PutMat3x3(), FullMatrixHandler::PutT(), StructExtForce::SendToFileDes(), StructMappingExtForce::SendToFileDes(), ExtModalForce::SendToFileDes(), StructMembraneMappingExtForce::SendToFileDes(), FullMatrixHandler::Sub(), and FullMatrixHandler::SubT().

                                          { 
       return pdMat;
    };

doublereal* Mat3x3::pGetMat ( void )

inline

Definition at line 747 of file matvec3.h.

References pdMat.

                              { 
       return pdMat;
    };

void Mat3x3::Put	(	unsigned short int	iRow,
		unsigned short int	iCol,
		const doublereal &	dCoef
	)

inline

Definition at line 758 of file matvec3.h.

References ASSERT, and pdMat.

Referenced by Mat6x6::Put(), CubicElasticGenericConstitutiveLaw< Vec3, Mat3x3 >::Update(), and CubicViscoElasticGenericConstitutiveLaw< Vec3, Mat3x3 >::Update().

                                             {
       ASSERT(iRow >= 1 && iRow <= 3);
       ASSERT(iCol >= 1 && iCol <= 3);      
       pdMat[--iRow+3*--iCol] = dCoef;
    };

void Mat3x3::PutTo	(	doublereal *	pd,
		integer	iNRows
	)		const

inline

Definition at line 1029 of file matvec3.h.

References ASSERT, M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

                                                     {
       ASSERT(pd != NULL);
       ASSERT(iNRows >= 3);
       
       doublereal* pdTo = pd;
       
       pdTo[0] = pdMat[M11];
       pdTo[1] = pdMat[M21];
       pdTo[2] = pdMat[M31];
       
       pdTo += iNRows;
       pdTo[0] = pdMat[M12];
       pdTo[1] = pdMat[M22];
       pdTo[2] = pdMat[M32];
       
       pdTo += iNRows;
       pdTo[0] = pdMat[M13];
       pdTo[1] = pdMat[M23];
       pdTo[2] = pdMat[M33];
    };

void Mat3x3::PutVec	(	unsigned short int	i,
		const Vec3 &	v
	)

inline

Definition at line 918 of file matvec3.h.

References ASSERT, pdMat, Vec3::pdVec, V1, V2, and V3.

Referenced by Modal::AssRes(), and EigSym().

                                                     {
       ASSERT(i >= 1 && i <= 3);
 
       i--; i = 3*i;
       pdMat[i++] = v.pdVec[V1];
       pdMat[i++] = v.pdVec[V2];
       pdMat[i] = v.pdVec[V3];
    };

void Mat3x3::Reset ( void )

Definition at line 613 of file matvec3.cc.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

Referenced by AerodynamicBeam::AssJac(), AerodynamicBeam2::AssJac(), Modal::AssRes(), and Mat6x6::Reset().

 {
         pdMat[M11] = 0.;
         pdMat[M12] = 0.;
         pdMat[M13] = 0.;
 
         pdMat[M21] = 0.;
         pdMat[M22] = 0.;
         pdMat[M23] = 0.;
 
         pdMat[M31] = 0.;
         pdMat[M32] = 0.;
         pdMat[M33] = 0.;
 }

Mat3x3 Mat3x3::Skew ( void ) const

Definition at line 629 of file matvec3.cc.

References Ax(), Mat3x3(), and MatCross.

 {
         return Mat3x3(MatCross, this->Ax());
 }

Here is the call graph for this function:

const Mat3x3& Mat3x3::Skew ( const Mat3x3 & m )

inline

Definition at line 877 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, and pdMat.

                                        {
       pdMat[M11] = pdMat[M22] = pdMat[M13] = 0.;
       pdMat[M12] = m.pdMat[M12] - m.pdMat[M21];
       pdMat[M21] = -pdMat[M12];
       pdMat[M13] = m.pdMat[M13] - m.pdMat[M31];
       pdMat[M31] = -pdMat[M13];
       pdMat[M23] = m.pdMat[M23] - m.pdMat[M32];
       pdMat[M32] = -pdMat[M23];
 
       return *this;
    };

Vec3 Mat3x3::Solve ( const Vec3 & v ) const

Definition at line 186 of file matvec3.cc.

References dDet(), grad::fabs(), and MBDYN_EXCEPT_ARGS.

Referenced by RotorTrimBase::AssRes(), and testSolve().

 {
    doublereal d = dDet();
    
    if (fabs(d) < std::numeric_limits<doublereal>::epsilon()) {
       silent_cerr("matrix is singular" << std::endl);
       throw ErrGeneric(MBDYN_EXCEPT_ARGS);
    }
 
    return Solve(d, v);
 }

Here is the call graph for this function:

Vec3 Mat3x3::Solve	(	const doublereal &	d,
		const Vec3 &	v
	)		const

Definition at line 166 of file matvec3.cc.

References ASSERT, grad::fabs(), M11, M12, M13, M21, M22, M23, M31, M32, M33, pdMat, Vec3::pGetVec(), V1, V2, V3, and Vec3.

 {
    const doublereal* p = pdMat;
    const doublereal* pv = v.pGetVec();
 
    ASSERT(fabs(d) > std::numeric_limits<doublereal>::epsilon());
    
    return Vec3((pv[V1]*(p[M22]*p[M33] - p[M23]*p[M32])
                 +pv[V2]*(p[M13]*p[M32] - p[M12]*p[M33])
                 +pv[V3]*(p[M12]*p[M23] - p[M13]*p[M22]))/d,
                (pv[V1]*(p[M23]*p[M31] - p[M21]*p[M33])
                 +pv[V2]*(p[M11]*p[M33] - p[M13]*p[M31])
                 +pv[V3]*(p[M13]*p[M21] - p[M11]*p[M23]))/d,
                (pv[V1]*(p[M21]*p[M32] - p[M22]*p[M31])
                 +pv[V2]*(p[M12]*p[M31] - p[M11]*p[M32])
                 +pv[V3]*(p[M11]*p[M22] - p[M12]*p[M21]))/d);
 }

Here is the call graph for this function:

void Mat3x3::SubVec	(	unsigned short int	i,
		const Vec3 &	v
	)

inline

Definition at line 936 of file matvec3.h.

References ASSERT, pdMat, Vec3::pdVec, V1, V2, and V3.

                                                     {
       ASSERT(i >= 1 && i <= 3);
 
       i--; i = 3*i;
       pdMat[i++] -= v.pdVec[V1];
       pdMat[i++] -= v.pdVec[V2];
       pdMat[i] -= v.pdVec[V3];
    };

Mat3x3 Mat3x3::Symm ( void ) const

inline

Definition at line 840 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

Referenced by CenterOfMass::Collect_int(), and RotManip::VecRot().

                            {
       doublereal m12 = .5*(pdMat[M21]+pdMat[M12]);
       doublereal m13 = .5*(pdMat[M31]+pdMat[M13]);
       doublereal m23 = .5*(pdMat[M32]+pdMat[M23]);
 
       return Mat3x3(
                       pdMat[M11], m12, m13,
                       m12, pdMat[M22], m23,
                       m13, m23, pdMat[M33]
                       );
    };

Here is the call graph for this function:

const Mat3x3& Mat3x3::Symm ( const Mat3x3 & m )

inline

Definition at line 864 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

                                        {
       pdMat[M11] = m.pdMat[M11];
       pdMat[M22] = m.pdMat[M22];
       pdMat[M33] = m.pdMat[M33];
       pdMat[M12] = pdMat[M21] = .5*(m.pdMat[M21]+m.pdMat[M12]);
       pdMat[M13] = pdMat[M31] = .5*(m.pdMat[M31]+m.pdMat[M13]);
       pdMat[M23] = pdMat[M32] = .5*(m.pdMat[M32]+m.pdMat[M23]);
 
       return *this;
    };

Mat3x3 Mat3x3::Symm2 ( void ) const

inline

Definition at line 852 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

Referenced by Modal::AssJac(), Modal::AssRes(), and Modal::GetJ_int().

                             {
       doublereal m12 = pdMat[M21]+pdMat[M12];
       doublereal m13 = pdMat[M31]+pdMat[M13];
       doublereal m23 = pdMat[M32]+pdMat[M23];
 
       return Mat3x3(
                       2.*pdMat[M11], m12, m13,
                       m12, 2.*pdMat[M22], m23,
                       m13, m23, 2.*pdMat[M33]
                       );
    };

Here is the call graph for this function:

const Mat3x3& Mat3x3::Tens	(	const Vec3 &	a,
		const Vec3 &	b
	)

inline

Definition at line 799 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, pdMat, Vec3::pdVec, V1, V2, and V3.

Referenced by ElasticAxialJoint::AfterPredict(), ViscousAxialJoint::AfterPredict(), ViscoElasticAxialJoint::AfterPredict(), Motor::AssJac(), ViscousAxialJoint::InitialAssJac(), and ViscoElasticAxialJoint::InitialAssJac().

                                                     {
       pdMat[M11] = a.pdVec[V1]*b.pdVec[V1];   /* m(1,1) = a(1)*b(1) */
       pdMat[M21] = a.pdVec[V2]*b.pdVec[V1];   /* m(2,1) = a(2)*b(1) */
       pdMat[M31] = a.pdVec[V3]*b.pdVec[V1];   /* m(3,1) = a(3)*b(1) */
       pdMat[M12] = a.pdVec[V1]*b.pdVec[V2];   /* m(1,2) = a(1)*b(2) */
       pdMat[M22] = a.pdVec[V2]*b.pdVec[V2];   /* m(2,2) = a(2)*b(2) */
       pdMat[M32] = a.pdVec[V3]*b.pdVec[V2];   /* m(3,2) = a(3)*b(2) */
       pdMat[M13] = a.pdVec[V1]*b.pdVec[V3];   /* m(1,3) = a(1)*b(3) */
       pdMat[M23] = a.pdVec[V2]*b.pdVec[V3];   /* m(2,3) = a(2)*b(3) */
       pdMat[M33] = a.pdVec[V3]*b.pdVec[V3];   /* m(3,3) = a(3)*b(3) */
       return *this;
    };

doublereal Mat3x3::Tr ( void ) const

inline

Definition at line 1361 of file matvec3.h.

References M11, M22, M33, and pdMat.

Referenced by MatR2EulerParams().

                              {
       return pdMat[M11]+pdMat[M22]+pdMat[M33];
    };

doublereal Mat3x3::Trace ( void ) const

inline

Definition at line 836 of file matvec3.h.

References M11, M22, M33, and pdMat.

Referenced by EigSym(), CGR_Rot::Param_Manip::Manipulate(), MatR2gparam(), and RotManip::VecRot().

                                 {
       return pdMat[M11]+pdMat[M22]+pdMat[M33];
    };

Mat3x3 Mat3x3::Transpose ( void ) const

inline

Definition at line 816 of file matvec3.h.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, Mat3x3(), and pdMat.

Referenced by Brake::AfterConvergence(), DriveHingeJoint::AfterPredict(), ElasticHingeJointInv::AfterPredict(), ViscousHingeJointInv::AfterPredict(), ViscoElasticHingeJointInv::AfterPredict(), HydrodynamicPlainBearing::AssJac(), AerodynamicBody::AssJac(), AerodynamicBeam::AssJac(), AerodynamicBeam2::AssJac(), Modal::AssRes(), CyclocopterNoInflow::AssRes(), CyclocopterUniform1D::AssRes(), CyclocopterUniform2D::AssRes(), CyclocopterPolimi::AssRes(), HBeam::AssStiffnessVec(), GimbalRotationJoint::AssVec(), ElasticJointInv::AssVec(), Compute(), ViscousBody::dGetPrivData(), DeformableJoint::dGetPrivData(), HBeam::DsDxi(), LocalNodeResForces::Force(), getelemparams(), MBDynParser::GetMatAbs(), RoTrManip::Helix(), InLineWithOffsetJoint::InitialAssJac(), InPlaneWithOffsetJoint::InitialAssJac(), Modal::InitialAssRes(), Rotor::InitParam(), main(), LocalNodeResForces::Moment(), GimbalRotationJoint::Output(), DriveDisplacementJoint::Output(), UniversalPinJoint::Output(), DataManager::ReadOneElem(), ModalExt::Send(), DriveDisplacementJoint::SetValue(), DriveHingeJoint::SetValue(), PrismaticJoint::SetValue(), DeformableAxialJoint::SetValue(), DeformableDispJoint::SetValue(), DeformableHingeJoint::SetValue(), DeformableJoint::SetValue(), TotalJoint::SetValue(), DriveDisplacementPinJoint::SetValue(), TotalPinJoint::SetValue(), and MatExp::Transpose().

                                 {
       /* La funzione non e' ottimizzata. Genera una nuova matrice che 
        * costruisce in modo opportuno. Se si ritiene di dover usare 
        * ripetutamente la matrice trasposta, conviene memorizzarla in
        * una variabile di servizio */
       
       return Mat3x3(pdMat[M11], pdMat[M12], pdMat[M13],
                     pdMat[M21], pdMat[M22], pdMat[M23],
                     pdMat[M31], pdMat[M32], pdMat[M33]);
    };

Here is the call graph for this function:

std::ostream & Mat3x3::Write	(	std::ostream &	out,
		const char *	sFill = `" "`,
		const char *	sFill2 = `NULL`
	)		const

Definition at line 722 of file matvec3.cc.

References M11, M12, M13, M21, M22, M23, M31, M32, M33, and pdMat.

Referenced by ReadModal(), ReadStructNode(), AircraftInstruments::Restart(), TotalForce::Restart(), and Write().

 {
    char* sF2 = (char*)sFill2; 
    if (sFill2 == NULL) {
       sF2 = (char*)sFill;
    }
    out 
      << pdMat[M11] << sFill << pdMat[M12] << sFill << pdMat[M13] << sF2
      << pdMat[M21] << sFill << pdMat[M22] << sFill << pdMat[M23] << sF2
      << pdMat[M31] << sFill << pdMat[M32] << sFill << pdMat[M33];
    
    return out;
 }

Friends And Related Function Documentation

friend class Mat3x3_Manip

friend

Definition at line 553 of file matvec3.h.

friend class Mat3xN

friend

Definition at line 554 of file matvec3.h.

friend class MatNx3

friend

Definition at line 555 of file matvec3.h.

friend class SparseSubMatrixHandler

friend

Definition at line 552 of file matvec3.h.

friend class Vec3

friend

Definition at line 551 of file matvec3.h.

Referenced by Ax(), EigSym(), GetCol(), GetRow(), GetVec(), LDLSolve(), MulTV(), operator*(), and Solve().

Member Data Documentation

doublereal Mat3x3::pdMat[9]

protected

Definition at line 559 of file matvec3.h.

Referenced by Mat3xN::AddMat3x3(), AddTo(), AddVec(), Ax(), Vec3::Cross(), dDet(), dGet(), EigSym(), GetCol(), GetFrom(), GetRow(), GetVec(), Inv(), IsDiag(), IsExactlySame(), IsNull(), IsSame(), IsSymmetric(), LDLSolve(), Mat3xN::LeftMult(), Mat3x3(), MulMT(), MulTM(), MulTMT(), MulTV(), MulTVCross(), MulVCross(), operator()(), Vec3::operator*(), operator*(), operator*=(), operator+(), operator+=(), operator-(), operator-=(), operator/(), operator/=(), operator=(), pGetMat(), Put(), Mat3xN::PutMat3x3(), PutTo(), PutVec(), Reset(), MatNx3::RightMult(), Skew(), Solve(), Mat3xN::SubMat3x3(), SubVec(), Symm(), Symm2(), Tens(), Tr(), Trace(), Transpose(), and Write().

The documentation for this class was generated from the following files:

Public Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation