CoCalc -- matrix.h

GAP 4.8.9 installation with standard packages -- copy to your CoCalc project to get it
gap4r8 / pkg / carat / carat-2.1b1 / include / matrix.h
⁵⁶³⁵¹⁶ views
1
#ifdef __cplusplus
2
extern "C" {
3
#endif
4

5

6

7

8

9
#ifndef _MATRIX_H_
10
#define _MATRIX_H_
11

12
#ifndef _CARAT_TYPEDEF_H_
13
#include "typedef.h"
14
#endif
15

16
#ifdef __STDC__
17
/*--------------------------------------------------------------*\
18
| FILE add_mat.c 
19
\*--------------------------------------------------------------*/
20
extern matrix_TYP *imat_add (matrix_TYP *L_mat, matrix_TYP *R_mat,
21
     int Lc, int Rc);
22
extern matrix_TYP *imat_addeq (matrix_TYP *L_mat, matrix_TYP *R_mat,
23
     int Lc, int Rc);
24
extern matrix_TYP *rmat_addeq (matrix_TYP *L_mat, matrix_TYP *R_mat,
25
     rational L_coeff, rational R_coeff);
26
extern matrix_TYP *rmat_addeq (matrix_TYP *L_mat, matrix_TYP *R_mat,
27
     rational L_coeff, rational R_coeff);
28
extern matrix_TYP *pmat_add (matrix_TYP *L_mat, matrix_TYP *R_mat,
29
     int L_coeff, int R_coeff);
30
extern matrix_TYP *pmat_addeq (matrix_TYP *L_mat, matrix_TYP *R_mat,
31
     int L_coeff, int R_coeff);
32
extern matrix_TYP *mat_add (matrix_TYP *L_mat, matrix_TYP *R_mat,
33
     rational L_coeff, rational R_coeff);
34
extern matrix_TYP *mat_addeq (matrix_TYP *L_mat, matrix_TYP *R_mat,
35
     rational L_coeff, rational R_coeff);
36

37
/*--------------------------------------------------------------*\
38
| FILE col_row_ops_mat.c 
39
\*--------------------------------------------------------------*/
40
extern void row_per(matrix_TYP *M, int i, int j);
41
extern void col_per(matrix_TYP *M, int i, int j);
42
extern void row_add(matrix_TYP *M, int i, int j, int fac);
43
extern void col_add(matrix_TYP *M, int i, int j, int fac);
44
extern void row_mul(matrix_TYP *M, int i, int fac);
45
extern void col_mul(matrix_TYP *M, int i, int fac);
46

47
/*--------------------------------------------------------------*\
48
| FILE comp_mat.c 
49
\*--------------------------------------------------------------*/
50
extern int cmp_mat(matrix_TYP *A, matrix_TYP *B);
51

52
/*--------------------------------------------------------------*\
53
| FILE divide_by_gcd.c 
54
\*--------------------------------------------------------------*/
55
extern int divide_by_gcd(matrix_TYP *A);
56

57
/*--------------------------------------------------------------*\
58
| FILE construct_mat.c 
59
\*--------------------------------------------------------------*/
60
extern matrix_TYP *init_mat(int rows, int cols, char *option);
61
extern matrix_TYP *copy_mat( matrix_TYP *old );
62
extern void free_mat (matrix_TYP *mat);
63
extern void Check_mat(matrix_TYP *mat);
64

65
/*--------------------------------------------------------------*\
66
| FILE elt_div_mat.c 
67
\*--------------------------------------------------------------*/
68
extern matrix_TYP *elt_div(matrix_TYP *Mat);
69

70
/*--------------------------------------------------------------*\
71
| FILE find_max_entry_mat.c 
72
\*--------------------------------------------------------------*/
73
extern int find_max_entry(matrix_TYP *mat);
74

75
/*--------------------------------------------------------------*\
76
| FILE gauss_mat.c 
77
\*--------------------------------------------------------------*/
78
extern int tgauss(matrix_TYP *mat);
79
extern int row_gauss(matrix_TYP *M);
80
extern matrix_TYP *ggauss(matrix_TYP *mat);
81

82
/************************************************************************\
83
|  FILE: hnf_mat.c
84
\************************************************************************/
85
extern int row_hnf_mat_trf(matrix_TYP *Mat, matrix_TYP *T);
86
extern int row_hnf_mat_simultaneous(matrix_TYP *Mat, matrix_TYP *T);
87
extern int row_hnf_mat(matrix_TYP *Mat);
88
extern int col_hnf_mat_trf(matrix_TYP *Mat, matrix_TYP *T);
89
extern int col_hnf_mat_simultaneous(matrix_TYP *Mat, matrix_TYP *T);
90
extern int col_hnf_mat(matrix_TYP *Mat);
91

92
/*--------------------------------------------------------------*\
93
| FILE inv_mat.c 
94
\*--------------------------------------------------------------*/
95
extern matrix_TYP *pmat_inv (matrix_TYP *mat);
96
extern matrix_TYP *mat_inv(matrix_TYP *mat);
97

98
/*--------------------------------------------------------------*\
99
| FILE kernel_mat.c 
100
\*--------------------------------------------------------------*/
101
extern matrix_TYP kernel_mat(matrix_TYP *mat);
102

103
/*--------------------------------------------------------------*\
104
| FILE kgv2rat_mat.c 
105
\*--------------------------------------------------------------*/
106
extern int kgv2rat( matrix_TYP *mat );
107
extern int rat2kgv( matrix_TYP *mat );
108

109
/*--------------------------------------------------------------*\
110
| FILE kron_mat.c
111
\*--------------------------------------------------------------*/
112
extern matrix_TYP *kron_mat(matrix_TYP *A, matrix_TYP *B);
113

114
/*--------------------------------------------------------------*\
115
| FILE modp_mat.c
116
\*--------------------------------------------------------------*/
117
extern void modp_mat(matrix_TYP *M, int prime);
118

119
/*--------------------------------------------------------------*\
120
| FILE mul_mat.c 
121
\*--------------------------------------------------------------*/
122
extern matrix_TYP *pmat_mul (matrix_TYP *L_mat, matrix_TYP * R_mat);
123
extern matrix_TYP *mat_mul (matrix_TYP *L_mat, matrix_TYP * R_mat);
124
extern matrix_TYP *mat_muleq(matrix_TYP *L_mat, matrix_TYP *R_mat);
125
extern matrix_TYP *mat_kon(matrix_TYP *L_mat, matrix_TYP *M_mat,
126
     matrix_TYP *R_mat);
127

128
/*--------------------------------------------------------------*\
129
| FILE null_mat.c 
130
\*--------------------------------------------------------------*/
131
extern int null_mat(matrix_TYP *mat);
132
extern int save_null_mat(matrix_TYP *mat);
133
extern int quick_null_mat(matrix_TYP *mat);
134

135
/*--------------------------------------------------------------*\
136
| FILE p_mat_det.c 
137
\*--------------------------------------------------------------*/
138
extern int p_mat_det(matrix_TYP *M, int prime);
139

140
/*--------------------------------------------------------------*\
141
| FILE p_gauss_mat.c 
142
\*--------------------------------------------------------------*/
143
extern int p_gauss (matrix_TYP *L_mat);
144

145
/*--------------------------------------------------------------*\
146
| FILE p_lse_solve.c 
147
\*--------------------------------------------------------------*/
148
extern matrix_TYP **p_lse_solve(matrix_TYP *A, matrix_TYP *B, int *anz, int p);
149

150
/*--------------------------------------------------------------*\
151
| FILE p_solve_mat.c 
152
\*--------------------------------------------------------------*/
153
extern matrix_TYP **p_solve (int *anz, matrix_TYP **L_mat, matrix_TYP **R_mat,
154
                      int option);
155

156
/*--------------------------------------------------------------*\
157
| FILE real_mat.c 
158
\*--------------------------------------------------------------*/
159
extern void real_mat(matrix_TYP *mat, int rows, int cols);
160

161
/*--------------------------------------------------------------*\
162
| FILE red_mat.c 
163
\*--------------------------------------------------------------*/
164
extern matrix_TYP *mat_red(matrix_TYP *Mat);
165
extern void dec_mat(matrix_TYP *Mat, matrix_TYP *Trf);
166

167
/*--------------------------------------------------------------*\
168
| FILE scal_pr_mat.c 
169
\*--------------------------------------------------------------*/
170
extern matrix_TYP *scal_pr ( matrix_TYP *vectors, matrix_TYP *form,
171
     boolean truth );
172

173
/*--------------------------------------------------------------*\
174
| FILE solve_mat.c 
175
\*--------------------------------------------------------------*/
176
extern int Trf_gauss(matrix_TYP *M, matrix_TYP *Trf);
177
extern matrix_TYP *solve_mat(matrix_TYP *M);
178

179
/*--------------------------------------------------------------*\
180
| FILE tools_mat.c 
181
\*--------------------------------------------------------------*/
182
extern boolean iset_entry(matrix_TYP *mat, int r, int c, int v);
183
extern boolean rset_entry(matrix_TYP *mat, int r, int c, rational v);
184
extern void iscal_mul(matrix_TYP *mat, int v);
185
extern void rscal_mul(matrix_TYP *mat, rational v);
186
extern boolean kill_row(matrix_TYP *mat, int row);
187
extern boolean kill_col(matrix_TYP *mat, int col);
188
extern boolean ins_row(matrix_TYP *mat, int row);
189
extern boolean ins_col(matrix_TYP *mat,  int col);
190
extern boolean imul_row(matrix_TYP *mat, int row, int v);
191
extern boolean rmul_row(matrix_TYP *mat, int row, rational v);
192
extern boolean imul_col(matrix_TYP *mat, int col, int v);
193
extern boolean rmul_col( matrix_TYP *mat, int col, rational v);
194
extern boolean iadd_row(matrix_TYP *mat,int t_row, int d_row, int v);
195
extern boolean radd_row(matrix_TYP *mat, int t_row, int d_row, rational v);
196
extern boolean iadd_col(matrix_TYP *mat, int t_col, int d_col, int v);
197
extern boolean radd_col(matrix_TYP *mat, int t_col, int d_col, rational v);
198
extern void normal_rows(matrix_TYP *mat);
199
extern void normal_cols(matrix_TYP *mat);
200
extern matrix_TYP *mat_to_line(matrix_TYP **gen, int num);
201
extern matrix_TYP **line_to_mat(matrix_TYP *mat, int row, int col);
202
extern int normal_mat(matrix_TYP *mat);
203

204
/*--------------------------------------------------------------*\
205
| FILE tr_pose_mat.c 
206
\*--------------------------------------------------------------*/
207
extern matrix_TYP *tr_pose(matrix_TYP *mat);
208

209
/*--------------------------------------------------------------*\
210
| FILE trace_mat.c 
211
\*--------------------------------------------------------------*/
212
extern int trace( matrix_TYP *mat);
213

214
/*--------------------------------------------------------------*\
215
| FILE unity_mat.c
216
\*--------------------------------------------------------------*/
217
extern matrix_TYP *einheitsmatrix( int n);
218

219
#else
220
/*--------------------------------------------------------------*\
221
| FILE add_mat.c 
222
\*--------------------------------------------------------------*/
223
extern matrix_TYP *imat_add ();
224
extern matrix_TYP *imat_addeq ();
225
extern matrix_TYP *rmat_addeq ();
226
extern matrix_TYP *rmat_addeq ();
227
extern matrix_TYP *pmat_add ();
228
extern matrix_TYP *pmat_addeq ();
229
extern matrix_TYP *mat_add ();
230
extern matrix_TYP *mat_addeq ();
231

232
/*--------------------------------------------------------------*\
233
| FILE col_row_ops_mat.c 
234
\*--------------------------------------------------------------*/
235
extern void row_per();
236
extern void col_per();
237
extern void row_add();
238
extern void col_add();
239
extern void row_mul();
240
extern void col_mul();
241

242
/*--------------------------------------------------------------*\
243
| FILE comp_mat.c 
244
\*--------------------------------------------------------------*/
245
extern int cmp_mat();
246

247
/*--------------------------------------------------------------*\
248
| FILE divide_by_gcd.c 
249
\*--------------------------------------------------------------*/
250
extern int divide_by_gcd();
251

252
/*--------------------------------------------------------------*\
253
| FILE construct_mat.c 
254
\*--------------------------------------------------------------*/
255
extern matrix_TYP *init_mat();
256
extern matrix_TYP *copy_mat();
257
extern void free_mat ();
258
extern void Check_mat();
259

260
/*--------------------------------------------------------------*\
261
| FILE elt_div_mat.c 
262
\*--------------------------------------------------------------*/
263
extern matrix_TYP *elt_div();
264

265
/*--------------------------------------------------------------*\
266
| FILE find_max_entry_mat.c 
267
\*--------------------------------------------------------------*/
268
extern int find_max_entry();
269

270
/*--------------------------------------------------------------*\
271
| FILE gauss_mat.c 
272
\*--------------------------------------------------------------*/
273
extern int tgauss();
274
extern int row_gauss();
275
extern matrix_TYP *ggauss();
276

277
/************************************************************************\
278
|  FILE: hnf_mat.c
279
\************************************************************************/
280
extern int row_hnf_mat_trf();
281
extern int row_hnf_mat_simultaneous();
282
extern int row_hnf_mat();
283
extern int col_hnf_mat_trf();
284
extern int col_hnf_mat_simultaneous();
285
extern int col_hnf_mat();
286

287
/*--------------------------------------------------------------*\
288
| FILE inv_mat.c 
289
\*--------------------------------------------------------------*/
290
extern matrix_TYP *pmat_inv ();
291
extern matrix_TYP *mat_inv();
292

293
/*--------------------------------------------------------------*\
294
| FILE kernel_mat.c 
295
\*--------------------------------------------------------------*/
296
extern matrix_TYP kernel_mat();
297

298
/*--------------------------------------------------------------*\
299
| FILE kgv2rat_mat.c 
300
\*--------------------------------------------------------------*/
301
extern int kgv2rat();
302
extern int rat2kgv();
303

304
/*--------------------------------------------------------------*\
305
| FILE kron_mat.c
306
\*--------------------------------------------------------------*/
307
extern matrix_TYP *kron_mat();
308

309
/*--------------------------------------------------------------*\
310
| FILE modp_mat.c
311
\*--------------------------------------------------------------*/
312
extern void modp_mat();
313

314
/*--------------------------------------------------------------*\
315
| FILE mul_mat.c 
316
\*--------------------------------------------------------------*/
317
extern matrix_TYP *pmat_mul ();
318
extern matrix_TYP *mat_mul ();
319
extern matrix_TYP *mat_muleq();
320
extern matrix_TYP *mat_kon();
321

322
/*--------------------------------------------------------------*\
323
| FILE null_mat.c 
324
\*--------------------------------------------------------------*/
325
extern int null_mat();
326
extern int save_null_mat();
327
extern int quick_null_mat();
328

329
/*--------------------------------------------------------------*\
330
| FILE p_mat_det.c 
331
\*--------------------------------------------------------------*/
332
extern int p_mat_det();
333

334
/*--------------------------------------------------------------*\
335
| FILE p_gauss_mat.c 
336
\*--------------------------------------------------------------*/
337
extern int p_gauss ();
338

339
/*--------------------------------------------------------------*\
340
| FILE p_lse_solve.c 
341
\*--------------------------------------------------------------*/
342
extern matrix_TYP **p_lse_solve();
343

344
/*--------------------------------------------------------------*\
345
| FILE p_solve_mat.c 
346
\*--------------------------------------------------------------*/
347
extern matrix_TYP **p_solve ();
348

349
/*--------------------------------------------------------------*\
350
| FILE real_mat.c 
351
\*--------------------------------------------------------------*/
352
extern void real_mat();
353

354
/*--------------------------------------------------------------*\
355
| FILE red_mat.c 
356
\*--------------------------------------------------------------*/
357
extern matrix_TYP *mat_red();
358
extern void dec_mat();
359

360
/*--------------------------------------------------------------*\
361
| FILE scal_pr_mat.c 
362
\*--------------------------------------------------------------*/
363
extern matrix_TYP *scal_pr ();
364

365
/*--------------------------------------------------------------*\
366
| FILE solve_mat.c 
367
\*--------------------------------------------------------------*/
368
extern int Trf_gauss();
369
extern matrix_TYP *solve_mat();
370

371
/*--------------------------------------------------------------*\
372
| FILE tools_mat.c 
373
\*--------------------------------------------------------------*/
374
extern boolean iset_entry();
375
extern boolean rset_entry();
376
extern void iscal_mul();
377
extern void rscal_mul();
378
extern boolean kill_row();
379
extern boolean kill_col();
380
extern boolean ins_row();
381
extern boolean ins_col();
382
extern boolean imul_row();
383
extern boolean rmul_row();
384
extern boolean imul_col();
385
extern boolean rmul_col();
386
extern boolean iadd_row();
387
extern boolean radd_row();
388
extern boolean iadd_col();
389
extern boolean radd_col();
390
extern void normal_rows();
391
extern void normal_cols();
392
extern matrix_TYP *mat_to_line();
393
extern matrix_TYP **line_to_mat();
394
extern int normal_mat();
395

396
/*--------------------------------------------------------------*\
397
| FILE tr_pose_mat.c 
398
\*--------------------------------------------------------------*/
399
extern matrix_TYP *tr_pose();
400

401
/*--------------------------------------------------------------*\
402
| FILE trace_mat.c 
403
\*--------------------------------------------------------------*/
404
extern int trace();
405

406
/*--------------------------------------------------------------*\
407
| FILE unity_mat.c
408
\*--------------------------------------------------------------*/
409
extern matrix_TYP *einheitsmatrix();
410

411
#endif
412
#endif
413

414

415
#ifdef __cplusplus
416
}
417
#endif
418

419

420
Product

Resources

Company
