kids-doc/linalg_8h_source.html

#ifndef KIDS_LINALG_H

#define KIDS_LINALG_H


#include "kids/Types.h"


#define KIDS_LINALG_BIND_EIGEN_NOT_USE_TEMPLATE


#ifndef KIDS_LINALG_BIND_EIGEN_NOT_USE_TEMPLATE

#include "kids/linalg_tpl.h"

#else  // KIDS_LINALG_BIND_EIGEN_NOT_USE_TEMPLATE


namespace PROJECT_NS {


bool ARRAY_ISFINITE(kids_real* A, size_t n);


bool ARRAY_ISFINITE(kids_complex* A, size_t n);


void ARRAY_CLEAR(kids_int* A, size_t N);


void ARRAY_CLEAR(kids_real* A, size_t N);


void ARRAY_CLEAR(kids_complex* A, size_t N);


void ARRAY_MATMUL(kids_real* A, kids_real* B, kids_real* C, size_t N1, size_t N2, size_t N3);


void ARRAY_MATMUL(kids_complex* A, kids_complex* B, kids_complex* C, size_t N1, size_t N2, size_t N3);


void ARRAY_MATMUL(kids_complex* A, kids_real* B, kids_complex* C, size_t N1, size_t N2, size_t N3);


void ARRAY_MATMUL(kids_complex* A, kids_complex* B, kids_real* C, size_t N1, size_t N2, size_t N3);


void ARRAY_MATMUL_TRANS1(kids_real* A, kids_real* B, kids_real* C, size_t N1, size_t N2, size_t N3);


void ARRAY_MATMUL_TRANS1(kids_complex* A, kids_complex* B, kids_complex* C, size_t N1, size_t N2, size_t N3);


void ARRAY_MATMUL_TRANS1(kids_complex* A, kids_real* B, kids_complex* C, size_t N1, size_t N2, size_t N3);


void ARRAY_MATMUL_TRANS1(kids_complex* A, kids_complex* B, kids_real* C, size_t N1, size_t N2, size_t N3);


void ARRAY_MATMUL_TRANS2(kids_real* A, kids_real* B, kids_real* C, size_t N1, size_t N2, size_t N3);


void ARRAY_MATMUL_TRANS2(kids_complex* A, kids_complex* B, kids_complex* C, size_t N1, size_t N2, size_t N3);


void ARRAY_MATMUL_TRANS2(kids_complex* A, kids_real* B, kids_complex* C, size_t N1, size_t N2, size_t N3);


void ARRAY_MATMUL_TRANS2(kids_complex* A, kids_complex* B, kids_real* C, size_t N1, size_t N2, size_t N3);


void ARRAY_OUTER_TRANS2(kids_real* A, kids_real* B, kids_real* C, size_t N1, size_t N2);


void ARRAY_OUTER_TRANS2(kids_complex* A, kids_complex* B, kids_complex* C, size_t N1, size_t N2);


void ARRAY_MATMUL3_TRANS1(kids_real* A, kids_real* B, kids_real* C, kids_real* D,  //

                          size_t N1, size_t N2, size_t N0, size_t N3);


void ARRAY_MATMUL3_TRANS1(kids_complex* A, kids_complex* B, kids_complex* C, kids_complex* D,  //

                          size_t N1, size_t N2, size_t N0, size_t N3);


void ARRAY_MATMUL3_TRANS1(kids_complex* A, kids_real* B, kids_complex* C, kids_real* D,  //

                          size_t N1, size_t N2, size_t N0, size_t N3);


void ARRAY_MATMUL3_TRANS1(kids_complex* A, kids_complex* B, kids_real* C, kids_complex* D,  //

                          size_t N1, size_t N2, size_t N0, size_t N3);


void ARRAY_MATMUL3_TRANS2(kids_real* A, kids_real* B, kids_real* C, kids_real* D,  //

                          size_t N1, size_t N2, size_t N0, size_t N3);


void ARRAY_MATMUL3_TRANS2(kids_complex* A, kids_complex* B, kids_complex* C, kids_complex* D,  //

                          size_t N1, size_t N2, size_t N0, size_t N3);


void ARRAY_MATMUL3_TRANS2(kids_complex* A, kids_real* B, kids_complex* C, kids_real* D,  //

                          size_t N1, size_t N2, size_t N0, size_t N3);


void ARRAY_MATMUL3_TRANS2(kids_complex* A, kids_complex* B, kids_real* C, kids_complex* D,  //

                          size_t N1, size_t N2, size_t N0, size_t N3);


kids_real ARRAY_TRACE2(kids_real* B, kids_real* C, size_t N1, size_t N2);


kids_complex ARRAY_TRACE2(kids_complex* B, kids_complex* C, size_t N1, size_t N2);


kids_complex ARRAY_TRACE2(kids_complex* B, kids_real* C, size_t N1, size_t N2);


kids_complex ARRAY_TRACE2(kids_real* B, kids_complex* C, size_t N1, size_t N2);


kids_real ARRAY_TRACE2_DIAG(kids_real* B, kids_real* C, size_t N1, size_t N2);


kids_complex ARRAY_TRACE2_DIAG(kids_complex* B, kids_complex* C, size_t N1, size_t N2);


kids_complex ARRAY_TRACE2_DIAG(kids_complex* B, kids_real* C, size_t N1, size_t N2);


kids_complex ARRAY_TRACE2_DIAG(kids_real* B, kids_complex* C, size_t N1, size_t N2);


kids_real ARRAY_TRACE2_OFFD(kids_real* B, kids_real* C, size_t N1, size_t N2);


kids_complex ARRAY_TRACE2_OFFD(kids_complex* B, kids_complex* C, size_t N1, size_t N2);


kids_complex ARRAY_TRACE2_OFFD(kids_complex* B, kids_real* C, size_t N1, size_t N2);


kids_complex ARRAY_TRACE2_OFFD(kids_real* B, kids_complex* C, size_t N1, size_t N2);


kids_real ARRAY_INNER_TRANS1(kids_real* B, kids_real* C, size_t N1);


kids_complex ARRAY_INNER_TRANS1(kids_complex* B, kids_complex* C, size_t N1);


kids_complex ARRAY_INNER_TRANS1(kids_complex* B, kids_real* C, size_t N1);


kids_complex ARRAY_INNER_TRANS1(kids_real* B, kids_complex* C, size_t N1);


kids_real ARRAY_INNER_VMV_TRANS1(kids_real* B, kids_real* C, kids_real* D, size_t N1, size_t N2);


kids_complex ARRAY_INNER_VMV_TRANS1(kids_complex* B, kids_complex* C, kids_complex* D, size_t N1, size_t N2);


kids_complex ARRAY_INNER_VMV_TRANS1(kids_complex* B, kids_real* C, kids_complex* D, size_t N1, size_t N2);


kids_complex ARRAY_INNER_VMV_TRANS1(kids_real* B, kids_complex* C, kids_real* D, size_t N1, size_t N2);


void ARRAY_EYE(kids_real* A, size_t n);


void ARRAY_EYE(kids_complex* A, size_t n);


void ARRAY_MAT_DIAG(kids_real* A, kids_real* B, size_t N1);


void ARRAY_MAT_DIAG(kids_complex* A, kids_complex* B, size_t N1);


void ARRAY_MAT_DIAG(kids_complex* A, kids_real* B, size_t N1);


void ARRAY_MAT_OFFD(kids_real* A, kids_real* B, size_t N1);


void ARRAY_MAT_OFFD(kids_complex* A, kids_complex* B, size_t N1);


void ARRAY_MAT_OFFD(kids_complex* A, kids_real* B, size_t N1);


void LinearSolve(kids_real* x, kids_real* A, kids_real* b, size_t N);


void EigenSolve(kids_real* E, kids_real* T, kids_real* A, size_t N);


void EigenSolve(kids_real* E, kids_complex* T, kids_complex* A, size_t N);


void EigenSolve(kids_complex* E, kids_complex* T, kids_complex* A, size_t N);


void PseudoInverse(kids_real* A, kids_real* invA, size_t N, kids_real e = 1E-5);


void MatrixInverse(kids_real* invA, kids_real* A, size_t N);


void ARRAY_INV_MAT(kids_complex* invA, kids_complex* A, size_t N);


void ARRAY_EXP_MAT_GENERAL(kids_complex* expkA, kids_complex* A, kids_complex k, size_t N);


void ARRAY_CORRECT_U(kids_complex* U, size_t N);


void ARRAY_TRANSPOSE(kids_real* A, size_t N1, size_t N2);


void ARRAY_TRANSPOSE(kids_complex* A, size_t N1, size_t N2);


};  // namespace PROJECT_NS


