← Back to branch summary

~ubuntu-branches/debian/jessie/eso-midas/jessie

« back to all changes in this revision

Viewing changes to stdred/feros/libsrc/nrutil.c

  • Committer: Package Import Robot
  • Author(s): Ole Streicher
  • Date: 2014-04-22 14:44:58 UTC
  • Revision ID: package-import@ubuntu.com-20140422144458-okiwi1assxkkiz39
Tags: upstream-13.09pl1.2+dfsg
Import upstream version 13.09pl1.2+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
stdred/feros/libsrc/nrutil.c
 
1
/* 
 
2
 
 
3
   Pascal Ballester (ESO/Garching)           
 
4
   Cristian Levin   (ESO/La Silla)          
 
5
 
 
6
   nrutil.c
 
7
   
 
8
   various routines from Numerical Recipes
 
9
 
 
10
*/
 
11
 
 
12
/*
 
13
 
 
14
.VERSION
 
15
051021          last modif
 
16
 
 
17
*/
 
18
 
 
19
/* system includes */
 
20
 
 
21
#include <stdio.h>
 
22
#include <stdlib.h>
 
23
 
 
24
void nrerror
 
25
#ifdef __STDC__ 
 
26
( 
 
27
 char error_text[]
 
28
 )
 
29
#else
 
30
     (
 
31
      error_text
 
32
      )
 
33
     char error_text[];
 
34
#endif
 
35
 
 
36
{
 
37
 
 
38
#ifdef __STDC__
 
39
  void exit(int);
 
40
#endif
 
41
 
 
42
  fprintf(stderr,"Numerical Recipes run-time error...\n");
 
43
  return;
 
44
}
 
45
 
 
46
/* functions of the OSMEMORY module of the Midas system library */
 
47
 
 
48
char *osmmget 
 
49
(
 
50
#ifdef __STDC__
 
51
 unsigned int
 
52
#endif
 
53
 );
 
54
 
 
55
void osmmfree
 
56
(
 
57
#ifdef __STDC__
 
58
 char *
 
59
#endif
 
60
 );
 
61
 
 
62
int **imatrix
 
63
#ifdef __STDC__
 
64
( 
 
65
 int nrl, int nrh, int ncl, int nch 
 
66
 ) 
 
67
#else
 
68
     ( 
 
69
      nrl, nrh, ncl, nch 
 
70
      ) 
 
71
     int nrl, nrh, ncl, nch;
 
72
#endif
 
73
     /* Allocates a int matrix with range [nrl..nrh][ncl..nch] */
 
74
{
 
75
  int i;
 
76
  int **m;
 
77
 
 
78
  /* Allocate pointers to rows */
 
79
  m = (int **)osmmget( (unsigned) (nrh-nrl+1) * sizeof(int *) );
 
80
  m -= nrl;
 
81
 
 
82
  /* Allocate rows and set pointers to them */
 
83
  for ( i = nrl; i <= nrh; i++ ) {
 
84
    m[i] = (int *)osmmget( (unsigned) (nch-ncl+1) * sizeof(int) );
 
85
    m[i] -= ncl;
 
86
  }
 
87
  return (m);
 
88
}
 
89
 
 
90
void free_imatrix
 
91
#ifdef __STDC__
 
92
( 
 
93
 int **m, int nrl, int nrh, int ncl 
 
94
 ) 
 
95
#else
 
96
     ( 
 
97
      m, nrl, nrh, ncl 
 
98
      ) 
 
99
     int **m,nrl,nrh,ncl;
 
100
#endif 
 
101
     /* Frees a matrix allocated with imatrix() */
 
102
 
 
103
{
 
104
  int i;
 
105
 
 
106
  for ( i = nrh; i >= nrl; i-- )
 
107
    osmmfree( (char *) (m[i] + ncl) );
 
108
 
 
109
  osmmfree( (char *) (m + nrl) );
 
110
}
 
111
 
 
112
int *ivector
 
113
#ifdef __STDC__
 
114
( 
 
115
 int nl, int nh 
 
116
 ) 
 
117
#else
 
118
     (
 
119
      nl, nh 
 
120
      ) 
 
121
     int nl, nh;
 
122
#endif
 
123
     /* Allocates a int vector with range [nl..nh] */
 
124
{
 
125
  int *v;
 
126
 
 
127
  v = (int *)osmmget( (unsigned) (nh-nl+1) * sizeof(int) );
 
128
  return( v - nl );
 
129
}
 
130
 
 
131
void free_ivector
 
132
#ifdef __STDC__
 
133
( 
 
134
 int *v, int nl 
 
135
 ) 
 
136
#else
 
137
     ( 
 
138
      v, nl 
 
139
      ) 
 
140
     int *v,nl;
 
141
#endif
 
142
     /* Frees a vector allocated with ivector() */
 
