+ View the NASA Portal

Search JPL

Search CLARAty

- Algorithms- Infrastructure - Doxygen (public)- Doxygen (private)- Tutorials

- Repository- Nightly Build- Nightly Regression- Feature/Bug Tracking- Build Targets- Procedure- Conventions- Tools

Algorithms
[Math Package]

Collaboration diagram for Algorithms:

Classes
class	claraty::Matrix_LU< T >
class	claraty::N_1D_Function_Solver
class	claraty::ND_Function_Minimizer
Functions
template<class T>
Matrix< M_FLOAT >	claraty::inverse (const Matrix< T > &tm)
Vector< int >	claraty::LU_decompose (Matrix< M_FLOAT > &a, int &sgn)
template<class T>
void	claraty::matrix_cholesky (const Matrix< T > &A, Matrix< T > &L)

---

Function Documentation

template<class T>

Matrix< M_FLOAT > claraty::inverse

(

const Matrix< T > &

tm

)

Matrix inverse.

Definition at line 58 of file matrix_inverse.h.

References claraty::N_2D_Array< T >::get_num_of_cols(), claraty::Matrix_LU< T >::inverse(), claraty::N_2D_Array< T >::is_square(), and claraty::to_float().

Referenced by claraty::Wheel_Model::get_ground_contact(), claraty::ME_Body::get_relative_transform(), claraty::Frame::get_relative_transform(), and claraty::inverse().

{
  Matrix<M_FLOAT> fm =  to_float(m);
  int N = fm.get_num_of_cols();
  Matrix<M_FLOAT> im (N, N);
  int sgn;

  if (!m.is_square()) {
    std::cerr << "matrix error: cannot invert a non-square martrix"
              << std::endl;
    return fm;
  }
  else {
    // Perform the LU decomposition of the matrix.
    Matrix_LU<M_FLOAT> lu_matrix(fm);
    if (!lu_matrix.inverse(im)) {
      std::cerr << "matrix error: martrix inversion failed"
                << std::endl;
      return fm;
    }
    
  }
  return im;
}       

Here is the call graph for this function:

Vector<int> claraty::LU_decompose	(	Matrix< M_FLOAT > &	a,
		int &	sgn
	)

template<class T>

void claraty::matrix_cholesky	(	const Matrix< T > &	A,
		Matrix< T > &	L
	)

Cholesky factorization - computes the cholesky factor for a symmetric positive definite matrix A. The matrix must be square, symmetric, and positive definite. It's trivial to check that the matrix is square. It's O(n^2) times memory access, subtraction, absolute value, and comparison to check that the matrix is more or less symmetric. Checking whether the matrix is positive definite can only be done as part of the algorithm by looking for dangerously small or negative pivots.

Parameters:

[in]	A	Symmetric postive definite matrix A
[out]	L	Resultant matrix.

Definition at line 62 of file matrix_cholesky.h.

References claraty::N_2D_Array< T >::get_num_of_cols(), claraty::N_2D_Array< T >::get_num_of_rows(), and claraty::sum().

Referenced by claraty::matrix_solve_symposdef().

{
  int i, j, k; // loop counters
  double sum;  // accumulator
  
  // Get matrix size.  Number of rows and columns should be the same
  int nrows = A.get_num_of_rows();

  // Check that input matrix is square
  if (A.get_num_of_cols()!=nrows){
    //print an error message about non-square matrix
    std::cerr << "matrix_cholesky: Come on, this matrix isn't even square!" << std::endl;
  }

  // Check that the input matrix is symmetric
  for (k=0; k<nrows; k++){
    for (j=0; j<k; j++){
      if (fabs(A(j,k)-A(k,j))>1e-14){
        // Print error message about non-symmetric matrix
        std::cerr << "matrix_cholesky: matrix is not symmetric" << std::endl;
      }
    }
  }
  
  // This only needs to be a size check or a resize for the matrix
  // that holds the factorization.  For now I'm using "=" because I
  // know that this will do what I need.
  L = A;
  
  // Compute lower triangular Cholesky factor (my algorithm)
  for (k=0; k<nrows; k++){
    // First compute diagonal element for this row
    sum = A(k,k);
    for (j=0; j<k; j++){
      sum = sum - L(k,j) * L(k,j);
    }
    if (sum<0)
      // If this is <0, we can't even take the square root.  This part
      // should throw an exception
      std::cerr << "matrix_cholesky: matrix is not positive definite" << std::endl;
    L(k,k) = sqrt( sum );
    if (L(k,k) < 1e-14){
      // This is a dangerously small pivot, issue a warning
      std::cerr << "matrix_cholesky: matrix is ill conditioned" << std::endl;
    }

    // Now fill in the rest of the column
    for (i=(k+1); i<nrows; i++){
      sum = A(k,i);
      for (j=0; j<k; j++){
        sum = sum - L(i,j)*L(k,j);
      }
      L(i,k) = sum / L(k,k);
    }
  }
  
  // Finally, ensure that the superdiagonal triangle is zeroed out,
  // since the result is lower triangular:
  for (i=0; i<nrows; i++){
    for (j=i+1; j<nrows; j++){
      L(i,j) = 0.0;
    }
  }
}

Here is the call graph for this function:

Last modified: June 05 2007 10:19:53

JPL PRIVACY STATEMENT GLOSSARY SITEMAP FEEDBACK CONTACT US

Site Manager: Issa A.D. Nesnas
Site Maintainer: Kelly Breed
Document Clearance #: CL 07-0635