1 /* glpspm.h (general sparse matrix) */
2
3 /***********************************************************************
4 * This code is part of GLPK (GNU Linear Programming Kit).
5 *
6 * Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
7 * 2009, 2010 Andrew Makhorin, Department for Applied Informatics,
8 * Moscow Aviation Institute, Moscow, Russia. All rights reserved.
9 * E-mail: <mao@gnu.org>.
10 *
11 * GLPK is free software: you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by
13 * the Free Software Foundation, either version 3 of the License, or
14 * (at your option) any later version.
15 *
16 * GLPK is distributed in the hope that it will be useful, but WITHOUT
17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
19 * License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with GLPK. If not, see <http://www.gnu.org/licenses/>.
23 ***********************************************************************/
24
25 #ifndef GLPSPM_H
26 #define GLPSPM_H
get_row_lb(LPX * lp,int i)27
28 #include "glpdmp.h"
29
30 typedef struct SPM SPM;
31 typedef struct SPME SPME;
32
33 struct SPM
34 { /* general sparse matrix */
35 int m;
36 /* number of rows, m >= 0 */
37 int n;
38 /* number of columns, n >= 0 */
39 DMP *pool;
40 /* memory pool to store matrix elements */
41 SPME **row; /* SPME *row[1+m]; */
42 /* row[i], 1 <= i <= m, is a pointer to i-th row list */
43 SPME **col; /* SPME *col[1+n]; */
44 /* col[j], 1 <= j <= n, is a pointer to j-th column list */
45 };
46
get_row_ub(LPX * lp,int i)47 struct SPME
48 { /* sparse matrix element */
49 int i;
50 /* row number */
51 int j;
52 /* column number */
53 double val;
54 /* element value */
55 SPME *r_prev;
56 /* pointer to previous element in the same row */
57 SPME *r_next;
58 /* pointer to next element in the same row */
59 SPME *c_prev;
60 /* pointer to previous element in the same column */
61 SPME *c_next;
62 /* pointer to next element in the same column */
63 };
64
65 typedef struct PER PER;
66
get_col_lb(LPX * lp,int j)67 struct PER
68 { /* permutation matrix */
69 int n;
70 /* matrix order, n >= 0 */
71 int *row; /* int row[1+n]; */
72 /* row[i] = j means p[i,j] = 1 */
73 int *col; /* int col[1+n]; */
74 /* col[j] = i means p[i,j] = 1 */
75 };
76
77 #define spm_create_mat _glp_spm_create_mat
78 SPM *spm_create_mat(int m, int n);
79 /* create general sparse matrix */
80
81 #define spm_new_elem _glp_spm_new_elem
82 SPME *spm_new_elem(SPM *A, int i, int j, double val);
83 /* add new element to sparse matrix */
84
85 #define spm_delete_mat _glp_spm_delete_mat
86 void spm_delete_mat(SPM *A);
get_col_ub(LPX * lp,int j)87 /* delete general sparse matrix */
88
89 #define spm_test_mat_e _glp_spm_test_mat_e
90 SPM *spm_test_mat_e(int n, int c);
91 /* create test sparse matrix of E(n,c) class */
92
93 #define spm_test_mat_d _glp_spm_test_mat_d
94 SPM *spm_test_mat_d(int n, int c);
95 /* create test sparse matrix of D(n,c) class */
96
97 #define spm_show_mat _glp_spm_show_mat
98 int spm_show_mat(const SPM *A, const char *fname);
99 /* write sparse matrix pattern in BMP file format */
100
101 #define spm_read_hbm _glp_spm_read_hbm
102 SPM *spm_read_hbm(const char *fname);
103 /* read sparse matrix in Harwell-Boeing format */
104
105 #define spm_count_nnz _glp_spm_count_nnz
106 int spm_count_nnz(const SPM *A);
is_binary(LPX * lp,int j)107 /* determine number of non-zeros in sparse matrix */
108
109 #define spm_drop_zeros _glp_spm_drop_zeros
110 int spm_drop_zeros(SPM *A, double eps);
111 /* remove zero elements from sparse matrix */
112
113 #define spm_read_mat _glp_spm_read_mat
114 SPM *spm_read_mat(const char *fname);
eval_lf_min(LPX * lp,int len,int ind[],double val[])115 /* read sparse matrix from text file */
116
117 #define spm_write_mat _glp_spm_write_mat
118 int spm_write_mat(const SPM *A, const char *fname);
119 /* write sparse matrix to text file */
120
121 #define spm_transpose _glp_spm_transpose
122 SPM *spm_transpose(const SPM *A);
123 /* transpose sparse matrix */
124
125 #define spm_add_sym _glp_spm_add_sym
126 SPM *spm_add_sym(const SPM *A, const SPM *B);
127 /* add two sparse matrices (symbolic phase) */
128
129 #define spm_add_num _glp_spm_add_num
130 void spm_add_num(SPM *C, double alfa, const SPM *A, double beta,
131 const SPM *B);
132 /* add two sparse matrices (numeric phase) */
133
134 #define spm_add_mat _glp_spm_add_mat
135 SPM *spm_add_mat(double alfa, const SPM *A, double beta,
136 const SPM *B);
137 /* add two sparse matrices (driver routine) */
138
139 #define spm_mul_sym _glp_spm_mul_sym
140 SPM *spm_mul_sym(const SPM *A, const SPM *B);
141 /* multiply two sparse matrices (symbolic phase) */
142
143 #define spm_mul_num _glp_spm_mul_num
144 void spm_mul_num(SPM *C, const SPM *A, const SPM *B);
145 /* multiply two sparse matrices (numeric phase) */
146
147 #define spm_mul_mat _glp_spm_mul_mat
148 SPM *spm_mul_mat(const SPM *A, const SPM *B);
149 /* multiply two sparse matrices (driver routine) */
150
151 #define spm_create_per _glp_spm_create_per
152 PER *spm_create_per(int n);
153 /* create permutation matrix */
154
eval_lf_max(LPX * lp,int len,int ind[],double val[])155 #define spm_check_per _glp_spm_check_per
156 void spm_check_per(PER *P);
157 /* check permutation matrix for correctness */
158
159 #define spm_delete_per _glp_spm_delete_per
160 void spm_delete_per(PER *P);
161 /* delete permutation matrix */
162
163 #endif
164
165 /* eof */
166