gretl_matrix_get()

#define gretl_matrix_get(m,i,j) (m->val[(j)*m->rows+(i)])

gretl_vector_get()

#define gretl_vector_get(v,i) (v->val[i])

gretl_matrix_set()

#define gretl_matrix_set(m,i,j,x) ((m)->val[(j)*(m)->rows+(i)]=x)

Sets the i , j element of m to x .

gretl_vector_set()

#define gretl_vector_set(v,i,x) ((v)->val[i]=x)

Sets element i of v to x .

gretl_matrix_cols()

#define gretl_matrix_cols(m) ((m == NULL)? 0 : m->cols)

gretl_matrix_rows()

#define gretl_matrix_rows(m) ((m == NULL)? 0 : m->rows)

gretl_vector_get_length()

#define             gretl_vector_get_length(v)

gretl_vector_alloc()

#define gretl_vector_alloc(i) gretl_matrix_alloc(1,(i))

gretl_column_vector_alloc()

#define gretl_column_vector_alloc(i) gretl_matrix_alloc((i),1)

gretl_vector_free()

#define gretl_vector_free(v) gretl_matrix_free(v)

Frees the vector v and its associated storage.

gretl_matrix_is_scalar()

#define             gretl_matrix_is_scalar(m)

gretl_is_null_matrix()

#define gretl_is_null_matrix(m) (m == NULL || m->rows == 0 || m->cols == 0)

get_gretl_matrix_err ()

int
get_gretl_matrix_err (void);

clear_gretl_matrix_err ()

void
clear_gretl_matrix_err (void);

gretl_matrix_print ()

void
gretl_matrix_print (const gretl_matrix *m,
                    const char *msg);

Prints the given matrix to stderr.

gretl_matrix_xna_check ()

int
gretl_matrix_xna_check (const gretl_matrix *m);

gretl_matrix_is_symmetric ()

int
gretl_matrix_is_symmetric (const gretl_matrix *m);

gretl_matrix_is_idempotent ()

int
gretl_matrix_is_idempotent (const gretl_matrix *m);

gretl_matrix_xtr_symmetric ()

void
gretl_matrix_xtr_symmetric (gretl_matrix *m);

Computes the symmetric part of m by averaging its off-diagonal elements.

gretl_matrix_set_equals_tolerance ()

void
gretl_matrix_set_equals_tolerance (double tol);

Sets the tolerance for judging whether or not a matrix is symmetric (see gretl_matrix_is_symmetric() and also gretl_invert_symmetric_matrix()). The tolerance is the maximum relative difference between corresponding off-diagonal elements that is acceptable in a supposedly "symmetric" matrix. The default value is 1.0e-9.

gretl_matrix_unset_equals_tolerance ()

void
gretl_matrix_unset_equals_tolerance (void);

Sets the tolerance for judging whether or not a matrix is symmetric to its default value. See also gretl_matrix_set_equals_tolerance().

gretl_matrix_alloc ()

gretl_matrix *
gretl_matrix_alloc (int rows,
                    int cols);

gretl_matrix_reuse ()

gretl_matrix *
gretl_matrix_reuse (gretl_matrix *m,
                    int rows,
                    int cols);

An "experts only" memory-conservation trick. If m is an already-allocated gretl matrix, you can "resize" it by specifying a new number of rows and columns. This works only if the product of rows and cols is less than or equal to the product of the number of rows and columns in the matrix as originally allocated; no actual reallocation of memory is performed. If you "reuse" with an excessive number of rows or columns you will surely crash your program or smash the stack. Note also that the matrix-pointer returned is not really new, and when the matrix is to be freed, gretl_matrix_free() should be applied only once.

gretl_matrix_realloc ()

int
gretl_matrix_realloc (gretl_matrix *m,
                      int rows,
                      int cols);

Reallocates the storage in m to the specified dimensions.

gretl_matrix_init ()

void
gretl_matrix_init (gretl_matrix *m);

Initializes m to be zero by zero with NULL data.

gretl_matrix_replace ()

