/usr/include/opencascade/math_Recipes.hxx is in libopencascade-foundation-dev 6.5.0.dfsg-2build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 | #ifndef math_Recipes_HeaderFile
#define math_Recipes_HeaderFile
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#ifndef __math_API
# if defined(WNT) && !defined(HAVE_NO_DLL)
# ifdef __math_DLL
# define __math_API __declspec( dllexport )
# else
# define __math_API __declspec( dllimport )
# endif /* __math_DLL */
# else
# define __math_API
# endif /* WNT */
#endif /* __math_API */
class math_IntegerVector;
class math_Vector;
class math_Matrix;
const Standard_Integer math_Status_OK = 0;
const Standard_Integer math_Status_SingularMatrix = 1;
const Standard_Integer math_Status_ArgumentError = 2;
const Standard_Integer math_Status_NoConvergence = 3;
__math_API Standard_Integer LU_Decompose(math_Matrix& a,
math_IntegerVector& indx,
Standard_Real& d,
Standard_Real TINY = 1.0e-20);
// Given a matrix a(1..n, 1..n), this routine computes its LU decomposition,
// The matrix a is replaced by this LU decomposition and the vector indx(1..n)
// is an output which records the row permutation effected by the partial
// pivoting; d is output as +1 or -1 depending on wether the number of row
// interchanges was even or odd.
__math_API Standard_Integer LU_Decompose(math_Matrix& a,
math_IntegerVector& indx,
Standard_Real& d,
math_Vector& vv,
Standard_Real TINY = 1.0e-30);
// Idem to the previous LU_Decompose function. But the input Vector vv(1..n) is
// used internally as a scratch area.
__math_API void LU_Solve(const math_Matrix& a,
const math_IntegerVector& indx,
math_Vector& b);
// Solves a * x = b for a vector x, where x is specified by a(1..n, 1..n),
// indx(1..n) as returned by LU_Decompose. n is the dimension of the
// square matrix A. b(1..n) is the input right-hand side and will be
// replaced by the solution vector.Neither a and indx are destroyed, so
// the routine may be called sequentially with different b's.
__math_API Standard_Integer LU_Invert(math_Matrix& a);
// Given a matrix a(1..n, 1..n) this routine computes its inverse. The matrix
// a is replaced by its inverse.
__math_API Standard_Integer SVD_Decompose(math_Matrix& a,
math_Vector& w,
math_Matrix& v);
// Given a matrix a(1..m, 1..n), this routine computes its singular value
// decomposition, a = u * w * transposed(v). The matrix u replaces a on
// output. The diagonal matrix of singular values w is output as a vector
// w(1..n). The matrix v is output as v(1..n, 1..n). m must be greater or
// equal to n; if it is smaller, then a should be filled up to square with
// zero rows.
__math_API Standard_Integer SVD_Decompose(math_Matrix& a,
math_Vector& w,
math_Matrix& v,
math_Vector& rv1);
// Idem to the previous LU_Decompose function. But the input Vector vv(1..m)
// (the number of rows a(1..m, 1..n)) is used internally as a scratch area.
__math_API void SVD_Solve(const math_Matrix& u,
const math_Vector& w,
const math_Matrix& v,
const math_Vector& b,
math_Vector& x);
// Solves a * x = b for a vector x, where x is specified by u(1..m, 1..n),
// w(1..n), v(1..n, 1..n) as returned by SVD_Decompose. m and n are the
// dimensions of A, and will be equal for square matrices. b(1..m) is the
// input right-hand side. x(1..n) is the output solution vector.
// No input quantities are destroyed, so the routine may be called
// sequentially with different b's.
__math_API Standard_Integer DACTCL_Decompose(math_Vector& a, const math_IntegerVector& indx,
const Standard_Real MinPivot = 1.e-20);
// Given a SYMMETRIC matrix a, this routine computes its
// LU decomposition.
// a is given through a vector of its non zero components of the upper
// triangular matrix.
// indx is the indice vector of the diagonal elements of a.
// a is replaced by its LU decomposition.
// The range of the matrix is n = indx.Length(),
// and a.Length() = indx(n).
__math_API Standard_Integer DACTCL_Solve(const math_Vector& a, math_Vector& b,
const math_IntegerVector& indx,
const Standard_Real MinPivot = 1.e-20);
// Solves a * x = b for a vector x and a matrix a coming from DACTCL_Decompose.
// indx is the same vector as in DACTCL_Decompose.
// the vector b is replaced by the vector solution x.
__math_API Standard_Integer Jacobi(math_Matrix& a, math_Vector& d, math_Matrix& v, Standard_Integer& nrot);
// Computes all eigenvalues and eigenvectors of a real symmetric matrix
// a(1..n, 1..n). On output, elements of a above the diagonal are destroyed.
// d(1..n) returns the eigenvalues of a. v(1..n, 1..n) is a matrix whose
// columns contain, on output, the normalized eigenvectors of a. nrot returns
// the number of Jacobi rotations that were required.
// Eigenvalues are sorted into descending order, and eigenvectors are
// arranges correspondingly.
__math_API Standard_Real Random2(Standard_Integer& idum);
// returns a uniform random deviate betwween 0.0 and 1.0. Set idum to any
// negative value to initialize or reinitialize the sequence.
#endif
|