← Back to branch summary

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

« back to all changes in this revision

Viewing changes to stdred/echelle/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/echelle/libsrc/nrutil.c
 
1
 
 
2
/*
 
3
 
 
4
.VERSION
 
5
051021          last modif
 
6
 
 
7
*/
 
8
 
 
9
#include <stdlib.h>
 
10
#include <stdio.h>
 
11
 
 
12
void nrerror(error_text)
 
13
char error_text[];
 
14
{
 
15
        void exit();
 
16
 
 
17
        fprintf(stderr,"Numerical Recipes run-time error...\n");
 
18
        fprintf(stderr,"%s\n",error_text);
 
19
        fprintf(stderr,"...now exiting to system...\n");
 
20
        exit(1);
 
21
}
 
22
 
 
23
 
 
24
 
 
25
float *vector(nl,nh)
 
26
int nl,nh;
 
27
{
 
28
        float *v;
 
29
 
 
30
        v=(float *)malloc((size_t) (nh-nl+1)*sizeof(float));
 
31
        if (!v) nrerror("allocation failure in vector()");
 
32
        return v-nl;
 
33
}
 
34
 
 
35
int *ivector(nl,nh)
 
36
int nl,nh;
 
37
{
 
38
        int *v;
 
39
 
 
40
        v=(int *)malloc((size_t) (nh-nl+1)*sizeof(int));
 
41
        if (!v) nrerror("allocation failure in ivector()");
 
42
        return v-nl;
 
43
}
 
44
 
 
45
double *dvector(nl,nh)
 
46
int nl,nh;
 
47
{
 
48
        double *v;
 
49
 
 
50
        v=(double *)malloc((size_t) (nh-nl+1)*sizeof(double));
 
51
        if (!v) nrerror("allocation failure in dvector()");
 
52
        return v-nl;
 
53
}
 
54
 
 
55
 
 
56
 
 
57
float **matrix(nrl,nrh,ncl,nch)
 
58
int nrl,nrh,ncl,nch;
 
59
{
 
60
        int i;
 
61
        float **m;
 
62
 
 
63
        m=(float **) malloc((size_t) (nrh-nrl+1)*sizeof(float*));
 
64
        if (!m) nrerror("allocation failure 1 in matrix()");
 
65
        m -= nrl;
 
66
 
 
67
        for(i=nrl;i<=nrh;i++) {
 
68
                m[i]=(float *) malloc((size_t) (nch-ncl+1)*sizeof(float));
 
69
                if (!m[i]) nrerror("allocation failure 2 in matrix()");
 
70
                m[i] -= ncl;
 
71
        }
 
72
        return m;
 
73
}
 
74
 
 
75
double **dmatrix(nrl,nrh,ncl,nch)
 
76
int nrl,nrh,ncl,nch;
 
77
{
 
78
        int i;
 
79
        double **m;
 
80
 
 
81
        m=(double **) malloc((size_t) (nrh-nrl+1)*sizeof(double*));
 
82
        if (!m) nrerror("allocation failure 1 in dmatrix()");
 
83
        m -= nrl;
 
84
 
 
85
        for(i=nrl;i<=nrh;i++) {
 
86
                m[i]=(double *) malloc((size_t) (nch-ncl+1)*sizeof(double));
 
87
                if (!m[i]) nrerror("allocation failure 2 in dmatrix()");
 
88
                m[i] -= ncl;
 
89
        }
 
90
        return m;
 
91
}
 
92
 
 
93
int **imatrix(nrl,nrh,ncl,nch)
 
94
int nrl,nrh,ncl,nch;
 
95
{
 
96
        int i,**m;
 
97
 
 
98
        m=(int **)malloc((size_t) (nrh-nrl+1)*sizeof(int*));
 
99
        if (!m) nrerror("allocation failure 1 in imatrix()");
 
100
        m -= nrl;
 
101
 
 
102
        for(i=nrl;i<=nrh;i++) {
 
103
                m[i]=(int *)malloc((size_t) (nch-ncl+1)*sizeof(int));
 
104
                if (!m[i]) nrerror("allocation failure 2 in imatrix()");
 
105
                m[i] -= ncl;
 
106
        }
 
107
        return m;
 
108
}
 