gretl_matrix *
gretl_matrix_replace (gretl_matrix **pa,
                      gretl_matrix *b);

Frees the matrix at location pa and substitutes b .

gretl_matrix_replace_content ()

int
gretl_matrix_replace_content (gretl_matrix *targ,
                              gretl_matrix *donor);

Moves the content of donor into targ ; donor becomes a null matrix in consequence.

gretl_matrix_block_destroy ()

void
gretl_matrix_block_destroy (gretl_matrix_block *B);

gretl_matrix_block_zero ()

void
gretl_matrix_block_zero (gretl_matrix_block *B);

gretl_matrix_block_new ()

gretl_matrix_block *
gretl_matrix_block_new (gretl_matrix **pm,
                        ...);

gretl_matrix_block_n_matrices ()

int
gretl_matrix_block_n_matrices (gretl_matrix_block *B);

gretl_matrix_block_get_matrix ()

gretl_matrix *
gretl_matrix_block_get_matrix (gretl_matrix_block *B,
                               int i);

gretl_identity_matrix_new ()

gretl_matrix *
gretl_identity_matrix_new (int n);

gretl_DW_matrix_new ()

gretl_matrix *
gretl_DW_matrix_new (int n);

gretl_zero_matrix_new ()

gretl_matrix *
gretl_zero_matrix_new (int r,
                       int c);

gretl_unit_matrix_new ()

gretl_matrix *
gretl_unit_matrix_new (int r,
                       int c);

gretl_null_matrix_new ()

gretl_matrix *
gretl_null_matrix_new (void);

gretl_matrix_seq ()

gretl_matrix *
gretl_matrix_seq (double start,
                  double end,
                  double step,
                  int *err);

gretl_matrix_copy ()

gretl_matrix *
gretl_matrix_copy (const gretl_matrix *m);

gretl_matrix_copy_row ()

int
gretl_matrix_copy_row (gretl_matrix *dest,
                       int di,
                       const gretl_matrix *src,
                       int si);

Copies the values from row si of src into row di of dest , provided src and dest have the same number of columns.

gretl_matrix_inscribe_I ()

int
gretl_matrix_inscribe_I (gretl_matrix *m,
                         int row,
                         int col,
                         int n);

Writes an n x n identity matrix into matrix m , the top left-hand corner of the insertion being given by row and col (which are 0-based).

gretl_matrix_copy_transpose ()

gretl_matrix *
gretl_matrix_copy_transpose (const gretl_matrix *m);

gretl_matrix_reverse_rows ()

gretl_matrix *
gretl_matrix_reverse_rows (const gretl_matrix *m);

gretl_matrix_reverse_cols ()

gretl_matrix *
gretl_matrix_reverse_cols (const gretl_matrix *m);

gretl_matrix_get_diagonal ()

gretl_matrix *
gretl_matrix_get_diagonal (const gretl_matrix *m,
                           int *err);

gretl_matrix_get_row ()

int
gretl_matrix_get_row (const gretl_matrix *m,
                      int i,
                      gretl_vector *v);

Copies row i of matrix m into vector v .

gretl_matrix_trace ()

double
gretl_matrix_trace (const gretl_matrix *m);

gretl_matrix_random_fill ()

int
gretl_matrix_random_fill (gretl_matrix *m,
                          int dist);

Fills m with pseudo-random values from either the uniform or the standard normal distribution.

gretl_random_matrix_new ()

gretl_matrix *
gretl_random_matrix_new (int r,
                         int c,
                         int dist);

Creates a new $r x c matrix and filles it with pseudo-random values from either the uniform or the standard normal distribution.

gretl_matrix_resample ()

gretl_matrix *
gretl_matrix_resample (const gretl_matrix *m,
                       int *err);

gretl_matrix_block_resample ()

gretl_matrix *
gretl_matrix_block_resample (const gretl_matrix *m,
                             int blocklen,
                             int *err);

gretl_matrix_block_resample2 ()

int
gretl_matrix_block_resample2 (const gretl_matrix *src,
                              gretl_matrix *targ,
                              int blocklen,
                              int *z);

