lemon-project-template-glpk
comparison deps/glpk/src/glpspm.h @ 11:4fc6ad2fb8a6
Test GLPK in src/main.cc
author | Alpar Juttner <alpar@cs.elte.hu> |
---|---|
date | Sun, 06 Nov 2011 21:43:29 +0100 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:cdc586b9a537 |
---|---|
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, 2011 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 | |
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 | |
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 | |
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); | |
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); | |
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); | |
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 | |
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 */ |