143
{
 
144
  osmmfree( (char *) (v + nl) );
 
145
}
 
146
 
 
147
double **dmatrix
 
148
#ifdef __STDC__
 
149
( 
 
150
 int nrl, int nrh, int ncl, int nch 
 
151
 ) 
 
152
#else
 
153
     (
 
154
      nrl, nrh, ncl, nch 
 
155
      ) 
 
156
     int nrl, nrh,ncl,nch;
 
157
#endif
 
158
     /* Allocates a double matrix with range [nrl..nrh][ncl..nch] */
 
159
{
 
160
  int i;
 
161
  double **m;
 
162
 
 
163
  /* Allocate pointers to rows */
 
164
  m = (double **)osmmget( (unsigned) (nrh-nrl+1) * sizeof(double *) );
 
165
  m -= nrl;
 
166
 
 
167
  /* Allocate rows and set pointers to them */
 
168
  for ( i = nrl; i <= nrh; i++ ) {
 
169
    m[i] = (double *)osmmget( (unsigned) (nch-ncl+1) * sizeof(double) );
 
170
    m[i] -= ncl;
 
171
  }
 
172
  return( m );
 
173
}
 
174
 
 
175
void free_dmatrix
 
176
#ifdef __STDC__
 
177
(
 
178
 double **m, int nrl, int nrh, int ncl, int nch 
 
179
 ) 
 
180
#else
 
181
     ( 
 
182
      m, nrl, nrh, ncl, nch 
 
183
      ) 
 
184
     double **m;
 
185
     int nrl,nrh,ncl,nch;
 
186
#endif
 
187
     /* Frees a matrix allocated with dmatrix() */
 
188
{
 
189
  int i;
 
190
 
 
191
  for ( i = nrh; i >= nrl; i-- )
 
192
    osmmfree( (char *) (m[i] + ncl) );
 
193
 
 
194
  osmmfree( (char *) (m + nrl) );
 
195
}
 
196
 
 
197
double *dvector
 
198
#ifdef __STDC__
 
199
( 
 
200
 int nl, int nh 
 
201
 ) 
 
202
#else
 
203
     (
 
204
      nl, nh 
 
205
      ) 
 
206
     int nl, nh;
 
207
#endif
 
208
     /* Allocates a double vector with range [nl..nh] */
 
209
{
 
210
  double *v;
 
211
 
 
212
  v = (double *)osmmget( (unsigned) (nh-nl+1) * sizeof(double) );
 
213
  return( v - nl );
 
214
}
 
215
 
 
216
void free_dvector
 
217
#ifdef __STDC__
 
218
( 
 
219
 double *v, int nl, int nh 
 
220
 ) 
 
221
#else
 
222
     (
 
223
      v, nl, nh 
 
224
      ) 
 
225
     double *v;
 
226
     int nl, nh;
 
227
#endif
 
228
     /* Frees a vector allocated with dvector() */
 
229
{
 
230
  osmmfree( (char *) (v + nl) );
 
231
}
 
232
 
 
233
float **fmatrix
 
234
#ifdef __STDC__
 
235
( 
 
236
 int nrl, int nrh, int ncl, int nch 
 
237
 ) 
 
238
#else
 
239
     ( 
 
240
      nrl, nrh, ncl, nch 
 
241
      ) 
 
242
     int nrl,nrh,ncl,nch;
 
243
#endif
 
244
     /* Allocates a float matrix with range [nrl..nrh][ncl..nch] */
 
245
{
 
246
  int i;
 
247
  float **m;
 
248
 
 
249
  /* Allocate pointers to rows */
 
250
  m = (float **)osmmget( (unsigned) (nrh-nrl+1) * sizeof(float *) );
 
251
  m -= nrl;
 
252
 
 
253
  /* Allocate rows and set pointers to them */
 
254
  for ( i = nrl; i <= nrh; i++ ) {
 
255
    m[i] = (float *)osmmget( (unsigned) (nch-ncl+1) * sizeof(float) );
 
256
    m[i] -= ncl;
 
257
  }
 
258
  return( m );
 
259
}
 
260
 
 
261
void free_fmatrix
 
262
#ifdef __STDC__
 
263
(
 
264
 float **m, int nrl, int nrh, int ncl, int nch 
 
265
 ) 
 
266
#else
 
267
     (
 
268
      m, nrl, nrh, ncl, nch 
 
269
      ) 
 
270
     float **m;
 
271
     int nrl,nrh,ncl,nch;
 
272
#endif
 
273
     /* Frees a matrix allocated with fmatrix() */
 
274
{
 
275
  int i;
 
276
 
 
277
  for ( i = nrh; i >= nrl; i-- )
 
278
    osmmfree( (char *) (m[i] + ncl) );
 
279
 
 
280
  osmmfree( (char *) (m + nrl) );
 
281
}
 