An "in-place" version of gretl_matrix_block_resample(). It is assumed that targ is a matrix of the same dimensions as src , that blocklen is greater than 1, and that z is long enough to hold n integers, where n is the number of rows in src divided by blocklen , rounded up to the nearest integer.

gretl_vector_mean ()

double
gretl_vector_mean (const gretl_vector *v);

gretl_vector_variance ()

double
gretl_vector_variance (const gretl_vector *v);

gretl_matrix_zero ()

void
gretl_matrix_zero (gretl_matrix *m);

Sets all elements of m to zero.

gretl_matrix_zero_upper ()

int
gretl_matrix_zero_upper (gretl_matrix *m);

Sets the elements of m outside of the lower triangle to zero.

gretl_matrix_zero_lower ()

int
gretl_matrix_zero_lower (gretl_matrix *m);

Sets the elements of m outside of the upper triangle to zero.

gretl_matrix_mirror ()

int
gretl_matrix_mirror (gretl_matrix *m,
                     char uplo);

If uplo = 'L', copy the lower triangle of m into the upper triangle; or if uplo = 'U' copy the upper triangle into the lower, in either case producing a symmetric result.

gretl_matrix_fill ()

void
gretl_matrix_fill (gretl_matrix *m,
                   double x);

Sets all entries in m to the value x .

gretl_matrix_multiply_by_scalar ()

void
gretl_matrix_multiply_by_scalar (gretl_matrix *m,
                                 double x);

Multiplies all elements of m by x .

gretl_matrix_divide_by_scalar ()

int
gretl_matrix_divide_by_scalar (gretl_matrix *m,
                               double x);

Divides all elements of m by x .

gretl_matrix_switch_sign ()

void
gretl_matrix_switch_sign (gretl_matrix *m);

Changes the sign of each element of m .

gretl_matrix_dot_op ()

gretl_matrix *
gretl_matrix_dot_op (const gretl_matrix *a,
                     const gretl_matrix *b,
                     int op,
                     int *err);

gretl_matrix_complex_multiply ()

gretl_matrix *
gretl_matrix_complex_multiply (const gretl_matrix *a,
                               const gretl_matrix *b,
                               int *err);

Computes the complex product of a and b . The first column in these matrices is assumed to contain real values, and the second column (if present) imaginary coefficients.

gretl_matrix_divide ()

gretl_matrix *
gretl_matrix_divide (const gretl_matrix *a,
                     const gretl_matrix *b,
                     GretlMatrixMod mod,
                     int *err);

Follows the semantics of Matlab/Octave for left and right matrix "division". In left division, A \ B is in principle equivalent to A^{-1} * B, and in right division A / B is in principle equivalent to A * B^{-1}, but the result is obtained without explicit computation of the inverse.

In left division a and b must have the same number of rows; in right division they must have the same number of columns.

gretl_matrix_complex_divide ()

gretl_matrix *
gretl_matrix_complex_divide (const gretl_matrix *a,
                             const gretl_matrix *b,
                             int *err);

Computes the complex division of a over b . The first column in these matrices is assumed to contain real values, and the second column (if present) imaginary coefficients.

gretl_matrix_exp ()

gretl_matrix *
gretl_matrix_exp (const gretl_matrix *m,
                  int *err);

Calculates the matrix exponential of m , using algorithm 11.3.1 from Golub and Van Loan, "Matrix Computations", 3e.

gretl_matrix_polroots ()

gretl_matrix *
gretl_matrix_polroots (const gretl_matrix *a,
                       int *err);

Calculates the roots of the polynomial with coefficients given by a . If the degree of the polynomial is p, then a should contain p + 1 coefficients in ascending order, i.e. starting with the constant and ending with the coefficient on x^p.

gretl_matrix_raise ()

void
gretl_matrix_raise (gretl_matrix *m,
                    double x);

Raises each element of m to the power x .

gretl_matrix_free ()

void
gretl_matrix_free (gretl_matrix *m);

Frees the allocated storage in m , then m itself.

gretl_matrix_steal_data ()

double *
gretl_matrix_steal_data (gretl_matrix *m);

