Simbody  3.7
LinearAlgebra.h
Go to the documentation of this file.
1 #ifndef SimTK_LINEAR_ALGEBRA_H_
2 #define SimTK_LINEAR_ALGEBRA_H_
3 
4 /* -------------------------------------------------------------------------- *
5  * Simbody(tm): SimTKmath *
6  * -------------------------------------------------------------------------- *
7  * This is part of the SimTK biosimulation toolkit originating from *
8  * Simbios, the NIH National Center for Physics-Based Simulation of *
9  * Biological Structures at Stanford, funded under the NIH Roadmap for *
10  * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody. *
11  * *
12  * Portions copyright (c) 2006-12 Stanford University and the Authors. *
13  * Authors: Jack Middleton *
14  * Contributors: Michael Sherman *
15  * *
16  * Licensed under the Apache License, Version 2.0 (the "License"); you may *
17  * not use this file except in compliance with the License. You may obtain a *
18  * copy of the License at http://www.apache.org/licenses/LICENSE-2.0. *
19  * *
20  * Unless required by applicable law or agreed to in writing, software *
21  * distributed under the License is distributed on an "AS IS" BASIS, *
22  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
23  * See the License for the specific language governing permissions and *
24  * limitations under the License. *
25  * -------------------------------------------------------------------------- */
26 
33 #include "SimTKcommon.h"
35 
36 
37 namespace SimTK {
38 
39 // default for reciprocal of the condition number
40 // TODO: sherm 080128 I changed this from 0.01 to a more reasonable
41 // value but it is still wrong because the default should depend
42 // on the matrix size, something like max(m,n)*eps^(7/8) where
43 // eps is machine precision for float or double as appropriate.
44 static const double DefaultRecpCondition = 1e-12;
45 
50 public:
51 
52  Factor() {}
54  template <class ELT> Factor( Matrix_<ELT> m );
56  template <class ELT> void solve( const Vector_<ELT>& b, Vector_<ELT>& x ) const;
58  template <class ELT> void solve( const Matrix_<ELT>& b, Matrix_<ELT>& x ) const;
59 
60 }; // class Factor
61 
62 class FactorLURepBase;
63 
68  public:
69 
70  ~FactorLU();
71 
72  FactorLU();
73  FactorLU( const FactorLU& c );
74  FactorLU& operator=(const FactorLU& rhs);
75 
76  template <class ELT> FactorLU( const Matrix_<ELT>& m );
78  template <class ELT> void factor( const Matrix_<ELT>& m );
80  template <class ELT> void solve( const Vector_<ELT>& b, Vector_<ELT>& x ) const;
82  template <class ELT> void solve( const Matrix_<ELT>& b, Matrix_<ELT>& x ) const;
83 
85  template <class ELT> void getL( Matrix_<ELT>& l ) const;
87  template <class ELT> void getU( Matrix_<ELT>& u ) const;
89  template < class ELT > void inverse( Matrix_<ELT>& m ) const;
90 
92  bool isSingular() const;
94  int getSingularIndex() const;
95 
96 
97  protected:
98  class FactorLURepBase *rep;
99 
100 }; // class FactorLU
101 
102 
103 class FactorQTZRepBase;
108  public:
109 
110  ~FactorQTZ();
111 
112  FactorQTZ();
113  FactorQTZ( const FactorQTZ& c );
114  FactorQTZ& operator=(const FactorQTZ& rhs);
116  template <typename ELT> FactorQTZ( const Matrix_<ELT>& m);
118  template <typename ELT> FactorQTZ( const Matrix_<ELT>& m, double rcond );
120  template <typename ELT> FactorQTZ( const Matrix_<ELT>& m, float rcond );
122  template <typename ELT> void factor( const Matrix_<ELT>& m);
124  template <typename ELT> void factor( const Matrix_<ELT>& m, float rcond );
126  template <typename ELT> void factor( const Matrix_<ELT>& m, double rcond );
128  template <typename ELT> void solve( const Vector_<ELT>& b, Vector_<ELT>& x ) const;
130  template <typename ELT> void solve( const Matrix_<ELT>& b, Matrix_<ELT>& x ) const;
131 
132  template < class ELT > void inverse( Matrix_<ELT>& m ) const;
133 
135  int getRank() const;
137  double getRCondEstimate() const;
138 // void setRank(int rank); TBD
139 
140  protected:
141  class FactorQTZRepBase *rep;
142 }; // class FactorQTZ
147  public:
148 
149  ~Eigen();
150 
151  Eigen();
152  Eigen( const Eigen& c );
153  Eigen& operator=(const Eigen& rhs);
154 
156  template <class ELT> Eigen( const Matrix_<ELT>& m );
158  template <class ELT> void factor( const Matrix_<ELT>& m );
160  template <class VAL, class VEC> void getAllEigenValuesAndVectors( Vector_<VAL>& values, Matrix_<VEC>& vectors);
162  template <class T> void getAllEigenValues( Vector_<T>& values);
163 
165  template <class VAL, class VEC> void getFewEigenValuesAndVectors( Vector_<VAL>& values, Matrix_<VEC>& vectors, int ilow, int ihi);
167  template <class T> void getFewEigenVectors( Matrix_<T>& vectors, int ilow, int ihi );
169  template <class T> void getFewEigenValues( Vector_<T>& values, int ilow, int ihi );
170 
172  template <class VAL, class VEC> void getFewEigenValuesAndVectors( Vector_<VAL>& values, Matrix_<VEC>& vectors, typename CNT<VAL>::TReal rlow, typename CNT<VAL>::TReal rhi);
174  template <class T> void getFewEigenVectors( Matrix_<T>& vectors, typename CNT<T>::TReal rlow, typename CNT<T>::TReal rhi );
176  template <class T> void getFewEigenValues( Vector_<T>& values, typename CNT<T>::TReal rlow, typename CNT<T>::TReal rhi );
177 
178 
179  protected:
180  class EigenRepBase *rep;
181 
182 }; // class Eigen
187  public:
188 
189  ~FactorSVD();
191  FactorSVD();
193  FactorSVD( const FactorSVD& c );
195  FactorSVD& operator=(const FactorSVD& rhs);
196 
198  template < class ELT > FactorSVD( const Matrix_<ELT>& m );
201  template < class ELT > FactorSVD( const Matrix_<ELT>& m, float rcond );
204  template < class ELT > FactorSVD( const Matrix_<ELT>& m, double rcond );
206  template < class ELT > void factor( const Matrix_<ELT>& m );
209  template < class ELT > void factor( const Matrix_<ELT>& m, float rcond );
212  template < class ELT > void factor( const Matrix_<ELT>& m, double rcond );
213 
215  template < class T > void getSingularValuesAndVectors( Vector_<typename CNT<T>::TReal>& values,
216  Matrix_<T>& leftVectors, Matrix_<T>& rightVectors );
218  template < class T > void getSingularValues( Vector_<T>& values);
219 
221  int getRank();
223  template < class ELT > void inverse( Matrix_<ELT>& m );
225  template <class ELT> void solve( const Vector_<ELT>& b, Vector_<ELT>& x );
228  template <class ELT> void solve( const Matrix_<ELT>& b, Matrix_<ELT>& x );
229 
230  protected:
231  class FactorSVDRepBase *rep;
232 
233 }; // class FactorSVD
234 
235 } // namespace SimTK
236 
237 #endif //SimTK_LINEAR_ALGEBRA_H_
Class to perform a QTZ (linear least squares) factorization.
Definition: LinearAlgebra.h:107
K::TReal TReal
Definition: CompositeNumericalTypes.h:141
This is the vector class intended to appear in user code for large, variable size column vectors...
Definition: BigMatrix.h:171
This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with o...
Definition: Assembler.h:37
class FactorSVDRepBase * rep
Definition: LinearAlgebra.h:231
Factor()
Definition: LinearAlgebra.h:52
Base class for the various matrix factorizations.
Definition: LinearAlgebra.h:49
class FactorQTZRepBase * rep
Definition: LinearAlgebra.h:141
Includes internal headers providing declarations for the basic SimTK Core classes, including Simmatrix.
class EigenRepBase * rep
Definition: LinearAlgebra.h:180
This is the matrix class intended to appear in user code for large, variable size matrices...
Definition: BigMatrix.h:168
This is the header file that every Simmath compilation unit should include first. ...
Class for performing LU matrix factorizations.
Definition: LinearAlgebra.h:67
Class to compute Eigen values and Eigen vectors of a matrix.
Definition: LinearAlgebra.h:146
Mat< 1, 1, E, CS, RS >::TInvert inverse(const Mat< 1, 1, E, CS, RS > &m)
Specialized 1x1 Mat inverse: costs one divide.
Definition: SmallMatrixMixed.h:899
Class to compute a singular value decomposition of a matrix.
Definition: LinearAlgebra.h:186
class FactorLURepBase * rep
Definition: LinearAlgebra.h:98
#define SimTK_SIMMATH_EXPORT
Definition: SimTKmath/include/simmath/internal/common.h:64
static const double DefaultRecpCondition
Definition: LinearAlgebra.h:44