282
 
 
283
float *fvector
 
284
#ifdef __STDC__
 
285
( 
 
286
 int nl, int nh 
 
287
 ) 
 
288
#else
 
289
     ( 
 
290
      nl, nh 
 
291
      ) 
 
292
     int nl,nh;
 
293
#endif
 
294
     /* Allocates a float vector with range [nl..nh] */
 
295
{
 
296
  float *v;
 
297
 
 
298
  v = (float *)osmmget( (unsigned) (nh-nl+1) * sizeof(float) );
 
299
  return( v - nl );
 
300
}
 
301
 
 
302
 
 
303
void free_fvector
 
304
#ifdef __STDC__
 
305
( 
 
306
 float *v, int nl, int nh 
 
307
 ) 
 
308
#else
 
309
     (
 
310
      v, nl, nh 
 
311
      ) 
 
312
     float *v;
 
313
     int nl,nh;
 
314
#endif
 
315
     /* Frees a vector allocated with fvector() */
 
316
{
 
317
  osmmfree( (char *) (v + nl) );
 
318
}
 
319
 
 
320
char **cmatrix
 
321
#ifdef __STDC__
 
322
( 
 
323
 int nrl, int nrh, int ncl, int nch 
 
324
 ) 
 
325
#else
 
326
     ( 
 
327
      nrl, nrh, ncl, nch 
 
328
      ) 
 
329
     int nrl,nrh,ncl,nch;
 
330
#endif
 
331
     /* Allocates a char matrix with range [nrl..nrh][ncl..nch] */
 
332
{
 
333
  int i;
 
334
  char **m;
 
335
 
 
336
  /* Allocate pointers to rows */
 
337
  m = (char **)osmmget( (unsigned) (nrh-nrl+1) * sizeof(char *) );
 
338
  m -= nrl;
 
339
 
 
340
  /* Allocate rows and set pointers to them */
 
341
  for ( i = nrl; i <= nrh; i++ ) {
 
342
    m[i] = (char *)osmmget( (unsigned) (nch-ncl+1) * sizeof(char) );
 
343
    m[i] -= ncl;
 
344
  }
 
345
  return( m );
 
346
}
 
347
 
 
348
void free_cmatrix
 
349
#ifdef __STDC__
 
350
( 
 
351
 char **m, int nrl, int nrh, int ncl, int nch 
 
352
 ) 
 
353
#else
 
354
     ( 
 
355
      m, nrl, nrh, ncl, nch 
 
356
      ) 
 
357
     char **m;
 
358
     int nrl,nrh,ncl,nch;
 
359
#endif
 
360
     /* Frees a matrix allocated with cmatrix() */
 
361
{
 
362
  int i;
 
363
 
 
364
  for ( i = nrh; i >= nrl; i-- )
 
365
    osmmfree( (char *) (m[i] + ncl) );
 
366
 
 
367
  osmmfree( (char *) (m + nrl) );
 
368
}
 
369
 
 
370
char *cvector
 
371
#ifdef __STDC__
 
372
(
 
373
 int nl, int nh 
 
374
 ) 
 
375
#else
 
376
     ( 
 
377
      nl, nh 
 
378
      ) 
 
379
     int nl,nh;
 
380
#endif
 
381
     /* Allocates a char vector with range [nl..nh] */
 
382
{
 
383
  char *v;
 
384
 
 
385
  v = (char *)osmmget( (unsigned) (nh-nl+1) * sizeof(char) );
 
386
  return( v - nl );
 
387
}
 
388
 
 
389
void free_cvector
 
390
#ifdef __STDC__
 
391
( 
 
392
 char *v, int nl, int nh 
 
393
 ) 
 
394
#else
 
395
     (
 
396
      v, nl, nh 
 
397
      ) 
 
398
     char *v;
 
399
     int nl,nh;
 
400
#endif
 
401
     /* Frees a vector allocated with cvector() */
 
402
{
 
403
  osmmfree( (char *) (v + nl) );
 
404
}
 
405
 
 
406
 
 
407
float *vector
 
408
#ifdef __STDC__
 
409
(
 
410
 int nl, int nh
 
411
 )
 
412
#else
 
413
     (
 
414
      nl, nh
 
415
      )
 
416
     int nl, nh;
 
417
#endif
 
418
 
 
419
{
 
420
  float *v;
 
421
  
 
422
  v=(float *)malloc((size_t) (nh-nl+1)*sizeof(float));
 
423
  if (!v) nrerror("allocation failure in vector()");
 
424
  return v-nl;
 
425
}
 
426
 
 
427
void free_vector
 
428
#ifdef __STDC__
 
429
( 
 
430
 float *v, int nl, int nh
 
431
 )
 
432
#else
 
433
     (
 
434
      v,nl,nh
 
435
      )
 