"Steals" the allocated data from m , which is left with a NULL data pointer.

gretl_vector_copy_values ()

int
gretl_vector_copy_values (gretl_vector *targ,
                          const gretl_vector *src);

Copies the elements of src into the corresponding elements of targ .

gretl_matrix_copy_values ()

int
gretl_matrix_copy_values (gretl_matrix *targ,
                          const gretl_matrix *src);

Copies the elements of src into the corresponding elements of targ .

gretl_matrix_copy_data ()

int
gretl_matrix_copy_data (gretl_matrix *targ,
                        const gretl_matrix *src);

Copies all data from src to targ : this does the same as gretl_matrix_copy_values() but also transcribes t1, t2, colnames and rownames information, if present.

gretl_matrix_copy_values_shaped ()

int
gretl_matrix_copy_values_shaped (gretl_matrix *targ,
                                 const gretl_matrix *src);

Copies the elements of src into targ , column by column.

gretl_matrix_add_to ()

int
gretl_matrix_add_to (gretl_matrix *targ,
                     const gretl_matrix *src);

Adds the elements of src to the corresponding elements of targ .

gretl_matrix_add ()

int
gretl_matrix_add (const gretl_matrix *a,
                  const gretl_matrix *b,
                  gretl_matrix *c);

Adds the elements of a and b , the result going to c .

gretl_matrix_add_transpose_to ()

int
gretl_matrix_add_transpose_to (gretl_matrix *targ,
                               const gretl_matrix *src);

Adds the elements of src , transposed, to the corresponding elements of targ .

gretl_matrix_subtract_from ()

int
gretl_matrix_subtract_from (gretl_matrix *targ,
                            const gretl_matrix *src);

Subtracts the elements of src from the corresponding elements of targ .

gretl_matrix_subtract ()

int
gretl_matrix_subtract (const gretl_matrix *a,
                       const gretl_matrix *b,
                       gretl_matrix *c);

Subtracts the elements of b from the corresponding elements of a , the result going to c .

gretl_matrix_subtract_reversed ()

int
gretl_matrix_subtract_reversed (const gretl_matrix *a,
                                gretl_matrix *b);

Operates on b such that b_{ij} = a_{ij} - b_{ij}.

gretl_matrix_I_minus ()

int
gretl_matrix_I_minus (gretl_matrix *m);

Rewrites m as (I - m), where I is the n x n identity matrix.

gretl_matrix_transpose_in_place ()

int
gretl_matrix_transpose_in_place (gretl_matrix *m);

Tranposes m in place.

gretl_matrix_transpose ()

int
gretl_matrix_transpose (gretl_matrix *targ,
                        const gretl_matrix *src);

Fills out targ (which must be pre-allocated and of the right dimensions) with the transpose of src .

gretl_square_matrix_transpose ()

int
gretl_square_matrix_transpose (gretl_matrix *m);

Transposes the matrix m .

gretl_matrix_add_self_transpose ()

int
gretl_matrix_add_self_transpose (gretl_matrix *m);

Adds the transpose of m to m itself, yielding a symmetric matrix.

gretl_matrix_vectorize ()

int
gretl_matrix_vectorize (gretl_matrix *targ,
                        const gretl_matrix *src);

Writes into targ vec(src ), that is, a column vector formed by stacking the columns of src .

gretl_matrix_vectorize_new ()

gretl_matrix *
gretl_matrix_vectorize_new (const gretl_matrix *m);

gretl_matrix_unvectorize ()

int
gretl_matrix_unvectorize (gretl_matrix *targ,
                          const gretl_matrix *src);

Writes successive blocks of length m from src into the successive columns of targ (that is, performs the inverse of the vec() operation).

gretl_matrix_vectorize_h ()

int
gretl_matrix_vectorize_h (gretl_matrix *targ,
                          const gretl_matrix *src);

Writes into targ vech(src ), that is, a column vector containing the lower-triangular elements of src . This is only useful for symmetric matrices, but for the sake of performance we don't check for that.

gretl_matrix_unvectorize_h ()

