GRASS Programmer's Manual  6.4.4(2014)-r
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 
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 }
N_les * N_alloc_nquad_les_Ax(int cols, int rows, int type)
Allocate memory for a (not) quadratic linear equation system which includes the Matrix A and vector x...
Definition: N_les.c:71
void G_free(void *buf)
Free allocated memory.
Definition: gis/alloc.c:142
#define NULL
Definition: strings.c:26
int quad
Definition: N_pde.h:104
N_les * N_alloc_nquad_les(int cols, int rows, int type)
Allocate memory for a (not) quadratic linear equation system which includes the Matrix A...
Definition: N_les.c:55
N_les * N_alloc_les_Ax_b(int rows, int type)
Allocate memory for a quadratic linear equation system which includes the Matrix A, vector x and vector b.
Definition: N_les.c:165
N_les * N_alloc_les(int rows, int type)
Allocate memory for a quadratic linear equation system which includes the Matrix A, vector x and vector b.
Definition: N_les.c:120
#define N_SPARSE_LES
Definition: N_pde.h:42
int cols
Definition: N_pde.h:81
double * x
Definition: N_pde.h:98
The row vector of the sparse matrix.
Definition: N_pde.h:79
N_les * N_alloc_nquad_les_A(int cols, int rows, int type)
Allocate memory for a (not) quadratic linear equation system which includes the Matrix A...
Definition: N_les.c:87
double ** A
Definition: N_pde.h:100
int * index
Definition: N_pde.h:83
void N_free_spvector(N_spvector *spvector)
Release the memory of the sparse vector.
Definition: N_les.c:363
N_spvector * N_alloc_spvector(int cols)
Allocate memory for a sparse vector.
Definition: N_les.c:29
N_les * N_alloc_les_param(int cols, int rows, int type, int parts)
Allocate memory for a quadratic or not quadratic linear equation system.
Definition: N_les.c:198
double * values
Definition: N_pde.h:82
N_les * N_alloc_les_A(int rows, int type)
Allocate memory for a quadratic linear equation system which includes the Matrix A.
Definition: N_les.c:150
int cols
Definition: N_pde.h:103
tuple cols
N_les * N_alloc_nquad_les_Ax_b(int cols, int rows, int type)
Allocate memory for a (not) quadratic linear equation system which includes the Matrix A...
Definition: N_les.c:103
int G_debug(int level, const char *msg,...)
Print debugging message.
Definition: gis/debug.c:51
N_les * N_alloc_les_Ax(int rows, int type)
Allocate memory for a quadratic linear equation system which includes the Matrix A and vector x...
Definition: N_les.c:135
void free(void *)
double * b
Definition: N_pde.h:99
#define N_NORMAL_LES
Definition: N_pde.h:41
int rows
Definition: N_pde.h:102
void N_free_les(N_les *les)
Release the memory of the linear equation system.
Definition: N_les.c:387
The linear equation system (les) structure.
Definition: N_pde.h:96
N_spvector ** Asp
Definition: N_pde.h:101
int type
Definition: N_pde.h:105
void N_print_les(N_les *les)
prints the linear equation system to stdout
Definition: N_les.c:312
int N_add_spvector_to_les(N_les *les, N_spvector *spvector, int row)
Adds a sparse vector to a sparse linear equation system at position row.
Definition: N_les.c:263