436
     int *v,nl,nh;
 
437
#endif
 
438
 
 
439
{
 
440
  osmmfree((char*) (v+nl));
 
441
}
 
442
 
 
443
float **matrix
 
444
#ifdef __STDC__
 
445
(
 
446
 int nrl, int nrh, int ncl, int nch
 
447
 )
 
448
#else
 
449
     (
 
450
      nrl, nrh, ncl, nch
 
451
      )
 
452
     int nrl, nrh, ncl, nch;
 
453
#endif
 
454
 
 
455
{
 
456
  int i;
 
457
  float **m;
 
458
 
 
459
  m=(float **) malloc((size_t) (nrh-nrl+1)*sizeof(float*));
 
460
  if (!m) nrerror("allocation failure 1 in matrix()");
 
461
  m -= nrl;
 
462
 
 
463
  for(i=nrl;i<=nrh;i++) {
 
464
    m[i]=(float *) malloc((size_t) (nch-ncl+1)*sizeof(float));
 
465
    if (!m[i]) nrerror("allocation failure 2 in matrix()");
 
466
    m[i] -= ncl;
 
467
  }
 
468
  return m;
 
469
}
 
470
 
 
471
void free_matrix
 
472
#ifdef __STDC__
 
473
(
 
474
 float **m, int nrl, int nrh, int ncl, int nch
 
475
 )
 
476
#else
 
477
     (
 
478
      m,nrl,nrh,ncl,nch
 
479
      )
 
480
     float **m;
 
481
     int nrl,nrh,ncl,nch;
 
482
#endif
 
483
 
 
484
{
 
485
  int i;
 
486
 
 
487
  for(i=nrh;i>=nrl;i--) free((char*) (m[i]+ncl));
 
488
  free((char*) (m+nrl));
 
489
}
 
490
 
 
491
float **submatrix
 
492
#ifdef __STDC__
 
493
( 
 
494
 float **a, int oldrl, int oldrh, int oldcl,
 
495
 int oldch, int newrl, int newcl
 
496
 )
 
497
#else
 
498
     (
 
499
      a,oldrl,oldrh,oldcl,oldch,newrl,newcl
 
500
      )
 
501
     float **a;
 
502
     int oldrl,oldrh,oldcl,oldch,newrl,newcl;
 
503
#endif
 
504
 
 
505
{
 
506
  int i,j;
 
507
  float **m;
 
508
 
 
509
  m=(float **) malloc((size_t) (oldrh-oldrl+1)*sizeof(float*));
 
510
  if (!m) nrerror("allocation failure in submatrix()");
 
511
  m -= newrl;
 
512
 
 
513
  for(i=oldrl,j=newrl;i<=oldrh;i++,j++) m[j]=a[i]+oldcl-newcl;
 
514
 
 
515
  return m;
 
516
}
 
517
 
 
518
void free_submatrix
 
519
#ifdef __STDC__
 
520
(
 
521
 float **b, int nrl, int nrh, int ncl, int nch
 
522
 )
 
523
#else
 
524
     (
 
525
      b,nrl,nrh,ncl,nch
 
526
      )
 
527
     float **b;
 
528
     int nrl,nrh,ncl,nch;
 
529
#endif
 
530
 
 
531
{
 
532
  osmmfree((char*) (b+nrl));
 
533
}
 
534
 
 
535
float **convert_matrix
 
536
#ifdef __STDC__
 
537
(
 
538
 float *a, int nrl, int nrh, int ncl, int nch
 
539
 )
 
540
#else
 
541
     (
 
542
      a,nrl,nrh,ncl,nch
 
543
      )
 
544
     float *a;
 
545
     int nrl,nrh,ncl,nch;
 
546
#endif
 
547
 
 
548
{
 
549
  int i,j,nrow,ncol;
 
550
  float **m;
 
551
 
 
552
  nrow=nrh-nrl+1;
 
553
  ncol=nch-ncl+1;
 
554
  m = (float **) malloc((size_t) (nrow)*sizeof(float*));
 
555
  if (!m) nrerror("allocation failure in convert_matrix()");
 
556
  m -= nrl;
 
557
  for(i=0,j=nrl;i<=nrow-1;i++,j++) m[j]=a+ncol*i-ncl;
 
558
  return m;
 
559
}
 
560
 
 
561
void free_convert_matrix
 
562
#ifdef __STDC__
 
563
(
 
564
 float **b, int nrl, int nrh, int ncl, int nch
 
565
 )
 
566
#else
 
567
     (
 
568
      b,nrl,nrh,ncl,nch
 
569
      )
 
570
     float **b;
 
571
     int nrl,nrh,ncl,nch;
 
572
#endif
 
573
 
 
574
{
 
575
  osmmfree((char*) (b+nrl));
 
576
}