int
gretl_matrix_unvectorize_h (gretl_matrix *targ,
                            const gretl_matrix *src);

Rearranges successive blocks of decreasing length from src into the successive columns of targ (that is, performs the inverse of the vech() operation): targ comes out symmetric.

gretl_matrix_inscribe_matrix ()

int
gretl_matrix_inscribe_matrix (gretl_matrix *targ,
                              const gretl_matrix *src,
                              int row,
                              int col,
                              GretlMatrixMod mod);

Writes src into targ , starting at offset row , col . The targ matrix must be large enough to sustain the inscription of src at the specified point. If mod is GRETL_MOD_TRANSPOSE it is in fact the transpose of src that is written into targ .

gretl_matrix_extract_matrix ()

int
gretl_matrix_extract_matrix (gretl_matrix *targ,
                             const gretl_matrix *src,
                             int row,
                             int col,
                             GretlMatrixMod mod);

Writes into targ a sub-matrix of src , taken from the offset row , col . The targ matrix must be large enough to provide a sub-matrix of the dimensions of src . If mod is GRETL_MOD_TRANSPOSE it is in fact the transpose of the sub-matrix that that is written into targ .

gretl_matrix_multiply_mod ()

int
gretl_matrix_multiply_mod (const gretl_matrix *a,
                           GretlMatrixMod amod,
                           const gretl_matrix *b,
                           GretlMatrixMod bmod,
                           gretl_matrix *c,
                           GretlMatrixMod cmod);

Multiplies a (or a-transpose) into b (or b transpose), with the result written into c .

gretl_matrix_multiply_mod_single ()

int
gretl_matrix_multiply_mod_single (const gretl_matrix *a,
                                  GretlMatrixMod amod,
                                  const gretl_matrix *b,
                                  GretlMatrixMod bmod,
                                  gretl_matrix *c,
                                  GretlMatrixMod cmod);

gretl_matrix_multiply ()

int
gretl_matrix_multiply (const gretl_matrix *a,
                       const gretl_matrix *b,
                       gretl_matrix *c);

Multiplies a into b , with the result written into c .

gretl_matrix_multiply_single ()

int
gretl_matrix_multiply_single (const gretl_matrix *a,
                              const gretl_matrix *b,
                              gretl_matrix *c);

gretl_matrix_multiply_new ()

gretl_matrix *
gretl_matrix_multiply_new (const gretl_matrix *a,
                           const gretl_matrix *b,
                           int *err);

Multiplies a into b , with the result written into a newly allocated matrix.

gretl_matrix_kronecker_product ()

int
gretl_matrix_kronecker_product (const gretl_matrix *A,
                                const gretl_matrix *B,
                                gretl_matrix *K);

Writes the Kronecker product of A and B into K .

gretl_matrix_kronecker_product_new ()

gretl_matrix *
gretl_matrix_kronecker_product_new (const gretl_matrix *A,
                                    const gretl_matrix *B,
                                    int *err);

gretl_matrix_hdproduct ()

int
gretl_matrix_hdproduct (const gretl_matrix *A,
                        const gretl_matrix *B,
                        gretl_matrix *C);

Writes into C the horizontal direct product of A and B . That is, $C_i' = A_i' \otimes B_i'$ (in TeX notation)

gretl_matrix_hdproduct_new ()

gretl_matrix *
gretl_matrix_hdproduct_new (const gretl_matrix *A,
                            const gretl_matrix *B,
                            int *err);

gretl_matrix_I_kronecker ()

int
gretl_matrix_I_kronecker (int p,
                          const gretl_matrix *B,
                          gretl_matrix *K);

Writes the Kronecker product of the identity matrix of order r and B into K .

gretl_matrix_I_kronecker_new ()

gretl_matrix *
gretl_matrix_I_kronecker_new (int p,
                              const gretl_matrix *B,
                              int *err);

Writes the Kronecker product of the identity matrix of order r and B into a newly allocated matrix.

gretl_matrix_kronecker_I ()

int
gretl_matrix_kronecker_I (const gretl_matrix *A,
                          int r,
                          gretl_matrix *K);