#endif  // KIDS_LINALG_BIND_EIGEN_NOT_USE_TEMPLATE


#endif  // KIDS_LINALG_H

Types.h
definition of types in the project and some utiles for types

ARRAY_MATMUL_TRANS2
#define ARRAY_MATMUL_TRANS2(_A, _B, _C, _n1, _n2, _n3)
Definition array_macro.h:179

ARRAY_MATMUL3_TRANS1
#define ARRAY_MATMUL3_TRANS1(_A, _B, _C, _D, _n1, _n2, _n0, _n3)
Definition array_macro.h:199

ARRAY_MATMUL3_TRANS2
#define ARRAY_MATMUL3_TRANS2(_A, _B, _C, _D, _n1, _n2, _n0, _n3)
Definition array_macro.h:219

ARRAY_MATMUL
#define ARRAY_MATMUL(_A, _B, _C, _n1, _n2, _n3)
Definition array_macro.h:146

ARRAY_EYE
#define ARRAY_EYE(_A, _n)
Definition array_macro.h:75

ARRAY_MATMUL_TRANS1
#define ARRAY_MATMUL_TRANS1(_A, _B, _C, _n1, _n2, _n3)
Definition array_macro.h:162

ARRAY_TRACE2
#define ARRAY_TRACE2(_B, _C, _n1, _n2)
Definition array_macro.h:121

