R_DIAG_MIN

#define R_DIAG_MIN 1.0e-8

enum GretlMatrixMod

typedef enum {
    GRETL_MOD_NONE = 0,
    GRETL_MOD_TRANSPOSE,
    GRETL_MOD_SQUARE,
    GRETL_MOD_CUMULATE,
    GRETL_MOD_DECUMULATE
} GretlMatrixMod;

enum GretlMatrixStructure

typedef enum {
    GRETL_MATRIX_SQUARE = 1,
    GRETL_MATRIX_LOWER_TRIANGULAR,
    GRETL_MATRIX_UPPER_TRIANGULAR,
    GRETL_MATRIX_SYMMETRIC,
    GRETL_MATRIX_DIAGONAL,
    GRETL_MATRIX_SCALAR
} GretlMatrixStructure;

gretl_matrix

typedef struct {
    int rows;
    int cols;
    int t1, t2;
    double *val;
} gretl_matrix;

gretl_vector

typedef struct _gretl_matrix gretl_vector;

gretl_matrix_get()

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

Sets the i, j element of m to x.

gretl_vector_get()

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

Gives element i of v.

gretl_matrix_set()

#define gretl_matrix_set(m,i,j,x) (m->val[(j)*m->rows+(i)]=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)

Gives the number of columns in m.

gretl_matrix_rows()

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

Gives the number of rows in m.

gretl_vector_get_length()

#define     gretl_vector_get_length(v)

Gives the length of vector v (without regard to whether it is a row or column vector).

gretl_vector_alloc()

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

Allocates a new gretl_vector with i columns.

gretl_column_vector_alloc()

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

Allocates a new column gretl_vector with i rows.

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)

Gives 1 if m is 1 x 1, else 0.

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.5e-12.

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 the 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_identity_matrix_new ()

gretl_matrix* gretl_identity_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              (int start,
                                             int end);

start: first element. end: last element.

gretl_matrix_copy ()

gretl_matrix* gretl_matrix_copy             (const gretl_matrix *m);

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_get_diagonal ()

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

gretl_matrix_trace ()

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

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_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_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_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_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_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_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_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_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_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 ()

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_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 ()

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_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);

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 *errp);

gretl_vector_dot_product ()

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

gretl_matrix_row_sum ()

gretl_matrix* gretl_matrix_row_sum          (const gretl_matrix *m);

gretl_matrix_column_sum ()

gretl_matrix* gretl_matrix_column_sum       (const gretl_matrix *m);

gretl_matrix_row_mean ()

gretl_matrix* gretl_matrix_row_mean         (const gretl_matrix *m);

gretl_matrix_column_mean ()

gretl_matrix* gretl_matrix_column_mean      (const gretl_matrix *m);

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_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.