Writes the Kronecker product of A and the identity matrix of order r into K .

gretl_matrix_kronecker_I_new ()

gretl_matrix *
gretl_matrix_kronecker_I_new (const gretl_matrix *A,
                              int r,
                              int *err);

Writes into a newl allocated matrix the Kronecker product of A and the identity matrix of order r .

gretl_matrix_pow ()

gretl_matrix *
gretl_matrix_pow (const gretl_matrix *A,
                  int s,
                  int *err);

Calculates the matrix A^k using Golub and Van Loan's Algorithm 11.2.2 ("Binary Powering").

gretl_matrix_dot_product ()

double
gretl_matrix_dot_product (const gretl_matrix *a,
                          GretlMatrixMod amod,
                          const gretl_matrix *b,
                          GretlMatrixMod bmod,
                          int *err);

gretl_vector_dot_product ()

double
gretl_vector_dot_product (const gretl_vector *a,
                          const gretl_vector *b,
                          int *err);

gretl_matrix_row_sum ()

gretl_matrix *
gretl_matrix_row_sum (const gretl_matrix *m,
                      int *err);

gretl_matrix_column_sum ()

gretl_matrix *
gretl_matrix_column_sum (const gretl_matrix *m,
                         int *err);

gretl_matrix_row_prod ()

gretl_matrix *
gretl_matrix_row_prod (const gretl_matrix *m,
                       int *err);

gretl_matrix_column_prod ()

gretl_matrix *
gretl_matrix_column_prod (const gretl_matrix *m,
                          int *err);

gretl_matrix_row_mean ()

gretl_matrix *
gretl_matrix_row_mean (const gretl_matrix *m,
                       int *err);

gretl_matrix_column_mean ()

gretl_matrix *
gretl_matrix_column_mean (const gretl_matrix *m,
                          int *err);

gretl_matrix_column_sd ()

gretl_matrix *
gretl_matrix_column_sd (const gretl_matrix *m,
                        int *err);

gretl_matrix_column_sd2 ()

gretl_matrix *
gretl_matrix_column_sd2 (const gretl_matrix *m,
                         int df,
                         int *err);

gretl_matrix_row_i_mean ()

double
gretl_matrix_row_i_mean (const gretl_matrix *m,
                         int row);

gretl_matrix_column_j_mean ()

double
gretl_matrix_column_j_mean (const gretl_matrix *m,
                            int col);

gretl_matrix_demean_by_row ()

void
gretl_matrix_demean_by_row (gretl_matrix *m);

For each row of m , subtracts the row mean from each element on the row.

gretl_matrix_demean_by_column ()

void
gretl_matrix_demean_by_column (gretl_matrix *m);

For each column of m , subtracts the column mean from each element in the column.

gretl_matrix_vcv ()

gretl_matrix *
gretl_matrix_vcv (gretl_matrix *m);

Forms a variance-covariance matrix based on m , thus: (1) subtract the column means from the column elements of m ; (2) multiply m -transpose into m ; and (3) divide the elements of the product by the number of rows in m .

gretl_matrix_quantiles ()

gretl_matrix *
gretl_matrix_quantiles (const gretl_matrix *m,
                        const gretl_matrix *p,
                        int *err);

gretl_matrix_determinant ()

double
gretl_matrix_determinant (gretl_matrix *a,
                          int *err);

Compute the determinant of the square matrix a using the LU factorization. Matrix a is not preserved: it is overwritten by the factorization.

gretl_matrix_log_determinant ()

double
gretl_matrix_log_determinant (gretl_matrix *a,
                              int *err);

Compute the log of the determinant of the square matrix a using LU factorization. Matrix a is not preserved: it is overwritten by the factorization.

gretl_matrix_log_abs_determinant ()

double
gretl_matrix_log_abs_determinant (gretl_matrix *a,
                                  int *err);

Compute the log of the absolute value of the determinant of the square matrix a using LU factorization. Matrix a is not preserved: it is overwritten by the factorization.

gretl_vcv_log_determinant ()

