GRASS Programmer's Manual
6.4.2(2012)
Main Page
Related Pages
Namespaces
Data Structures
Files
File List
Globals
All
Data Structures
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Pages
N_les.c
Go to the documentation of this file.
1
2
/*****************************************************************************
3
*
4
* MODULE: Grass PDE Numerical Library
5
* AUTHOR(S): Soeren Gebbert, Berlin (GER) Dec 2006
6
* soerengebbert <at> gmx <dot> de
7
*
8
* PURPOSE: functions to manage linear equation systems
9
* part of the gpde library
10
*
11
* COPYRIGHT: (C) 2000 by the GRASS Development Team
12
*
13
* This program is free software under the GNU General Public
14
* License (>=v2). Read the file COPYING that comes with GRASS
15
* for details.
16
*
17
*****************************************************************************/
18
19
#include "grass/N_pde.h"
20
#include <stdlib.h>
21
29
N_spvector
*
N_alloc_spvector
(
int
cols
)
30
{
31
N_spvector
*spvector;
32
33
G_debug
(4,
"Allocate memory for a sparse vector with %i cols\n"
, cols);
34
35
spvector = (
N_spvector
*) G_calloc(1,
sizeof
(
N_spvector
));
36
37
spvector->
cols
=
cols
;
38
spvector->
index
= (
int
*)G_calloc(cols,
sizeof
(
int
));
39
spvector->
values
= (
double
*)G_calloc(cols,
sizeof
(
double
));
40
41
return
spvector;
42
}
43
55
N_les
*
N_alloc_nquad_les
(
int
cols
,
int
rows,
int
type
)
56
{
57
return
N_alloc_les_param
(cols, rows, type, 2);
58
}
59
71
N_les
*
N_alloc_nquad_les_Ax
(
int
cols
,
int
rows,
int
type
)
72
{
73
return
N_alloc_les_param
(cols, rows, type, 1);
74
}
75
87
N_les
*
N_alloc_nquad_les_A
(
int
cols
,
int
rows,
int
type
)
88
{
89
return
N_alloc_les_param
(cols, rows, type, 0);
90
}
91
103
N_les
*
N_alloc_nquad_les_Ax_b
(
int
cols
,
int
rows,
int
type
)
104
{
105
return
N_alloc_les_param
(cols, rows, type, 2);
106
}
107
108
109
120
N_les
*
N_alloc_les
(
int
rows,
int
type
)
121
{
122
return
N_alloc_les_param
(rows, rows, type, 2);
123
}
124
135
N_les
*
N_alloc_les_Ax
(
int
rows,
int
type
)
136
{
137
return
N_alloc_les_param
(rows, rows, type, 1);
138
}
139
150
N_les
*
N_alloc_les_A
(
int
rows,
int
type
)
151
{
152
return
N_alloc_les_param
(rows, rows, type, 0);
153
}
154
165
N_les
*
N_alloc_les_Ax_b
(
int
rows,
int
type
)
166
{
167
return
N_alloc_les_param
(rows, rows, type, 2);
168
}
169
170
198
N_les
*
N_alloc_les_param
(
int
cols
,
int
rows,
int
type
,
int
parts)
199
{
200
N_les
*les;
201
int
i;
202
203
if
(type ==
N_SPARSE_LES
)
204
G_debug
(2,
205
"Allocate memory for a sparse linear equation system with %i rows\n"
,
206
rows);
207
else
208
G_debug
(2,
209
"Allocate memory for a regular linear equation system with %i rows\n"
,
210
rows);
211
212
les = (
N_les
*) G_calloc(1,
sizeof
(
N_les
));
213
214
if
(parts > 0) {
215
les->
x
= (
double
*)G_calloc(cols,
sizeof
(
double
));
216
for
(i = 0; i <
cols
; i++)
217
les->
x
[i] = 0.0;
218
}
219
220
221
if
(parts > 1) {
222
les->
b
= (
double
*)G_calloc(cols,
sizeof
(
double
));
223
for
(i = 0; i <
cols
; i++)
224
les->
b
[i] = 0.0;
225
}
226
227
les->
A
=
NULL
;
228
les->
Asp
=
NULL
;
229
les->
rows
= rows;
230
les->
cols
=
cols
;
231
if
(rows == cols)
232
les->
quad
= 1;
233
else
234
les->
quad
= 0;
235
236
if
(type ==
N_SPARSE_LES
) {
237
les->
Asp
= (
N_spvector
**) G_calloc(rows,
sizeof
(
N_spvector
*));
238
les->
type
=
N_SPARSE_LES
;
239
}
240
else
{
241
les->
A
= (
double
**)G_calloc(rows,
sizeof
(
double
*));
242
for
(i = 0; i < rows; i++) {
243
les->
A
[i] = (
double
*)G_calloc(cols,
sizeof
(
double
));
244
}
245
les->
type
=
N_NORMAL_LES
;
246
}
247
248
return
les;
249
}
250
251
263
int
N_add_spvector_to_les
(
N_les
* les,
N_spvector
* spvector,
int
row)
264
{
265
266
267
if
(les !=
NULL
) {
268
if
(les->
type
!=
N_SPARSE_LES
)
269
return
-1;
270
271
if
(les->
rows
> row) {
272
G_debug
(5,
273
"Add sparse vector %p to the sparse linear equation system at row %i\n"
,
274
spvector, row);
275
les->
Asp
[row] = spvector;
276
}
277
else
278
return
-1;
279
280
}
281
else
{
282
return
-1;
283
}
284
285
286
return
1;
287
}
288
312
void
N_print_les
(
N_les
* les)
313
{
314
int
i, j, k, out;
315
316
317
if
(les->
type
==
N_SPARSE_LES
) {
318
for
(i = 0; i < les->
rows
; i++) {
319
for
(j = 0; j < les->
cols
; j++) {
320
out = 0;
321
for
(k = 0; k < les->
Asp
[i]->
cols
; k++) {
322
if
(les->
Asp
[i]->
index
[k] == j) {
323
fprintf(stdout,
"%4.5f "
, les->
Asp
[i]->
values
[k]);
324
out = 1;
325
}
326
}
327
if
(!out)
328
fprintf(stdout,
"%4.5f "
, 0.0);
329
}
330
if
(les->
x
)
331
fprintf(stdout,
" * %4.5f"
, les->
x
[i]);
332
if
(les->
b
)
333
fprintf(stdout,
" = %4.5f "
, les->
b
[i]);
334
335
fprintf(stdout,
"\n"
);
336
}
337
}
338
else
{
339
340
for
(i = 0; i < les->
rows
; i++) {
341
for
(j = 0; j < les->
cols
; j++) {
342
fprintf(stdout,
"%4.5f "
, les->
A
[i][j]);
343
}
344
if
(les->
x
)
345
fprintf(stdout,
" * %4.5f"
, les->
x
[i]);
346
if
(les->
b
)
347
fprintf(stdout,
" = %4.5f "
, les->
b
[i]);
348
349
fprintf(stdout,
"\n"
);
350
}
351
352
}
353
return
;
354
}
355
363
void
N_free_spvector
(
N_spvector
* spvector)
364
{
365
if
(spvector) {
366
if
(spvector->
values
)
367
G_free
(spvector->
values
);
368
if
(spvector->
index
)
369
G_free
(spvector->
index
);
370
G_free
(spvector);
371
372
spvector =
NULL
;
373
}
374
375
return
;
376
}
377
378
387
void
N_free_les
(
N_les
* les)
388
{
389
int
i;
390
391
if
(les->
type
==
N_SPARSE_LES
)
392
G_debug
(2,
"Releasing memory of a sparse linear equation system\n"
);
393
else
394
G_debug
(2,
"Releasing memory of a regular linear equation system\n"
);
395
396
if
(les) {
397
398
if
(les->
x
)
399
G_free
(les->
x
);
400
if
(les->
b
)
401
G_free
(les->
b
);
402
403
if
(les->
type
==
N_SPARSE_LES
) {
404
405
if
(les->
Asp
) {
406
for
(i = 0; i < les->
rows
; i++)
407
if
(les->
Asp
[i])
408
N_free_spvector
(les->
Asp
[i]);
409
410
G_free
(les->
Asp
);
411
}
412
}
413
else
{
414
415
if
(les->
A
) {
416
for
(i = 0; i < les->
rows
; i++)
417
if
(les->
A
[i])
418
G_free
(les->
A
[i]);
419
420
G_free
(les->
A
);
421
}
422
}
423
424
free(les);
425
}
426
427
return
;
428
}
lib
gpde
N_les.c
Generated on Wed Jun 6 2012 14:04:26 for GRASS Programmer's Manual by
1.8.1