go_quad_matrix_back_solve ()

gboolean
go_quad_matrix_back_solve (const GOQuadMatrix *R,
                           GOQuad *x,
                           const GOQuad *b,
                           gboolean allow_degenerate);

go_quad_matrix_back_solvel ()

gboolean
go_quad_matrix_back_solvel (const GOQuadMatrixl *R,
                            GOQuadl *x,
                            const GOQuadl *b,
                            gboolean allow_degenerate);

go_quad_matrix_back_solveD ()

gboolean
go_quad_matrix_back_solveD (const GOQuadMatrixD *R,
                            GOQuadD *x,
                            const GOQuadD *b,
                            gboolean allow_degenerate);

go_quad_matrix_copy ()

void
go_quad_matrix_copy (GOQuadMatrix *A,
                     const GOQuadMatrix *B);

Copies B to A.

go_quad_matrix_copyl ()

void
go_quad_matrix_copyl (GOQuadMatrixl *A,
                      const GOQuadMatrixl *B);

Copies B to A.

go_quad_matrix_copyD ()

void
go_quad_matrix_copyD (GOQuadMatrixD *A,
                      const GOQuadMatrixD *B);

Copies B to A.

go_quad_matrix_determinant ()

void
go_quad_matrix_determinant (const GOQuadMatrix *A,
                            GOQuad *res);

Computes the determinant of A and stores it in res .

go_quad_matrix_determinantl ()

void
go_quad_matrix_determinantl (const GOQuadMatrixl *A,
                             GOQuadl *res);

Computes the determinant of A and stores it in res .

go_quad_matrix_determinantD ()

void
go_quad_matrix_determinantD (const GOQuadMatrixD *A,
                             GOQuadD *res);

Computes the determinant of A and stores it in res .

go_quad_matrix_dump ()

void
go_quad_matrix_dump (const GOQuadMatrix *A,
                     const char *fmt);

Dumps A to stderr using fmt .

[skip]

go_quad_matrix_dumpl ()

void
go_quad_matrix_dumpl (const GOQuadMatrixl *A,
                      const char *fmt);

Dumps A to stderr using fmt .

[skip]

go_quad_matrix_dumpD ()

void
go_quad_matrix_dumpD (const GOQuadMatrixD *A,
                      const char *fmt);

Dumps A to stderr using fmt .

[skip]

go_quad_matrix_dup ()

GOQuadMatrix *
go_quad_matrix_dup (const GOQuadMatrix *A);

[skip]

go_quad_matrix_dupl ()

GOQuadMatrixl *
go_quad_matrix_dupl (const GOQuadMatrixl *A);

[skip]

go_quad_matrix_dupD ()

GOQuadMatrixD *
go_quad_matrix_dupD (const GOQuadMatrixD *A);

[skip]

go_quad_matrix_eigen_range ()

void
go_quad_matrix_eigen_range (const GOQuadMatrix *A,
                            double *emin,
                            double *emax);

go_quad_matrix_eigen_rangel ()

void
go_quad_matrix_eigen_rangel (const GOQuadMatrixl *A,
                             long double *emin,
                             long double *emax);

go_quad_matrix_eigen_rangeD ()

void
go_quad_matrix_eigen_rangeD (const GOQuadMatrixD *A,
                             _Decimal64 *emin,
                             _Decimal64 *emax);

go_quad_matrix_free ()

void
go_quad_matrix_free (GOQuadMatrix *A);

Frees A and its associated data.

[skip]

go_quad_matrix_freel ()

void
go_quad_matrix_freel (GOQuadMatrixl *A);

Frees A and its associated data.

[skip]

go_quad_matrix_freeD ()

void
go_quad_matrix_freeD (GOQuadMatrixD *A);

Frees A and its associated data.

[skip]

go_quad_matrix_fwd_solve ()

gboolean
go_quad_matrix_fwd_solve (const GOQuadMatrix *R,
                          GOQuad *x,
                          const GOQuad *b,
                          gboolean allow_degenerate);

go_quad_matrix_fwd_solvel ()

gboolean
go_quad_matrix_fwd_solvel (const GOQuadMatrixl *R,
                           GOQuadl *x,
                           const GOQuadl *b,
                           gboolean allow_degenerate);

go_quad_matrix_fwd_solveD ()

gboolean
go_quad_matrix_fwd_solveD (const GOQuadMatrixD *R,
                           GOQuadD *x,
                           const GOQuadD *b,
                           gboolean allow_degenerate);

go_quad_matrix_inverse ()

GOQuadMatrix *
go_quad_matrix_inverse (const GOQuadMatrix *A,
                        double threshold);

[skip]

go_quad_matrix_inversel ()

GOQuadMatrixl *
go_quad_matrix_inversel (const GOQuadMatrixl *A,
                         long double threshold);

[skip]

go_quad_matrix_inverseD ()

GOQuadMatrixD *
go_quad_matrix_inverseD (const GOQuadMatrixD *A,
                         _Decimal64 threshold);

[skip]

go_quad_matrix_multiply ()

void
go_quad_matrix_multiply (GOQuadMatrix *C,
                         const GOQuadMatrix *A,
                         const GOQuadMatrix *B);

Multiplies A*B and stores the result in C.

go_quad_matrix_multiplyl ()

void
go_quad_matrix_multiplyl (GOQuadMatrixl *C,
                          const GOQuadMatrixl *A,
                          const GOQuadMatrixl *B);

Multiplies A*B and stores the result in C.

go_quad_matrix_multiplyD ()

void
go_quad_matrix_multiplyD (GOQuadMatrixD *C,
                          const GOQuadMatrixD *A,
                          const GOQuadMatrixD *B);

Multiplies A*B and stores the result in C.

go_quad_matrix_new ()

GOQuadMatrix *
go_quad_matrix_new (int m,
                    int n);

[skip]

go_quad_matrix_newl ()

GOQuadMatrixl *
go_quad_matrix_newl (int m,
                     int n);

[skip]

go_quad_matrix_newD ()

GOQuadMatrixD *
go_quad_matrix_newD (int m,
                     int n);

[skip]

go_quad_matrix_pseudo_inverse ()

GOQuadMatrix *
go_quad_matrix_pseudo_inverse (const GOQuadMatrix *A,
                               double threshold);

[skip]

go_quad_matrix_pseudo_inversel ()

GOQuadMatrixl *
go_quad_matrix_pseudo_inversel (const GOQuadMatrixl *A,
                                long double threshold);

[skip]

go_quad_matrix_pseudo_inverseD ()

GOQuadMatrixD *
go_quad_matrix_pseudo_inverseD (const GOQuadMatrixD *A,
                                _Decimal64 threshold);

[skip]

go_quad_matrix_transpose ()

void
go_quad_matrix_transpose (GOQuadMatrix *A,
                          const GOQuadMatrix *B);

Transposes B into A.

go_quad_matrix_transposel ()

void
go_quad_matrix_transposel (GOQuadMatrixl *A,
                           const GOQuadMatrixl *B);

Transposes B into A.

go_quad_matrix_transposeD ()

void
go_quad_matrix_transposeD (GOQuadMatrixD *A,
                           const GOQuadMatrixD *B);

Transposes B into A.