double
gretl_vcv_log_determinant (const gretl_matrix *m,
                           int *err);

Compute the log determinant of the symmetric positive-definite matrix m using Cholesky decomposition.

gretl_matrix_one_norm ()

double
gretl_matrix_one_norm (const gretl_matrix *m);

gretl_matrix_infinity_norm ()

double
gretl_matrix_infinity_norm (const gretl_matrix *m);

gretl_LU_solve ()

int
gretl_LU_solve (gretl_matrix *a,
                gretl_matrix *b);

Solves ax = b for the unknown x, via LU decomposition using partial pivoting with row interchanges. On exit, b is replaced by the solution and a is replaced by its decomposition. Calls the LAPACK functions dgetrf() and dgetrs().

gretl_LU_solve_invert ()

int
gretl_LU_solve_invert (gretl_matrix *a,
                       gretl_matrix *b);

Solves ax = b for the unknown x, using LU decomposition, then proceeds to use the decomposition to invert a . Calls the LAPACK functions dgetrf(), dgetrs() and dgetri(); the decomposition proceeds via partial pivoting with row interchanges.

On exit, b is replaced by the solution and a is replaced by its inverse.

gretl_cholesky_decomp_solve ()

int
gretl_cholesky_decomp_solve (gretl_matrix *a,
                             gretl_matrix *b);

Solves ax = b for the unknown vector x, using Cholesky decomposition via the LAPACK functions dpotrf() and dpotrs().

On exit, b is replaced by the solution and a is replaced by its Cholesky decomposition.

gretl_cholesky_solve ()

int
gretl_cholesky_solve (const gretl_matrix *a,
                      gretl_vector *b);

Solves ax = b for the unknown vector x, using the pre-computed Cholesky decomposition of a . On exit, b is replaced by the solution.

gretl_cholesky_invert ()

int
gretl_cholesky_invert (gretl_matrix *a);

Inverts a , which must contain the pre-computed Cholesky decomposition of a p.d. matrix, as may be obtained using gretl_cholesky_decomp_solve(). For speed there's no error checking of the input -- the caller should make sure it's OK.

gretl_toeplitz_solve ()

gretl_vector *
gretl_toeplitz_solve (const gretl_vector *c,
                      const gretl_vector *r,
                      const gretl_vector *b,
                      int *err);

Solves Tx = b for the unknown vector x, where T is a Toeplitz matrix, that is (zero-based)

T_{ij} = c_{i-j} for i <= j T_{ij} = r_{i-j} for i > j

Note that c[0] should equal r[0].

gretl_matrix_XTX_new ()

gretl_matrix *
gretl_matrix_XTX_new (const gretl_matrix *X);

gretl_inverse_from_cholesky_decomp ()

int
gretl_inverse_from_cholesky_decomp (gretl_matrix *targ,
                                    const gretl_matrix *src);

Computes in targ the inverse of a symmetric positive definite matrix, on the assumption that the original matrix this has already been Cholesky-decomposed in src .

gretl_invert_general_matrix ()

int
gretl_invert_general_matrix (gretl_matrix *a);

Computes the inverse of a general matrix using LU factorization. On exit a is overwritten with the inverse. Uses the LAPACK functions dgetrf() and dgetri().

gretl_invert_symmetric_indef_matrix ()

int
gretl_invert_symmetric_indef_matrix (gretl_matrix *a);

Computes the inverse of a real symmetric matrix via the Bunch-Kaufman diagonal pivoting method. Uses the LAPACK functions dsytrf() and dsytri(). On exit a is overwritten with the inverse.

gretl_invert_symmetric_matrix ()

int
gretl_invert_symmetric_matrix (gretl_matrix *a);

Computes the inverse of a symmetric positive definite matrix using Cholesky factorization. On exit a is overwritten with the inverse. Uses the LAPACK functions dpotrf() and dpotri().

gretl_invert_symmetric_matrix2 ()

int
gretl_invert_symmetric_matrix2 (gretl_matrix *a,
                                double *ldet);