ARRAY_CLEAR
#define ARRAY_CLEAR(_A, _n)
Definition array_macro.h:36

linalg_tpl.h
Provide linalg APIs by templating.

PROJECT_NS
< http://warp.povusers.org/FunctionParser/fparser.html
Definition Context.h:39

PROJECT_NS::ARRAY_ISFINITE
bool ARRAY_ISFINITE(kids_real *A, size_t n)
Check if all elements of a real array are finite.
Definition linalg.cpp:38

PROJECT_NS::PseudoInverse
void PseudoInverse(kids_real *A, kids_real *invA, size_t N, kids_real e=1E-5)
Compute the pseudo-inverse of a matrix for real numbers.
Definition linalg_1.cpp:71

PROJECT_NS::ARRAY_CORRECT_U
void ARRAY_CORRECT_U(kids_complex *U, size_t N)
Definition linalg_1.cpp:132

PROJECT_NS::ARRAY_MAT_DIAG
void ARRAY_MAT_DIAG(kids_real *A, kids_real *B, size_t N1)
Copy the diagonal elements from matrix B to matrix A for real matrices.
Definition linalg.cpp:458

PROJECT_NS::ARRAY_INNER_TRANS1
kids_real ARRAY_INNER_TRANS1(kids_real *B, kids_real *C, size_t N1)
Compute the inner product of the transpose of B with C for real matrices.
Definition linalg.cpp:400

PROJECT_NS::ARRAY_INV_MAT
void ARRAY_INV_MAT(kids_complex *invA, kids_complex *A, size_t N)
Compute the inverse of a matrix for complex numbers.
Definition linalg_1.cpp:91

PROJECT_NS::ARRAY_TRANSPOSE
void ARRAY_TRANSPOSE(kids_real *A, size_t N1, size_t N2)
Definition linalg.cpp:500

PROJECT_NS::ARRAY_MAT_OFFD
void ARRAY_MAT_OFFD(kids_real *A, kids_real *B, size_t N1)
Copy the off-diagonal elements from matrix B to matrix A for real matrices.
Definition linalg.cpp:479

PROJECT_NS::kids_real
double kids_real
Alias for real number type.
Definition Types.h:59

PROJECT_NS::kids_complex
std::complex< double > kids_complex
Alias for complex number type.
Definition Types.h:60

PROJECT_NS::ARRAY_OUTER_TRANS2
void ARRAY_OUTER_TRANS2(kids_real *A, kids_real *B, kids_real *C, size_t N1, size_t N2)
Perform outer product with transpose where A = B^T * C for real matrices.
Definition linalg.cpp:160

PROJECT_NS::ARRAY_INNER_VMV_TRANS1
kids_real ARRAY_INNER_VMV_TRANS1(kids_real *B, kids_real *C, kids_real *D, size_t N1, size_t N2)
Compute the inner product of the transpose of the real vector B with the matrix C,...
Definition linalg.cpp:424

PROJECT_NS::EigenSolve
void EigenSolve(kids_real *E, kids_real *T, kids_real *A, size_t N)
Solve the eigenvalue problem for real matrices.
Definition linalg_1.cpp:44

PROJECT_NS::ARRAY_TRACE2_DIAG
kids_real ARRAY_TRACE2_DIAG(kids_real *B, kids_real *C, size_t N1, size_t N2)
Compute the trace of the diagonal elements of the matrix product B * C for real matrices.
Definition linalg.cpp:340

PROJECT_NS::ARRAY_EXP_MAT_GENERAL
void ARRAY_EXP_MAT_GENERAL(kids_complex *expkA, kids_complex *A, kids_complex k, size_t N)
Definition linalg_1.cpp:97

PROJECT_NS::MatrixInverse
void MatrixInverse(kids_real *invA, kids_real *A, size_t N)
Compute the inverse of a matrix for real numbers.

PROJECT_NS::LinearSolve
void LinearSolve(kids_real *x, kids_real *A, kids_real *b, size_t N)
Solve a linear system Ax = b for real matrices.
Definition linalg_1.cpp:37

PROJECT_NS::ARRAY_TRACE2_OFFD
kids_real ARRAY_TRACE2_OFFD(kids_real *B, kids_real *C, size_t N1, size_t N2)
Compute the trace of the off-diagonal elements of the matrix product B * C for real matrices.
Definition linalg.cpp:368

PROJECT_NS::kids_int
int kids_int
Alias for integer type.
Definition Types.h:57