109
 
 
110
 
 
111
 
 
112
float **submatrix(a,oldrl,oldrh,oldcl,oldch,newrl,newcl)
 
113
float **a;
 
114
int oldrl,oldrh,oldcl,oldch,newrl,newcl;
 
115
{
 
116
        int i,j;
 
117
        float **m;
 
118
 
 
119
        m=(float **) malloc((size_t) (oldrh-oldrl+1)*sizeof(float*));
 
120
        if (!m) nrerror("allocation failure in submatrix()");
 
121
        m -= newrl;
 
122
 
 
123
        for(i=oldrl,j=newrl;i<=oldrh;i++,j++) m[j]=a[i]+oldcl-newcl;
 
124
 
 
125
        return m;
 
126
}
 
127
 
 
128
 
 
129
 
 
130
void free_vector(v,nl,nh)
 
131
float *v;
 
132
int nl,nh;
 
133
{
 
134
        free((char*) (v+nl));
 
135
}
 
136
 
 
137
void free_ivector(v,nl,nh)
 
138
int *v,nl,nh;
 
139
{
 
140
        free((char*) (v+nl));
 
141
}
 
142
 
 
143
void free_dvector(v,nl,nh)
 
144
double *v;
 
145
int nl,nh;
 
146
{
 
147
        free((char*) (v+nl));
 
148
}
 
149
 
 
150
 
 
151
 
 
152
void free_matrix(m,nrl,nrh,ncl,nch)
 
153
float **m;
 
154
int nrl,nrh,ncl,nch;
 
155
{
 
156
        int i;
 
157
 
 
158
        for(i=nrh;i>=nrl;i--) free((char*) (m[i]+ncl));
 
159
        free((char*) (m+nrl));
 
160
}
 
161
 
 
162
void free_dmatrix(m,nrl,nrh,ncl,nch)
 
163
double **m;
 
164
int nrl,nrh,ncl,nch;
 
165
{
 
166
        int i;
 
167
 
 
168
        for(i=nrh;i>=nrl;i--) free((char*) (m[i]+ncl));
 
169
        free((char*) (m+nrl));
 
170
}
 
171
 
 
172
void free_imatrix(m,nrl,nrh,ncl,nch)
 
173
int **m;
 
174
int nrl,nrh,ncl,nch;
 
175
{
 
176
        int i;
 
177
 
 
178
        for(i=nrh;i>=nrl;i--) free((char*) (m[i]+ncl));
 
179
        free((char*) (m+nrl));
 
180
}
 
181
 
 
182
 
 
183
 
 
184
void free_submatrix(b,nrl,nrh,ncl,nch)
 
185
float **b;
 
186
int nrl,nrh,ncl,nch;
 
187
{
 
188
        free((char*) (b+nrl));
 
189
}
 
190
 
 
191
 
 
192
 
 
193
float **convert_matrix(a,nrl,nrh,ncl,nch)
 
194
float *a;
 
195
int nrl,nrh,ncl,nch;
 
196
{
 
197
        int i,j,nrow,ncol;
 
198
        float **m;
 
199
 
 
200
        nrow=nrh-nrl+1;
 
201
        ncol=nch-ncl+1;
 
202
        m = (float **) malloc((size_t) (nrow)*sizeof(float*));
 
203
        if (!m) nrerror("allocation failure in convert_matrix()");
 
204
        m -= nrl;
 
205
        for(i=0,j=nrl;i<=nrow-1;i++,j++) m[j]=a+ncol*i-ncl;
 
206
        return m;
 
207
}
 
208
 
 
209
 
 
210
 
 
211
void free_convert_matrix(b,nrl,nrh,ncl,nch)
 
212
float **b;
 
213
int nrl,nrh,ncl,nch;
 
214
{
 
215
        free((char*) (b+nrl));
 
216
}