/* glpspm.h (general sparse matrix) */

 /***********************************************************************

 *  This code is part of GLPK (GNU Linear Programming Kit).

 *

 *  Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,

 *  2009, 2010 Andrew Makhorin, Department for Applied Informatics,

 *  Moscow Aviation Institute, Moscow, Russia. All rights reserved.

 *  E-mail: <mao@gnu.org>.

 *

 *  GLPK is free software: you can redistribute it and/or modify it

 *  under the terms of the GNU General Public License as published by

 *  the Free Software Foundation, either version 3 of the License, or

 *  (at your option) any later version.

 *

 *  GLPK is distributed in the hope that it will be useful, but WITHOUT

 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

 *  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public

 *  License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with GLPK. If not, see <http://www.gnu.org/licenses/>.

 ***********************************************************************/

 #ifndef GLPSPM_H

 #define GLPSPM_H

 #include "glpdmp.h"

 typedef struct SPM SPM;

 typedef struct SPME SPME;

 struct SPM

 {     /* general sparse matrix */

       int m;

       /* number of rows, m >= 0 */

       int n;

       /* number of columns, n >= 0 */

       DMP *pool;

       /* memory pool to store matrix elements */

       SPME **row; /* SPME *row[1+m]; */

       /* row[i], 1 <= i <= m, is a pointer to i-th row list */

       SPME **col; /* SPME *col[1+n]; */

       /* col[j], 1 <= j <= n, is a pointer to j-th column list */

 };

 struct SPME

 {     /* sparse matrix element */

       int i;

       /* row number */

       int j;

       /* column number */

       double val;

       /* element value */

       SPME *r_prev;

       /* pointer to previous element in the same row */

       SPME *r_next;

       /* pointer to next element in the same row */

       SPME *c_prev;

       /* pointer to previous element in the same column */

       SPME *c_next;

       /* pointer to next element in the same column */

 };

 typedef struct PER PER;

 struct PER

 {     /* permutation matrix */

       int n;

       /* matrix order, n >= 0 */

       int *row; /* int row[1+n]; */

       /* row[i] = j means p[i,j] = 1 */

       int *col; /* int col[1+n]; */

       /* col[j] = i means p[i,j] = 1 */

 };

 #define spm_create_mat _glp_spm_create_mat

 SPM *spm_create_mat(int m, int n);

 /* create general sparse matrix */

 #define spm_new_elem _glp_spm_new_elem

 SPME *spm_new_elem(SPM *A, int i, int j, double val);

 /* add new element to sparse matrix */

 #define spm_delete_mat _glp_spm_delete_mat

 void spm_delete_mat(SPM *A);

 /* delete general sparse matrix */

 #define spm_test_mat_e _glp_spm_test_mat_e

 SPM *spm_test_mat_e(int n, int c);

 /* create test sparse matrix of E(n,c) class */

 #define spm_test_mat_d _glp_spm_test_mat_d

 SPM *spm_test_mat_d(int n, int c);

 /* create test sparse matrix of D(n,c) class */

 #define spm_show_mat _glp_spm_show_mat

 int spm_show_mat(const SPM *A, const char *fname);

 /* write sparse matrix pattern in BMP file format */

 #define spm_read_hbm _glp_spm_read_hbm

 SPM *spm_read_hbm(const char *fname);

 /* read sparse matrix in Harwell-Boeing format */

 #define spm_count_nnz _glp_spm_count_nnz

 int spm_count_nnz(const SPM *A);

 /* determine number of non-zeros in sparse matrix */

 #define spm_drop_zeros _glp_spm_drop_zeros

 int spm_drop_zeros(SPM *A, double eps);

 /* remove zero elements from sparse matrix */

 #define spm_read_mat _glp_spm_read_mat

 SPM *spm_read_mat(const char *fname);

 /* read sparse matrix from text file */

 #define spm_write_mat _glp_spm_write_mat

 int spm_write_mat(const SPM *A, const char *fname);

 /* write sparse matrix to text file */

 #define spm_transpose _glp_spm_transpose

 SPM *spm_transpose(const SPM *A);

 /* transpose sparse matrix */

 #define spm_add_sym _glp_spm_add_sym

 SPM *spm_add_sym(const SPM *A, const SPM *B);

 /* add two sparse matrices (symbolic phase) */

 #define spm_add_num _glp_spm_add_num

 void spm_add_num(SPM *C, double alfa, const SPM *A, double beta,

       const SPM *B);

 /* add two sparse matrices (numeric phase) */

 #define spm_add_mat _glp_spm_add_mat

 SPM *spm_add_mat(double alfa, const SPM *A, double beta,

       const SPM *B);

 /* add two sparse matrices (driver routine) */

 #define spm_mul_sym _glp_spm_mul_sym

 SPM *spm_mul_sym(const SPM *A, const SPM *B);

 /* multiply two sparse matrices (symbolic phase) */

 #define spm_mul_num _glp_spm_mul_num

 void spm_mul_num(SPM *C, const SPM *A, const SPM *B);

 /* multiply two sparse matrices (numeric phase) */

 #define spm_mul_mat _glp_spm_mul_mat

 SPM *spm_mul_mat(const SPM *A, const SPM *B);

 /* multiply two sparse matrices (driver routine) */

 #define spm_create_per _glp_spm_create_per

 PER *spm_create_per(int n);

 /* create permutation matrix */

 #define spm_check_per _glp_spm_check_per

 void spm_check_per(PER *P);

 /* check permutation matrix for correctness */

 #define spm_delete_per _glp_spm_delete_per

 void spm_delete_per(PER *P);

 /* delete permutation matrix */

 #endif

 /* eof */