Computes the inverse of a symmetric positive definite matrix using Cholesky factorization, computing the log-determinant in the process. On exit a is overwritten with the inverse and if ldet is not NULL the log-determinant is written to that location. Uses the LAPACK functions dpotrf() and dpotri().

gretl_invert_packed_symmetric_matrix ()

int
gretl_invert_packed_symmetric_matrix (gretl_matrix *v);

Computes the inverse of a symmetric positive definite matrix, stored in vech form, using Cholesky factorization. On exit v is overwritten with the lower triangle of the inverse. Uses the LAPACK functions dpptrf() and dpptri().

gretl_invert_triangular_matrix ()

int
gretl_invert_triangular_matrix (gretl_matrix *a,
                                char uplo);

Computes the inverse of a triangular matrix. On exit a is overwritten with the inverse. Uses the lapack function dtrtri.

gretl_invert_diagonal_matrix ()

int
gretl_invert_diagonal_matrix (gretl_matrix *a);

Computes the inverse of a diagonal matrix. On exit a is overwritten with the inverse.

gretl_invert_matrix ()

int
gretl_invert_matrix (gretl_matrix *a);

Computes the inverse of matrix a : on exit a is overwritten with the inverse. If a is diagonal or symmetric, appropriate simple inversion routines are called.

gretl_matrix_moore_penrose ()

int
gretl_matrix_moore_penrose (gretl_matrix *A);

Computes the generalized inverse of matrix a via its SVD factorization, with the help of the lapack function dgesvd. On exit the original matrix is overwritten by the inverse.

gretl_SVD_invert_matrix ()

int
gretl_SVD_invert_matrix (gretl_matrix *a);

Computes the inverse (or generalized inverse) of a general square matrix using SVD factorization, with the help of the lapack function dgesvd. If any of the singular values of a are less than 1.0e-9 the Moore-Penrose generalized inverse is computed instead of the standard inverse. On exit the original matrix is overwritten by the inverse.

gretl_invpd ()

int
gretl_invpd (gretl_matrix *a);

Computes the inverse of a symmetric positive definite matrix using Cholesky factorization. On exit a is overwritten with the inverse. Uses the LAPACK functions dpotrf() and dpotri(). Little checking is done, for speed: we assume the caller knows what he's doing.

gretl_maybe_invpd ()

int
gretl_maybe_invpd (gretl_matrix *a);

Attempts to computes the inverse of a matrix which may be positive definite. On exit a is overwritten with the inverse. Uses the LAPACK functions dpotrf() and dpotri(). Little checking is done, for speed: we assume the caller knows what he's doing. Unlike gretl_invpd() this function does not dump error messages to stderr in case the matrix is not in fact positive definite.

gretl_matrix_SVD ()

int
gretl_matrix_SVD (const gretl_matrix *a,
                  gretl_matrix **pu,
                  gretl_vector **ps,
                  gretl_matrix **pvt);

Computes SVD factorization of a general matrix using the lapack function dgesvd. A = u * diag(s) * vt.

gretl_symmetric_matrix_rcond ()

double
gretl_symmetric_matrix_rcond (const gretl_matrix *m,
                              int *err);

Estimates the reciprocal condition number of the real symmetric positive definite matrix m (in the 1-norm), using the LAPACK functions dpotrf() and dpocon().

gretl_matrix_rcond ()

double
gretl_matrix_rcond (const gretl_matrix *m,
                    int *err);

Estimates the reciprocal condition number of the real matrix m (in the 1-norm).

gretl_matrix_cond_index ()

double
gretl_matrix_cond_index (const gretl_matrix *m,
                         int *err);

Estimates the condition number (a la Belsley) of the real matrix m .

gretl_symmetric_eigen_sort ()

int
gretl_symmetric_eigen_sort (gretl_matrix *evals,
                            gretl_matrix *evecs,
                            int rank);

Sorts the eigenvalues in evals from largest to smallest, and rearranges the columns in evecs correspondingly. If rank is greater than zero and less than the number of columns in evecs , then on output evecs is shrunk so that it contains only the columns associated with the largest rank eigenvalues.