KrisLibrary
1.0.0
|
Definitions of mathematical concepts and numerical algorithms. More...
Files | |
file | AABB.h |
Functions defining axis-aligned bounding boxes (AABBs). | |
file | angle.h |
Planar (R2) rotation utilities. | |
file | brent.h |
Brent's methods for parabolic minimization of a 1D function. | |
file | Conditioner.h |
Numerical conditioners for a matrix equation A*x=b. | |
file | conjgrad.h |
Template routine using preconditioned conjugate gradient to solve a linear system. | |
file | diffeq.h |
Various methods for solving ordinary differential equations. | |
file | differentiation.h |
Numerical differentiation routines. | |
file | fastmath.h |
Miscellaneous lightweight math routines. | |
file | function.h |
Abstract base classes for function interfaces. | |
file | Householder.h |
Functions for householder transformations. | |
file | math/indexing.h |
Utilities for matrix/vector access / manipulation with index vectors. | |
file | infnan.h |
Cross-platform infinity and not-a-number routines. | |
file | interpolate.h |
Convenience functions for linear interpolation of vectors and matrices. | |
file | math.h |
Common math typedefs, constants, functions. | |
file | metric.h |
Standard vector/matrix metrics. | |
file | misc.h |
Miscellaneous math functions. | |
file | quadrature.h |
Several functions for performing quadrature (function integration) | |
file | math/random.h |
Defines a standard method for random floating-point number generation. | |
file | root.h |
Numerical root-solving routines. | |
file | sparsefunction.h |
Vector field classes with sparse jacobians. | |
file | math/indexing.h |
Utilities for matrix/vector access / manipulation with index vectors. | |
file | vectorfunction.h |
Various basic function classes. | |
Namespaces | |
Math | |
Contains all definitions in the Math package. | |
Math::Quadrature | |
Namespace for quadrature functions. | |
Classes | |
struct | Math::AngleInterval |
A contiguous range of angles. More... | |
struct | Math::AngleSet |
A set of AngleIntervals. More... | |
struct | Math::BLASInterface |
An interface to BLAS. Activated with the preprocessor flag HAVE_BLAS=1. More... | |
class | Math::CholeskyDecomposition< T > |
Performs the Cholesky decomposition. More... | |
class | Math::Complex |
Complex number class (x + iy). More... | |
class | Math::Quaternion |
Complex quaternion class (w + ix + jy + kz). More... | |
struct | Math::Conditioner_SymmDiag |
A matrix conditioner that does a pre/postmultiply with a diagonal S. More... | |
struct | Math::NullPreconditioner< Matrix > |
Identity precondtioner. More... | |
struct | Math::JacobiPreconditioner< Matrix > |
Jacobi preconditioning (inverse of diagonal) More... | |
class | Math::DiagonalMatrixTemplate< T > |
A templated diagonal matrix, represented by a vector of the entries on the diagonal. More... | |
class | Math::RealFunction |
A function from R to R. More... | |
class | Math::RealFunction2 |
class | Math::VectorFunction |
A function from R to R^n, identical to RealFunction except a vector is returned. More... | |
class | Math::ScalarFieldFunction |
A function from R^n to R. More... | |
class | Math::VectorFieldFunction |
A function from R^n to R^m. More... | |
class | Math::DiffEqFunction |
class | Math::Gaussian< T > |
Multivariate gaussian N(mu,K) of d dimensions. More... | |
class | Math::InequalityConstraint |
A vector field with constraints s.t. ci(x) >= 0. More... | |
class | Math::CompositeInequalityConstraint |
class | Math::LimitConstraint |
class | Math::LinearConstraint |
constraint represented as A*x >= b i.e. constraint value is A*x-b More... | |
struct | Math::InequalityConstraintAdaptor |
A class that makes it easier to construct "plugin" classes to alter constraint behavior. More... | |
struct | Math::Interval |
A generic interval {a,b}, where { and } can be either (,[ or ),]. More... | |
struct | Math::OpenInterval |
An open interval (a,b) More... | |
struct | Math::ClosedInterval |
A closed interval [a,b]. More... | |
struct | Math::LAPACKInterface |
An interface to LAPACK. Activated with the preprocessor flag HAVE_CLAPACK=1. More... | |
struct | Math::LDLDecomposition< T > |
Performs the LDL^t decompositoin of a symmetric matrix A. More... | |
class | Math::LUDecomposition< T > |
Forms the LU decomposition A=PLU. More... | |
class | Math::MatrixIterator< T > |
An iterator through MatrixTemplate elements. More... | |
class | Math::MatrixTemplate< T > |
A matrix over the field T. More... | |
class | Math::NormAccumulator< T > |
class | Math::QRDecomposition< T > |
Calculates the QR decomposition. More... | |
class | Math::NRQRDecomposition< T > |
The QR decomposition as computed by the algorithm in Numerical Recipes in C. More... | |
struct | Math::QNHessianUpdater |
Maintains the Cholesky decomposition of the hessian H over Quasi-Newton steps. More... | |
class | Math::RowEchelon< T > |
Compute reduced row-eschelon form for a matrix A. More... | |
class | Math::SparseVectorFunction |
A vector field function with a sparse jacobian. The Jacobian_Sparse and Jacobian_i_Sparse methods must be overridden. More... | |
class | Math::SVDecomposition< T > |
Performs the singular value decomposition. More... | |
class | Math::RobustSVD< T > |
Performs a pre/postconditioned singular value decomposition. More... | |
class | Math::ScalarFieldDirectionalFunction |
A function g(t) that returns f(x+tn) for a scalar field f(x) If ref is true, then x,n are set to refer to the x,n provided in the constructor, rather than to copy. More... | |
class | Math::ScalarFieldProjectionFunction |
class | Math::LinearScalarFieldFunction |
class | Math::QuadraticScalarFieldFunction |
struct | Math::NormSquaredScalarFieldFunction |
A scalar field ||x||^2. More... | |
struct | Math::NormScalarFieldFunction |
A scalar field for the L-d norm, where d is passed into the constructor. More... | |
class | Math::MinimumScalarFieldFunction |
A scalar field min_i xi. More... | |
class | Math::MaximumScalarFieldFunction |
A scalar field max_i xi. More... | |
class | Math::ComposeScalarFieldFunction |
A scalar field h(x) = f(g(x)) More... | |
class | Math::Vector3FieldFunction |
class | Math::LinearVectorFieldFunction |
class | Math::Compose_SF_VF_Function |
A scalar field function h(x) = f(g(x)) (g vector-valued) More... | |
class | Math::Compose_VF_VF_Function |
A vector field function h(x) = f(g(x)) (f,g vector fields) More... | |
class | Math::ComponentVectorFieldFunction |
class | Math::VectorFieldProjectionFunction |
A function g(x) that returns the i'th component of vector field f(x) More... | |
class | Math::CompositeVectorFieldFunction |
class | Math::IndexedVectorFieldFunction |
A vector field function f(x) = g(x[xindices])[findices]. More... | |
class | Math::SliceVectorFieldFunction |
A vector field function f(x) = g(x0 | x0[xindices]=x) More... | |
class | Math::VectorIterator< T > |
An iterator through VectorTemplate elements. More... | |
class | Math::VectorTemplate< T > |
A vector over the field T. More... | |
Typedefs | |
typedef double | Math::Real |
typedef Real(* | Math::QuadratureFunction) (RealFunction &, Real, Real) |
Enumerations | |
enum | ConvergenceResult { ConvergenceX, ConvergenceF, Divergence, LocalMinimum, MaxItersReached, ConvergenceError } |
Functions | |
void | Math::AABBClamp (Vector &x, const Vector &bmin, const Vector &bmax, Real d=Zero) |
Clamps x to be contained in the AABB (bmin,bmax) | |
Real | Math::AABBMargin (const Vector &x, const Vector &bmin, const Vector &bmax, int &index) |
Real | Math::AABBMargin (const Vector &x, const Vector &bmin, const Vector &bmax) |
bool | Math::AABBContains (const Vector &x, const Vector &bmin, const Vector &bmax, Real d=Zero) |
Returns true if the AABB (bmin,bmax) contains x. | |
int | Math::AABBLineSearch (const Vector &x0, const Vector &dx, const Vector &bmin, const Vector &bmax, Real &t) |
bool | Math::AABBClipLine (const Vector &x0, const Vector &dx, const Vector &bmin, const Vector &bmax, Real &u0, Real &u1) |
Real | Math::AngleNormalize (Real a) |
Normalizes an angle to [0,2pi) | |
Real | Math::AngleDiff (Real a, Real b) |
Returns the closest distance to get to a from b (range [-pi,pi]) | |
Real | Math::AngleCCWDiff (Real a, Real b) |
Returns the CCW distance needed to get to a from b. | |
Real | Math::AngleInterp (Real a, Real b, Real u) |
Interpolates between rotations a and b (u from 0 to 1) | |
bool | Math::IsValidAngle (Real a) |
void | Math::Acos_All (Real x, Real &a, Real &b) |
returns all solutions y to cos(y)=x in a,b | |
void | Math::Asin_All (Real x, Real &a, Real &b) |
returns all solutions y to sin(y)=x in a,b | |
void | Math::Atan_All (Real x, Real &a, Real &b) |
returns all solutions y to tan(y)=x in a,b | |
void | Math::TransformCosSin_Cos (Real a, Real b, Real &c, Real &d) |
void | Math::TransformCosSin_Sin (Real a, Real b, Real &c, Real &d) |
Same as above, but returns c*sin(x+d) | |
bool | Math::SolveCosSinEquation (Real a, Real b, Real c, Real &t1, Real &t2) |
void | Math::SolveCosSinGreater (Real a, Real b, Real c, AngleInterval &i) |
Same as above, but a cos(x) + b sin(x) >= c. | |
void | Math::BracketMin (Real &a, Real &b, Real &c, Real &fa, Real &fb, Real &fc, RealFunction &func) |
Returns a bracketing triplet given some a,b. More... | |
ConvergenceResult | Math::ParabolicMinimization (Real ax, Real bx, Real cx, RealFunction &f, int &maxIters, Real tol, Real &xmin) |
Brent's algorithm for parabolic minimization. More... | |
ConvergenceResult | Math::ParabolicMinimization (Real x, RealFunction &f, int &maxIters, Real tol, Real &xmin) |
Real | Math::ParabolicLineMinimization (ScalarFieldFunction &f, const Vector &x, const Vector &n, int maxIters, Real tol) |
Real | Math::ParabolicLineMinimization_i (ScalarFieldFunction &f, const Vector &x, int i, int maxIters, Real tol) |
Same as above, but minimizes f(x + t*ei). | |
template<class Matrix , class Preconditioner > | |
int | Math::CG (const Matrix &A, Vector &x, const Vector &b, const Preconditioner &M, int &max_iter, Real &tol) |
Real | Math::RungeKutta4_step (RealFunction2 *f, Real t0, Real h, Real w) |
Runge-Kutta 4 step for 1D ODEs. More... | |
Real | Math::RungeKutta4 (RealFunction2 *f, Real a, Real b, Real alpha, int n) |
Runge-Kutta 4 method for 1D ODEs. More... | |
Real | Math::RKF (RealFunction2 *f, Real a, Real b, Real alpha, Real tol, Real hmax, Real hmin) |
Runge-Kutta-Fehlberg method for 1D ODEs. More... | |
Real | Math::AM2I (RealFunction2 *f, Real h, Real t0, Real t1, Real t2, Real w0, Real w1, Real w2) |
Adams-Moulton 2 step implicit method for 1D ODEs. More... | |
Real | Math::AM2E (RealFunction2 *f, Real h, Real t0, Real t1, Real w0, Real w1) |
Adams-Bashforth 2 step explicit method for 1D ODEs. More... | |
Real | Math::AM2_predictor_corrector_step (RealFunction2 *f, Real h, Real t0, Real t1, Real t2, Real w0, Real w1) |
Adams-Moulton predictor-corrector step of order 2 for 1D ODEs. | |
Real | Math::AM2_predictor_corrector (RealFunction2 *f, Real a, Real b, Real alpha0, Real alpha1, int n) |
Adams-Moulton predictor-corrector of order 2 for 1D ODEs. | |
void | Math::Euler_step (DiffEqFunction *f, Real t0, Real h, const Vector &w0, Vector &w1) |
Euler step for an ODE system. More... | |
void | Math::RungeKutta4_step (DiffEqFunction *f, Real t0, Real h, const Vector &w0, Vector &w1) |
Runge-Kutta 4 step for an ODE system. More... | |
void | Math::Euler (DiffEqFunction *f, Real a, Real b, const Vector &alpha, int n, Vector &wn) |
Solve an ODE system using Euler's method. More... | |
void | Math::RungeKutta4 (DiffEqFunction *f, Real a, Real b, const Vector &alpha, int n, Vector &wn) |
Solve an ODE system using the Runge Kutta 4 method. More... | |
Real | Math::dfCenteredDifference (RealFunction &f, Real x, Real h) |
void | Math::dfCenteredDifference (VectorFunction &f, Real x, Real h, Vector &df) |
Real | Math::dfCenteredDifferenceAdaptive (RealFunction &f, Real x, Real h0, Real tol) |
void | Math::dfCenteredDifferenceAdaptive (VectorFunction &f, Real x, Real h0, Real tol, Vector &df) |
Real | Math::ddfCenteredDifference (RealFunction &f, Real x, Real h) |
void | Math::ddfCenteredDifference (VectorFunction &f, Real x, Real h, Vector &ddf) |
void | Math::GradientForwardDifference (ScalarFieldFunction &f, Vector &x, Real h, Vector &g) |
x is provided as a temporary, it's restored to its original value later | |
void | Math::JacobianForwardDifference (VectorFieldFunction &f, Vector &x, Real h, Matrix &J) |
void | Math::HessianForwardDifference (ScalarFieldFunction &f, Vector &x, Real h, Matrix &H) |
void | Math::HessianForwardDifference_Grad (ScalarFieldFunction &f, Vector &x, Real h, Matrix &H) |
void | Math::GradientCenteredDifference (ScalarFieldFunction &f, Vector &x, Real h, Vector &g) |
void | Math::JacobianCenteredDifference (VectorFieldFunction &f, Vector &x, Real h, Matrix &J) |
void | Math::HessianCenteredDifference (ScalarFieldFunction &f, Vector &x, Real h, Matrix &H) |
void | Math::HessianCenteredDifference_Grad (ScalarFieldFunction &f, Vector &x, Real h, Matrix &H) |
void | Math::GradientCenteredDifferenceAdaptive (ScalarFieldFunction &f, Vector &x, Real h0, Real tol, Vector &g) |
void | Math::GradientForwardDifference (ScalarFieldFunction &f, Vector &x, const Vector &h, Vector &g) |
specified hi in each direction xi | |
void | Math::JacobianForwardDifference (VectorFieldFunction &f, Vector &x, const Vector &h, Matrix &J) |
void | Math::HessianForwardDifference (ScalarFieldFunction &f, Vector &x, const Vector &h, Matrix &H) |
void | Math::HessianForwardDifference_Grad (ScalarFieldFunction &f, Vector &x, const Vector &h, Matrix &H) |
void | Math::GradientCenteredDifference (ScalarFieldFunction &f, Vector &x, const Vector &h, Vector &g) |
void | Math::JacobianCenteredDifference (VectorFieldFunction &f, Vector &x, const Vector &h, Matrix &J) |
void | Math::HessianCenteredDifference (ScalarFieldFunction &f, Vector &x, const Vector &h, Matrix &H) |
void | Math::HessianCenteredDifference_Grad (ScalarFieldFunction &f, Vector &x, const Vector &h, Matrix &H) |
virtual std::string | Math::RealFunction::Label () const |
virtual std::string | Math::RealFunction::VariableLabel () const |
virtual Real | Math::RealFunction::operator() (Real t) |
virtual void | Math::RealFunction::PreEval (Real t) |
virtual Real | Math::RealFunction::Eval (Real t)=0 |
virtual Real | Math::RealFunction::Deriv (Real t) |
virtual Real | Math::RealFunction::Deriv2 (Real t) |
virtual std::string | Math::RealFunction2::Label () const |
virtual std::string | Math::RealFunction2::VariableLabel (int i) const |
virtual Real | Math::RealFunction2::operator() (Real t, Real x) |
virtual void | Math::RealFunction2::PreEval (Real t, Real x) |
virtual Real | Math::RealFunction2::Eval (Real t, Real x)=0 |
virtual std::string | Math::VectorFunction::Label () const |
virtual std::string | Math::VectorFunction::Label (int i) const |
virtual std::string | Math::VectorFunction::VariableLabel () const |
virtual int | Math::VectorFunction::NumDimensions () const |
virtual void | Math::VectorFunction::operator() (Real t, Vector &x) |
virtual void | Math::VectorFunction::PreEval (Real t) |
virtual void | Math::VectorFunction::Eval (Real t, Vector &x)=0 |
virtual void | Math::VectorFunction::Deriv (Real t, Vector &dx) |
virtual void | Math::VectorFunction::Deriv2 (Real t, Vector &ddx) |
virtual std::string | Math::ScalarFieldFunction::Label () const |
virtual std::string | Math::ScalarFieldFunction::VariableLabel (int i) const |
virtual Real | Math::ScalarFieldFunction::operator() (const Vector &x) |
virtual void | Math::ScalarFieldFunction::PreEval (const Vector &x) |
virtual Real | Math::ScalarFieldFunction::Eval (const Vector &x)=0 |
virtual void | Math::ScalarFieldFunction::Gradient (const Vector &x, Vector &grad) |
virtual Real | Math::ScalarFieldFunction::Gradient_i (const Vector &x, int i) |
virtual Real | Math::ScalarFieldFunction::DirectionalDeriv (const Vector &x, const Vector &h) |
virtual void | Math::ScalarFieldFunction::Hessian (const Vector &x, Matrix &H) |
virtual Real | Math::ScalarFieldFunction::Hessian_ij (const Vector &x, int i, int j) |
virtual Real | Math::ScalarFieldFunction::DirectionalDeriv2 (const Vector &x, const Vector &h) |
virtual std::string | Math::VectorFieldFunction::Label () const |
virtual std::string | Math::VectorFieldFunction::Label (int i) const |
virtual std::string | Math::VectorFieldFunction::VariableLabel (int i) const |
virtual int | Math::VectorFieldFunction::NumDimensions () const |
virtual void | Math::VectorFieldFunction::operator() (const Vector &x, Vector &v) |
virtual void | Math::VectorFieldFunction::PreEval (const Vector &x) |
virtual void | Math::VectorFieldFunction::Eval (const Vector &x, Vector &v)=0 |
virtual Real | Math::VectorFieldFunction::Eval_i (const Vector &x, int i) |
virtual Real | Math::VectorFieldFunction::Jacobian_ij (const Vector &x, int i, int j) |
virtual void | Math::VectorFieldFunction::Jacobian_i (const Vector &x, int i, Vector &Ji) |
virtual void | Math::VectorFieldFunction::Jacobian_j (const Vector &x, int j, Vector &Jj) |
virtual void | Math::VectorFieldFunction::Jacobian (const Vector &x, Matrix &J) |
virtual void | Math::VectorFieldFunction::DirectionalDeriv (const Vector &x, const Vector &h, Vector &v) |
virtual Real | Math::VectorFieldFunction::Divergence (const Vector &x) |
virtual void | Math::VectorFieldFunction::Hessian_i (const Vector &x, int i, Matrix &Hi) |
virtual Real | Math::VectorFieldFunction::Hessian_ijk (const Vector &x, int i, int j, int k) |
virtual int | Math::DiffEqFunction::NumDimensions () const |
virtual void | Math::DiffEqFunction::operator() (Real t, const Vector &y, Vector &fy) |
virtual void | Math::DiffEqFunction::PreEval (Real t, const Vector &y) |
virtual void | Math::DiffEqFunction::Eval (Real t, const Vector &y, Vector &fy)=0 |
template<class T > | |
int | Math::OrthonormalBasis (const VectorTemplate< T > *x, VectorTemplate< T > *basis, int n) |
template<class T > | |
int | Math::OrthogonalBasis (const VectorTemplate< T > *x, VectorTemplate< T > *basis, int n) |
Same as above, but does not normalize. | |
template<class T > | |
void | Math::Orthogonalize (VectorTemplate< T > &x, const VectorTemplate< T > *basis, int n) |
orthogonalizes a vector w.r.t the orthogonal basis of n vectors | |
template<class T > | |
T | Math::HouseholderTransform (VectorTemplate< T > &v) |
template<class T > | |
void | Math::HouseholderPreMultiply (T tau, const VectorTemplate< T > &v, MatrixTemplate< T > &A) |
template<class T > | |
void | Math::HouseholderPostMultiply (T tau, const VectorTemplate< T > &v, MatrixTemplate< T > &A) |
template<class T > | |
void | Math::HouseholderApply (T tau, const VectorTemplate< T > &v, VectorTemplate< T > &w) |
template<class T > | |
void | Math::HouseholderHM1 (T tau, MatrixTemplate< T > &A) |
template<class T > | |
void | Math::SetElements (VectorTemplate< T > &A, const std::vector< int > &indices, T fill) |
Sets A[indices] = fill. | |
template<class T > | |
void | Math::SetElements (VectorTemplate< T > &A, const std::vector< int > &indices, const VectorTemplate< T > &fill) |
Sets A[indices] = fill. More... | |
template<class T > | |
void | Math::GetElements (const VectorTemplate< T > &A, const std::vector< int > &indices, VectorTemplate< T > &B) |
Sets B = A[indices]. | |
template<class T > | |
void | Math::CopyElements (VectorTemplate< T > &A, const std::vector< int > &aindices, const VectorTemplate< T > &B, const std::vector< int > &bindices) |
Sets A[aindices] = B[bindices]. | |
template<class T > | |
void | Math::RemoveElements (VectorTemplate< T > &A, const std::vector< int > &indices) |
Removes the indexed elements of A (shrinking A) | |
template<class T > | |
void | Math::RemoveElements (SparseArray< T > &A, const std::vector< int > &indices) |
Removes the indexed elements of A (shrinking A) | |
template<class T > | |
void | Math::AddElements (VectorTemplate< T > &A, const std::vector< int > &indices, T fill) |
The inverse of RemoveElements. More... | |
template<class T > | |
void | Math::SetRows (MatrixTemplate< T > &A, const std::vector< int > &indices, T fill) |
Sets the indexed rows of A to fill. | |
template<class T > | |
void | Math::SetElements (MatrixTemplate< T > &A, const std::vector< int > &rows, const std::vector< int > &cols, T fill) |
Sets A[r,c] = fill for all r in rows and all c in columns. | |
template<class T > | |
void | Math::SetElements (MatrixTemplate< T > &A, const std::vector< int > &rows, const std::vector< int > &cols, const MatrixTemplate< T > &fill) |
Sets A[r,c] = fill for all r in rows and all c in columns. More... | |
template<class T > | |
void | Math::GetElements (const MatrixTemplate< T > &A, const std::vector< int > &rows, const std::vector< int > &cols, MatrixTemplate< T > &B) |
Sets B[i,j] = A[rows[i],cols[j]] for all i and j. | |
template<class T > | |
void | Math::CopyElements (MatrixTemplate< T > &A, const std::vector< int > &arows, const std::vector< int > &acols, const MatrixTemplate< T > &B, const std::vector< int > &brows, const std::vector< int > &bcols) |
Sets A[ar,ac] = B[br,bc] for all (ar,br) in arows x brows, (ac,bc) in acols x bcols. | |
template<class T > | |
void | Math::RemoveElements (MatrixTemplate< T > &A, const std::vector< int > &rows, const std::vector< int > &cols) |
Removes the indexed rows and columns of A (shrinking A) | |
template<class T > | |
void | Math::SetColumns (MatrixTemplate< T > &A, const std::vector< int > &indices, T fill) |
Sets the indexed columns of A to fill. | |
template<class T > | |
void | Math::SetRows (MatrixTemplate< T > &A, const std::vector< int > &indices, const VectorTemplate< T > &fill) |
Sets the indexed rows of A to the vector fill. | |
template<class T > | |
void | Math::SetColumns (MatrixTemplate< T > &A, const std::vector< int > &indices, const VectorTemplate< T > &fill) |
Sets the indexed columns of A to the vector fill. | |
template<class T > | |
void | Math::SetRows (MatrixTemplate< T > &A, const std::vector< int > &indices, const MatrixTemplate< T > &fill) |
Sets the indexed rows of A to the columns of the matrix fill. More... | |
template<class T > | |
void | Math::SetColumns (MatrixTemplate< T > &A, const std::vector< int > &indices, const MatrixTemplate< T > &fill) |
Sets the indexed columns of A to the columns of the matrix fill. More... | |
template<class T > | |
void | Math::GetRows (const MatrixTemplate< T > &A, const std::vector< int > &indices, MatrixTemplate< T > &B) |
Copies the indexed rows in A into B. More... | |
template<class T > | |
void | Math::GetColumns (const MatrixTemplate< T > &A, const std::vector< int > &indices, MatrixTemplate< T > &B) |
Copies the indexed columns in A into B. More... | |
template<class T > | |
void | Math::RemoveRows (MatrixTemplate< T > &A, const std::vector< int > &indices) |
Removes the rows of A indexed by the sorted list indices. | |
template<class T > | |
void | Math::RemoveColumns (MatrixTemplate< T > &A, const std::vector< int > &indices) |
Removes the columns of A indexed by the sorted indices. | |
template<class T > | |
void | Math::RemoveRows (SparseMatrixTemplate_RM< T > &A, const std::vector< int > &indices) |
Removes the rows of A indexed by the sorted list indices. | |
template<class T > | |
void | Math::RemoveColumns (SparseMatrixTemplate_RM< T > &A, const std::vector< int > &indices) |
Removes the columns of A indexed by the sorted indices. | |
int | Math::IsNaN (double x) |
Returns nonzero if x is not-a-number (NaN) | |
int | Math::IsNaN (float x) |
int | Math::IsFinite (double x) |
Returns nonzero unless x is infinite or a NaN. | |
int | Math::IsFinite (float x) |
int | Math::IsInf (double x) |
Returns +1 if x is +inf, -1 if x is -inf, and 0 otherwise. | |
int | Math::IsInf (float x) |
template<class T > | |
bool | Math::LinearlyDependent_Robust (const VectorTemplate< T > &a, const VectorTemplate< T > &b, T &c, bool &cb, T eps=Epsilon) |
Robust determination of linear dependence. More... | |
template<class T > | |
bool | Math::LinearlyDependent_Robust (const MatrixTemplate< T > &A, VectorTemplate< T > &c, T eps=Epsilon) |
A matrix version of the function above. More... | |
double | Math::Abs (double x) |
double | Math::Sqr (double x) |
double | Math::Sqrt (double x) |
double | Math::Exp (double x) |
double | Math::Log (double x) |
double | Math::Pow (double x, double y) |
double | Math::Sin (double x) |
double | Math::Cos (double x) |
double | Math::Tan (double x) |
double | Math::Sinh (double x) |
double | Math::Cosh (double x) |
double | Math::Tanh (double x) |
double | Math::Asin (double x) |
double | Math::Acos (double x) |
double | Math::Atan (double x) |
double | Math::Atan2 (double y, double x) |
double | Math::Floor (double x) |
double | Math::Ceil (double x) |
double | Math::Mod (double x, double y) |
float | Math::Abs (float x) |
float | Math::Sqr (float x) |
float | Math::Sqrt (float x) |
float | Math::Exp (float x) |
float | Math::Log (float x) |
float | Math::Pow (float x, float y) |
float | Math::Sin (float x) |
float | Math::Cos (float x) |
float | Math::Tan (float x) |
float | Math::Sinh (float x) |
float | Math::Cosh (float x) |
float | Math::Tanh (float x) |
float | Math::Asin (float x) |
float | Math::Acos (float x) |
float | Math::Atan (float x) |
float | Math::Atan2 (float y, float x) |
float | Math::Floor (float x) |
float | Math::Ceil (float x) |
float | Math::Mod (float x, float y) |
double | Math::Inv (double x) |
1/x | |
double | Math::Sign (double x) |
Returns {-1,0,1} if x is {<0,0,>0}. | |
double | Math::Clamp (double x, double a, double b) |
Returns a if x < a, b if x > b, otherwise x. | |
double | Math::Trunc (double x) |
double | Math::Frac (double x) |
float | Math::Inv (float x) |
float | Math::Sign (float x) |
float | Math::Clamp (float x, float a, float b) |
float | Math::Trunc (float x) |
float | Math::Frac (float x) |
double | Math::dot (double a, double b) |
Dot product of a scalar as a 1-d vector. | |
bool | Math::FuzzyEquals (double a, double b, double eps=dEpsilon) |
Returns true if a and b are within +/- eps. | |
bool | Math::FuzzyZero (double a, double eps=dEpsilon) |
Returns true if a is zero within +/- eps. | |
double | Math::PseudoInv (double x, double eps=dZero) |
Returns 1/x if x is nonzero, otherwise 0. | |
float | Math::dot (float a, float b) |
bool | Math::FuzzyEquals (float a, float b, float eps=fEpsilon) |
bool | Math::FuzzyZero (float a, float eps=fEpsilon) |
float | Math::PseudoInv (float x, float eps=fZero) |
template<class T > | |
Real | Math::Delta (T i, T j) |
Kronecker delta. | |
template<class T > | |
Real | Math::Delta (T x) |
double | Math::DtoR (double f) |
Degree to radian conversion. | |
double | Math::RtoD (double f) |
Radian to degree conversion. | |
float | Math::DtoR (float f) |
float | Math::RtoD (float f) |
template<class T > | |
T | Math::Norm (const VectorTemplate< T > &x, Real norm) |
template<class T > | |
T | Math::Norm_L1 (const VectorTemplate< T > &x) |
template<class T > | |
T | Math::Norm_L2 (const VectorTemplate< T > &x) |
template<class T > | |
T | Math::Norm_L2_Safe (const VectorTemplate< T > &x) |
Same as above, but robust to over/underflow. | |
template<class T > | |
T | Math::Norm_LInf (const VectorTemplate< T > &x) |
template<class T > | |
T | Math::Norm_Mahalanobis (const VectorTemplate< T > &x, const MatrixTemplate< T > &A) |
template<class T > | |
T | Math::Norm_Weighted (const VectorTemplate< T > &x, Real norm, const VectorTemplate< T > &w) |
template<class T > | |
T | Math::Norm_WeightedL1 (const VectorTemplate< T > &x, const VectorTemplate< T > &w) |
template<class T > | |
T | Math::Norm_WeightedL2 (const VectorTemplate< T > &x, const VectorTemplate< T > &w) |
template<class T > | |
T | Math::Norm_WeightedLInf (const VectorTemplate< T > &x, const VectorTemplate< T > &w) |
template<class T > | |
T | Math::Distance (const VectorTemplate< T > &x, const VectorTemplate< T > &y, Real norm) |
template<class T > | |
T | Math::Distance_L1 (const VectorTemplate< T > &x, const VectorTemplate< T > &y) |
template<class T > | |
T | Math::Distance_L2 (const VectorTemplate< T > &x, const VectorTemplate< T > &y) |
template<class T > | |
T | Math::Distance_L2_Safe (const VectorTemplate< T > &x, const VectorTemplate< T > &y) |
Same as above, but robust to over/underflow. | |
template<class T > | |
T | Math::Distance_LInf (const VectorTemplate< T > &x, const VectorTemplate< T > &y) |
template<class T > | |
T | Math::Distance_Mahalanobis (const VectorTemplate< T > &x, const VectorTemplate< T > &y, const MatrixTemplate< T > &A) |
template<class T > | |
T | Math::Distance_Weighted (const VectorTemplate< T > &x, const VectorTemplate< T > &y, Real norm, const VectorTemplate< T > &w) |
template<class T > | |
T | Math::Distance_WeightedL1 (const VectorTemplate< T > &x, const VectorTemplate< T > &y, const VectorTemplate< T > &w) |
template<class T > | |
T | Math::Distance_WeightedL2 (const VectorTemplate< T > &x, const VectorTemplate< T > &y, const VectorTemplate< T > &w) |
template<class T > | |
T | Math::Distance_WeightedLInf (const VectorTemplate< T > &x, const VectorTemplate< T > &y, const VectorTemplate< T > &w) |
template<class T > | |
T | Math::Norm_L1 (const MatrixTemplate< T > &A) |
template<class T > | |
T | Math::Norm_LInf (const MatrixTemplate< T > &A) |
template<class T > | |
T | Math::Norm_Frobenius (const MatrixTemplate< T > &A) |
template<class T > | |
T | Math::Norm_Frobenius_Safe (const MatrixTemplate< T > &A) |
Same as above, but robust to over/underflow. | |
template<class T > | |
T | Math::Distance_L1 (const MatrixTemplate< T > &A, const MatrixTemplate< T > &B) |
template<class T > | |
T | Math::Distance_LInf (const MatrixTemplate< T > &A, const MatrixTemplate< T > &B) |
template<class T > | |
T | Math::Distance_Frobenius (const MatrixTemplate< T > &A, const MatrixTemplate< T > &B) |
template<class T > | |
T | Math::Distance_Frobenius_Safe (const MatrixTemplate< T > &A, const MatrixTemplate< T > &B) |
Same as above, but robust to over/underflow. | |
int | Math::quadratic (double a, double b, double c, double &x1, double &x2) |
int | Math::cubic (double a, double b, double c, double d, double x[3]) |
double | Math::pythag (double a, double b) |
Returns c where a^2+b^2=c^2. | |
double | Math::pythag_leg (double a, double c) |
Returns b where a^2+b^2=c^2. | |
double | Math::Sinc (double x) |
Computes the sinc function sin(x)/x (stable for small x) | |
double | Math::Sinc_Dx (double x) |
Computes the derivative of the sinc function. | |
double | Math::dFactorial (unsigned int n) |
Computes the factorial of n, with double precision. | |
double | Math::dLogFactorial (unsigned int n) |
Computes the log of the factorial of n. | |
double | Math::dChoose (unsigned int n, unsigned int k) |
Computes n choose k in double precision. | |
double | Math::dLogChoose (unsigned int n, unsigned int k) |
Computes the log of n choose k. | |
double | Math::TaylorCoeff (double x, unsigned int n) |
Computes the taylor series coefficient x^n/n! | |
double | Math::Gamma (double x) |
Computes the gamma function. | |
double | Math::LogGamma (double x) |
Computes log gamma(x) | |
double | Math::GammaInv (double x) |
Computes 1 / gamma(x) | |
double | Math::Beta (double a, double b) |
Computes the beta function B(a,b) | |
double | Math::LogBeta (double a, double b) |
Computes log B(a,b) | |
double | Math::NormalizedIncompleteBeta (double a, double b, double x) |
Computes the normalized incomplete beta function B(a,b,x) | |
double | Math::Erf (double x) |
Computes the error function. | |
double | Math::ErfComplimentary (double x) |
Computes the complimentary error function? | |
int | Math::FuzzySign (double x, double eps=dEpsilon) |
Returns -1 if x<eps, 0 if |x|<=eps, 1 if x>eps. | |
bool | Math::OpposingSigns_pos (double a, double b) |
bool | Math::OpposingSigns_neg (double a, double b) |
Same as above, but treats 0 as a negative number. | |
int | Math::quadratic (float a, float b, float c, float &x1, float &x2) |
int | Math::cubic (float a, float b, float c, float d, float x[3]) |
float | Math::pythag (float a, float b) |
float | Math::pythag_leg (float a, float c) |
float | Math::Sinc (float x) |
float | Math::Sinc_Dx (float x) |
float | Math::fFactorial (unsigned int n) |
float | Math::fLogFactorial (unsigned int n) |
float | Math::fChoose (unsigned int n, unsigned int k) |
float | Math::fLogChoose (unsigned int n, unsigned int k) |
float | Math::TaylorCoeff (float x, unsigned int n) |
float | Math::Gamma (float x) |
float | Math::LogGamma (float x) |
float | Math::GammaInv (float x) |
float | Math::Beta (float a, float b) |
float | Math::LogBeta (float a, float b) |
float | Math::NormalizedIncompleteBeta (float a, float b, float x) |
float | Math::Erf (float x) |
float | Math::ErfComplimentary (float x) |
int | Math::FuzzySign (float x, float eps=fEpsilon) |
bool | Math::OpposingSigns_pos (float a, float b) |
bool | Math::OpposingSigns_neg (float a, float b) |
template<class T > | |
T | Math::IntegerPower (const T x, int i) |
Calculates x^i where i is an integer (in O(log i) time) | |
unsigned int | Math::Factorial (unsigned int n) |
Returns n! in O(n) time. | |
unsigned int | Math::FactorialTruncated (unsigned int n, unsigned int k) |
Returns n!/(n-k)! in O(k) time. | |
unsigned int | Math::Choose (unsigned int n, unsigned int k) |
Returns `n choose k' = n!/k!(n-k)! in O(k) time. | |
Real | Math::rFactorial (unsigned int n) |
Real | Math::LogFactorial (unsigned int n) |
Real | Math::rChoose (unsigned int n, unsigned int k) |
Real | Math::LogChoose (unsigned int n, unsigned int k) |
void | Math::Srand (unsigned long seed) |
long int | Math::RandInt () |
Generates a random int. | |
long int | Math::RandInt (long int n) |
Real | Math::Rand () |
Generates a random Real uniformly in [0,1]. | |
Real | Math::Rand (Real a, Real b) |
Generates a random Real uniformly in [a,b]. | |
Real | Math::RandGaussian () |
Real | Math::RandGaussian (Real mean, Real stddev) |
Generates a random Real in a Gaussian distribution. | |
bool | Math::RandBool () |
Generates a random boolean that is true with probability 0.5. | |
bool | Math::RandBool (Real p) |
Generates a random boolean that is true with probability p. | |
std::ostream & | Math::operator<< (std::ostream &out, ConvergenceResult r) |
ConvergenceResult | Math::Root_Bisection (RealFunction &f, Real &a, Real &b, Real &x, Real tol) |
Uses bisection to bracket f's root. More... | |
ConvergenceResult | Math::Root_Secant (RealFunction &f, Real x0, Real &x1, int &maxIters, Real tolx, Real tolf) |
Uses the secant method to search for f's root. More... | |
ConvergenceResult | Math::Root_SecantBracket (RealFunction &f, Real &a, Real &b, Real &x, int &iters, Real tolx, Real tolf) |
ConvergenceResult | Math::Root_Newton (RealFunction &f, Real &x, int &maxIters, Real tolx, Real tolf) |
Performs Newton's method, which uses the derivative of f to search for it's root. More... | |
ConvergenceResult | Math::Root_NewtonBracket (RealFunction &f, Real a, Real b, Real &x, int &maxIters, Real tolx, Real tolf) |
Same as above, but the interval [a,b] must be known to contain a root. | |
ConvergenceResult | Math::Root_Newton (ScalarFieldFunction &f, const Vector &x0, Vector &x, int &maxIters, Real tolx, Real tolf) |
Same as Root_Newton(), but takes a scalar field function as input. | |
ConvergenceResult | Math::Root_Newton (VectorFieldFunction &f, const Vector &x0, Vector &x, int &maxIters, Real tolx, Real tolf) |
Same as Root_Newton(), but takes a vector field function as input. | |
int | Math::WeightedSample (const std::vector< Real > &weights) |
Samples an integer with weighted probability. More... | |
int | Math::WeightedSample (const std::vector< Real > &weights, Real totWeight) |
Same as above, but the sum of all weights, W, is provided. | |
int | Math::CumulativeWeightedSample (const std::vector< Real > &partialSumWeights) |
void | Math::RandomAllocate (std::vector< int > &num, size_t total) |
Allocates total samples within the buckets in num, roughly evenly. An O(n) algorithm where n is the number of buckets. More... | |
void | Math::RandomAllocate (std::vector< int > &num, size_t total, const std::vector< Real > &weights) |
Same as above, but with weights. More... | |
Real | Math::Sample (const Interval &s) |
Uniformly samples the given intervals. | |
Real | Math::Sample (const ClosedIntervalSet &s) |
Uniformly samples the interval set. | |
void | Math::SampleCircle (Real r, Real &x, Real &y) |
Uniform distribution on boundary of a circle with radius r. | |
void | Math::SampleDisk (Real r, Real &x, Real &y) |
Uniform distribution inside a circle with radius r. | |
void | Math::SampleTriangle (Real &x, Real &y) |
Uniform distribution in the triangle whose vertices are (0,0),(1,0),(0,1) | |
void | Math::SampleBall (Real r, Real &x, Real &y, Real &z) |
Uniform distribution on boundary of a sphere with radius r. | |
void | Math::SampleSphere (Real r, Real &x, Real &y, Real &z) |
Uniform distribution inside a sphere with radius r. | |
void | Math::SampleHyperBall (Real r, std::vector< Real > &v) |
Uniformly samples from a hyper-ball of dimension v.size() | |
void | Math::SampleHyperSphere (Real r, std::vector< Real > &v) |
Uniformly samples from a hyper-sphere of dimension v.size() | |
virtual void | Math::SparseVectorFunction::Jacobian (const Vector &x, Matrix &J) |
virtual void | Math::SparseVectorFunction::Jacobian_i (const Vector &x, int i, Vector &Ji) |
virtual void | Math::SparseVectorFunction::Hessian_i (const Vector &x, int i, Matrix &Hi) |
virtual void | Math::SparseVectorFunction::Jacobian_Sparse (const Vector &x, SparseMatrix &J)=0 |
virtual void | Math::SparseVectorFunction::Jacobian_i_Sparse (const Vector &x, int i, SparseVector &Ji)=0 |
virtual void | Math::SparseVectorFunction::Hessian_i_Sparse (const Vector &x, int i, SparseMatrix &Hi) |
Variables | |
StandardRNG | Math::rng |
Definitions of mathematical concepts and numerical algorithms.
Generates random gaussian distributed floating point values.
NEEDED ON SOLARIS END SOLARIS SECTION
Uses a given uniform random number generator, generates values in a gaussian with 0 mean and standard deviation 1.
bool Math::AABBClipLine | ( | const Vector & | x0, |
const Vector & | dx, | ||
const Vector & | bmin, | ||
const Vector & | bmax, | ||
Real & | u0, | ||
Real & | u1 | ||
) |
Clips the line segment x=x0+u*dx, with t in [u0,u1] to the AABB (bmin,bmax). Returns false if there is no intersection.
Referenced by AABBContains().
int Math::AABBLineSearch | ( | const Vector & | x0, |
const Vector & | dx, | ||
const Vector & | bmin, | ||
const Vector & | bmax, | ||
Real & | t | ||
) |
For a point inside the AABB (bmin,bmax), limits the desired step t x = x0+t*dx such that x is inside the AABB. Returns the index responsible for this limit
Referenced by AABBContains(), and Optimization::BCMinimizationProblem::LineMinimizationStep().
|
inline |
Returns the minimum distance from x to the boundaries of the AABB (bmin,bmax). Also returns the element index that contains the minimum margin.
Returns the minimum distance from x to the boundaries of the AABB (bmin,bmax)
void Math::AddElements | ( | VectorTemplate< T > & | A, |
const std::vector< int > & | indices, | ||
T | fill | ||
) |
The inverse of RemoveElements.
Expands A such that the elements indexed by indices are set to fill. A must be able to expand to size A.n + indices.size()
Referenced by Optimization::InequalityMargin().
Real Math::AM2E | ( | RealFunction2 * | f, |
Real | h, | ||
Real | t0, | ||
Real | t1, | ||
Real | w0, | ||
Real | w1 | ||
) |
Adams-Bashforth 2 step explicit method for 1D ODEs.
Returns w2 given previous 2 time steps
Referenced by AM2_predictor_corrector_step().
Real Math::AM2I | ( | RealFunction2 * | f, |
Real | h, | ||
Real | t0, | ||
Real | t1, | ||
Real | t2, | ||
Real | w0, | ||
Real | w1, | ||
Real | w2 | ||
) |
Adams-Moulton 2 step implicit method for 1D ODEs.
Implicit, so it returns w2 (given w2!)
Referenced by AM2_predictor_corrector_step().
void Math::BracketMin | ( | Real & | a, |
Real & | b, | ||
Real & | c, | ||
Real & | fa, | ||
Real & | fb, | ||
Real & | fc, | ||
RealFunction & | func | ||
) |
Returns a bracketing triplet given some a,b.
A bracketing triplet [a,b,c] is such that b is between a and c, and f(b) is less than both f(a) and f(c). The function values are returned as well.
Referenced by ParabolicMinimization().
int Math::CG | ( | const Matrix & | A, |
Vector & | x, | ||
const Vector & | b, | ||
const Preconditioner & | M, | ||
int & | max_iter, | ||
Real & | tol | ||
) |
Solves the symmetric positive definite linear system Ax=b using the Conjugate Gradient method. Uses any type of matrix A with a method A.mul(x,b) (b=Ax) where b,x are vectors, and any preconditioner P with method P.solve(r,x) x = P*r where r,x are vectors.
CG follows the algorithm described on p. 15 in the SIAM Templates book.
The return value indicates convergence within max_iter (input) iterations (0), or no convergence within max_iter iterations (1).
Upon successful return, output arguments have the following values:
x -- approximate solution to Ax = b
max_iter – the number of iterations performed before the tolerance was reached tol – the residual after the final iteration
int Math::cubic | ( | double | a, |
double | b, | ||
double | c, | ||
double | d, | ||
double | x[3] | ||
) |
Computes up to 3 soln's to quadratic equation a^3 x + b^2 x + c x + d = 0. Returns the number of solutions (0 to 3)
References quadratic(), and Sign().
Referenced by ErfComplimentary(), and OpposingSigns_neg().
int Math::CumulativeWeightedSample | ( | const std::vector< Real > & | partialSumWeights | ) |
Same as above, but the array stores cumulative weights (i.e. partial sums) O(log n) algorithm
References Rand().
Real Math::ddfCenteredDifference | ( | RealFunction & | f, |
Real | x, | ||
Real | h | ||
) |
centered differences for 2nd derivative f''(x) ~= 1/h^2*(f(x+h) - 2f(x) + f(x-h)) + O(h^2)
References ddfCenteredDifference().
Referenced by ddfCenteredDifference(), and TestGradients().
Real Math::dfCenteredDifference | ( | RealFunction & | f, |
Real | x, | ||
Real | h | ||
) |
centered differences f'(x) ~= 1/2h*(f(x+h) - f(x-h)) + O(h^2)
References dfCenteredDifference().
Referenced by dfCenteredDifference(), dfCenteredDifferenceAdaptive(), and TestDeriv().
Real Math::dfCenteredDifferenceAdaptive | ( | RealFunction & | f, |
Real | x, | ||
Real | h0, | ||
Real | tol | ||
) |
adaptive centered differences with h determined dynamically starting from h0 such that the (approximate) error is no greater than tol
References dfCenteredDifference(), and dfCenteredDifferenceAdaptive().
Referenced by dfCenteredDifferenceAdaptive(), and GradientCenteredDifferenceAdaptive().
void Math::Euler | ( | DiffEqFunction * | f, |
Real | a, | ||
Real | b, | ||
const Vector & | alpha, | ||
int | n, | ||
Vector & | wn | ||
) |
Solve an ODE system using Euler's method.
Steps forward the ODE system
y' = f(t,y)
y(a) = alpha
using n iterations of Euler's method to reach time b.
Referenced by IntegratedControlSet::Contains(), and IntegratedControlSpace::Simulate().
void Math::Euler_step | ( | DiffEqFunction * | f, |
Real | t0, | ||
Real | h, | ||
const Vector & | w0, | ||
Vector & | w1 | ||
) |
Euler step for an ODE system.
Steps forward the ODE system
y' = f(t,y)
y(t0) = w0
by the time step h, placing the result in w1.
Referenced by IntegratedControlSpace::Simulate().
|
inline |
Copies the indexed columns in A into B.
B has dimensions A.m by indices.size()
|
inline |
Copies the indexed rows in A into B.
B has dimensions indices.size() by A.n.
void Math::GradientCenteredDifferenceAdaptive | ( | ScalarFieldFunction & | f, |
Vector & | x, | ||
Real | h0, | ||
Real | tol, | ||
Vector & | g | ||
) |
adaptive centered differences with h determined dynamically starting from h0 such that the (approximate) error is no greater than tol
References dfCenteredDifferenceAdaptive(), and Inv().
void Math::HouseholderApply | ( | T | tau, |
const VectorTemplate< T > & | v, | ||
VectorTemplate< T > & | w | ||
) |
Applies a householder transformation tau,v to vector w
void Math::HouseholderHM1 | ( | T | tau, |
MatrixTemplate< T > & | A | ||
) |
Applies a householder transformation v,tau to a matrix being built up from the identity matrix, using the first column of A as a householder vector
void Math::HouseholderPostMultiply | ( | T | tau, |
const VectorTemplate< T > & | v, | ||
MatrixTemplate< T > & | A | ||
) |
Applies a householder transformation v,tau to matrix m from the right hand side in order to zero out rows
void Math::HouseholderPreMultiply | ( | T | tau, |
const VectorTemplate< T > & | v, | ||
MatrixTemplate< T > & | A | ||
) |
Applies a householder transformation v,tau to matrix A
T Math::HouseholderTransform | ( | VectorTemplate< T > & | v | ) |
Replace v[0:n-1] with a householder vector (v[0:n-1]) and coefficient tau that annihilate v[1:n-1]. Tau is returned
References pythag().
bool Math::LinearlyDependent_Robust | ( | const VectorTemplate< T > & | a, |
const VectorTemplate< T > & | b, | ||
T & | c, | ||
bool & | cb, | ||
T | eps = Epsilon |
||
) |
Robust determination of linear dependence.
Calculates a constant c s.t. they're linearly dependent within rel error eps and |c| <= 1.
2 cases, (1) a*c = b with maxabs(a*c-b)/|a| <= eps. (2) a = c*b with maxabs(a-c*b)/|b| <= eps. in case 1, cb = false, in case 2, cb=true. c is chosen by pseudoinverse
Referenced by Math3D::Plane3D::allIntersections().
bool Math::LinearlyDependent_Robust | ( | const MatrixTemplate< T > & | A, |
VectorTemplate< T > & | c, | ||
T | eps = Epsilon |
||
) |
A matrix version of the function above.
|
inline |
Returns true of a and be have different signs, treating 0 as a positive number
Referenced by OpposingSigns_neg().
int Math::OrthonormalBasis | ( | const VectorTemplate< T > * | x, |
VectorTemplate< T > * | basis, | ||
int | n | ||
) |
Performs the Gram-Schmidt process to get an orthonormal basis for the span of the input vectors X. Returns the number of nonzero vectors in the output basis
Referenced by Math::RowEchelon< T >::getNullspace().
Real Math::ParabolicLineMinimization | ( | ScalarFieldFunction & | f, |
const Vector & | x, | ||
const Vector & | n, | ||
int | maxIters, | ||
Real | tol | ||
) |
Finds a minimum t* of f(x + t*n), using parabolic minimization Other parameters are the same as ParabolicMinimization.
References ParabolicMinimization().
Referenced by Optimization::BCMinimizationProblem::LineMinimizationStep(), and Optimization::MinimizationProblem::SolveCG().
ConvergenceResult Math::ParabolicMinimization | ( | Real | ax, |
Real | bx, | ||
Real | cx, | ||
RealFunction & | f, | ||
int & | maxIters, | ||
Real | tol, | ||
Real & | xmin | ||
) |
Brent's algorithm for parabolic minimization.
Brackets the minimum to a fractional precision of about tol. [ax,bx,cx] are a bracketing triplet. The abscissa of the minimum is returned as xmin, and the result of convergence is returned (either ConvergenceX or MaxItersReached). The minimum function value is not returned... The number of iterations taken is returned in maxIters.
The second version only takes a starting point, and finds a minimum from there.
References BracketMin().
Referenced by ParabolicLineMinimization(), and ParabolicLineMinimization_i().
int Math::quadratic | ( | double | a, |
double | b, | ||
double | c, | ||
double & | x1, | ||
double & | x2 | ||
) |
Computes up to 2 soln's to quadratic equation a^2 x + b x + c = 0. Returns the number of solutions (0, 1, or 2)
Referenced by Math3D::Plane2D::allIntersections(), Math3D::Sphere3D::closestPoint(), cubic(), ErfComplimentary(), Math3D::Cylinder3D::intersects(), and OpposingSigns_neg().
void Math::RandomAllocate | ( | vector< int > & | num, |
size_t | total | ||
) |
Allocates total samples within the buckets in num, roughly evenly. An O(n) algorithm where n is the number of buckets.
Specifically, this allocates at least floor(total/n) samples to each bucket, then distributes the remaining total-n*floor(total/n) such that no bucket receives more than 1 extra sample.
Allocates total samples within the buckets in num, roughly evenly. An O(n) algorithm where n is the number of buckets.
References Rand().
Referenced by Statistics::LinearProcessHMM::Posterior(), and Statistics::GaussianMixtureModel::TrainEM().
void Math::RandomAllocate | ( | vector< int > & | num, |
size_t | total, | ||
const vector< Real > & | weights | ||
) |
Real Math::RKF | ( | RealFunction2 * | f, |
Real | a, | ||
Real | b, | ||
Real | alpha, | ||
Real | tol, | ||
Real | hmax, | ||
Real | hmin | ||
) |
Runge-Kutta-Fehlberg method for 1D ODEs.
For the IVP
y' = f(t,y)
y(a) = alpha
does the Runge-Kutta-Fehlberg method with tolerance tol, max step size hmax, min step size hmin to reach time b.
ConvergenceResult Math::Root_Bisection | ( | RealFunction & | f, |
Real & | a, | ||
Real & | b, | ||
Real & | x, | ||
Real | tol | ||
) |
Uses bisection to bracket f's root.
[a,b] must be a range such that f(a) and f(b) have opposing signs. [a,b] is returned as a refined bracket. Linear convergence. The number of iterations used is ceil(log2(b-a)-log2(eps)).
References Sign().
ConvergenceResult Math::Root_Newton | ( | RealFunction & | f, |
Real & | x, | ||
int & | maxIters, | ||
Real | tolx, | ||
Real | tolf | ||
) |
Performs Newton's method, which uses the derivative of f to search for it's root.
f.Deriv() must be defined. Quadratic convergence. The # of iterations is returned in maxIters.
Referenced by Math::InequalityConstraint::Push().
ConvergenceResult Math::Root_Secant | ( | RealFunction & | f, |
Real | x0, | ||
Real & | x1, | ||
int & | maxIters, | ||
Real | tolx, | ||
Real | tolf | ||
) |
Uses the secant method to search for f's root.
Order of convergence ~1.6. The # of iterations is returned in maxIters.
ConvergenceResult Math::Root_SecantBracket | ( | RealFunction & | f, |
Real & | a, | ||
Real & | b, | ||
Real & | x, | ||
int & | maxIters, | ||
Real | tolx, | ||
Real | tolf | ||
) |
Same as above, but the interval [a,b] must be known to contain a root. [a,b] is returned as a refined bracket.
References Sign().
Referenced by Math::InequalityConstraint::LineSearch().
Real Math::RungeKutta4 | ( | RealFunction2 * | f, |
Real | a, | ||
Real | b, | ||
Real | alpha, | ||
int | n | ||
) |
Runge-Kutta 4 method for 1D ODEs.
Solves the initial value problem
y' = f(t,y)
y(a) = alpha
using n iterations of Runge-kutta order 4 to reach time b.
References RungeKutta4_step().
void Math::RungeKutta4 | ( | DiffEqFunction * | f, |
Real | a, | ||
Real | b, | ||
const Vector & | alpha, | ||
int | n, | ||
Vector & | wn | ||
) |
Solve an ODE system using the Runge Kutta 4 method.
Steps forward the ODE system
y' = f(t,y)
y(a) = alpha
using n iterations of Runge Kutta 4 to reach time b.
References RungeKutta4_step().
Real Math::RungeKutta4_step | ( | RealFunction2 * | f, |
Real | t0, | ||
Real | h, | ||
Real | w | ||
) |
Runge-Kutta 4 step for 1D ODEs.
Steps forward the initial value problem
y' = f(t,y)
y(t0) = w
by the time step h.
Referenced by IntegratedControlSpace::Simulate().
void Math::RungeKutta4_step | ( | DiffEqFunction * | f, |
Real | t0, | ||
Real | h, | ||
const Vector & | w0, | ||
Vector & | w1 | ||
) |
Runge-Kutta 4 step for an ODE system.
Steps forward the ODE system
y' = f(t,y)
y(t0) = w0
by the time step h, placing the result in w1.
Referenced by RungeKutta4().
|
inline |
Sets the indexed columns of A to the columns of the matrix fill.
The fill matrix is A.m by indices.size(). For copying from a matrix to another using the same set of indices, use CopyColumns().
|
inline |
Sets A[indices] = fill.
The fill vector is of size indices.size(). For copying from a vector to another using the same set of indices, use CopyElements().
|
inline |
Sets A[r,c] = fill for all r in rows and all c in columns.
The fill matrix is of size rows.size() x cols.size(). For copying from a matrix to another using the same set of indices, use CopyElements().
|
inline |
Sets the indexed rows of A to the columns of the matrix fill.
The fill matrix is indices.size() by A.n. For copying from a matrix to another using the same set of indices, use CopyRows().
bool Math::SolveCosSinEquation | ( | Real | a, |
Real | b, | ||
Real | c, | ||
Real & | t1, | ||
Real & | t2 | ||
) |
Solves a cos(x) + b sin(x) = c returns at most 2 different values of x, or false if there is no solution.
References FuzzyEquals(), and TransformCosSin_Sin().
Referenced by Atan_All().
void Math::TransformCosSin_Cos | ( | Real | a, |
Real | b, | ||
Real & | c, | ||
Real & | d | ||
) |
A "cos/sin" equation is a f(x) = cos(x) + b sin(x) which can be expressed as f(x) = c*cos(x+d)
References FuzzyEquals(), and pythag().
Referenced by Atan_All(), and SolveCosSinGreater().
int Math::WeightedSample | ( | const std::vector< Real > & | weights | ) |
Samples an integer with weighted probability.
The probability of sampling integer i in [0,n) is wi / W where W = sum of all wi.
References WeightedSample().
Referenced by KinodynamicTree::DeleteSubTree(), RestartShortcutMotionPlanner::Plan(), RestartShortcutMotionPlanner::PlanMore(), and Statistics::GaussianMixtureModel::TrainEM().