source: tags/arb_5.1/GDE/MOLPHY/matrixut.c

Last change on this file was 5708, checked in by westram, 15 years ago
  • backtrace gets printed to console from
    • GB_internal_error
    • SIGSEGV (currently GB_login installs the handler using GBK_install_SIGSEGV_handler. Most likely needs to be called manually for some executables)
    • GBK_terminate
  • added GBK_dump_backtrace, GBK_terminate and GBK_assert_msg
  • Default assertion dumps backtrace now
  • added -rdynamic and —export-dynamic compiler/linker flags, leaving symbols in code. This raises size of executables by approx. 8%, but we will get meaningful backtraces from users.
  • removed old inactive SIGSEGV code
  • replaced GB_CORE either by xx_assert() or GBK_terminate()
  • removed GBS_do_core (was used conditionally together with GB_CORE)
  • disabled crash provoked via arb_panic (using 'core' as savename)
  • Linkage changed:
    • The future plan is to try some kind of emergency save on open DBs when GBK_terminate or similar is called.
    • Since arb_assert calls GBK_terminate this affects ALL applications.
    • The drawback is all executables have to be linked vs ARBDB (done with: arb_help2xml and arb_convert_aln, all others already had ARBDB linked)
    • Molphy uses #define SIMPLE_ARB_ASSERT before including arb_assert.h
  • renamed define GBL_INCLUDED → ADLOCAL_H
  • added arbdb_base.h (defining some types and including ad_k_prot.h, which contains all GBK_*-functions). Intended as minimal and seldom changed interface to libARBDB as needed by arb_assert(), to keep build dependencies low.
  • arb_assert.h now automatically includes arbdb_base.h
  • trigger compilation of test functions in parsimony via define
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 7.0 KB
Line 
1/*
2 * matrixut.c - numerical matrix utility
3 * Ver. 1.2  Aug 26, 1993  Adachi, J.
4 *
5 * Copyright (C) 1992, 1993 J. Adachi & M. Hasegawa, All rights reserved.
6 */
7
8#ifndef MATRIX_UTILITY
9#define MATRIX_UTILITY
10
11#include <stdio.h>
12#include <stddef.h>
13
14#define SIMPLE_ARB_ASSERT
15#include                "mo_assert.h"
16#define mo_assert(cond) arb_assert(cond)
17
18#include "matrixut.h"
19
20void
21maerror(message)
22const char *message;
23/* memory allocation error handler */
24{
25        fprintf(stderr, "\nmemory allocation failure %s\n", message);
26        exit(1);
27}
28
29/*
30 * float matrix utility
31 */
32
33fvector
34new_fvector(n)
35int n;
36/* memory allocate a float vector */
37{
38        fvector v;
39
40    mo_assert(n>0);
41
42        v = (fvector) malloc((unsigned) (n * sizeof(float)));
43        if (v == NULL) maerror("in fvector().");
44        return v;
45}
46
47fmatrix
48new_fmatrix(nrow, ncol)
49int nrow;
50int ncol;
51/* memory allocate a float matrix */
52{
53        int i;
54        fmatrix m;
55
56    mo_assert(nrow>0);
57    mo_assert(ncol>0);
58
59        m = (fmatrix) malloc((unsigned) (nrow * sizeof(fvector)));
60        if (m == NULL) maerror("1 in fmatrix().");
61        *m = (fvector) malloc((unsigned) (nrow * ncol * sizeof(float)));
62        if (*m == NULL) maerror("2 in fmatrix().");
63        for (i = 1; i < nrow; i++) m[i] = m[i-1] + ncol;
64        return m;
65}
66
67fcube
68new_fcube(ntri, nrow, ncol)
69int ntri;
70int nrow;
71int ncol;
72/* memory allocate a float cube */
73{
74        int i, j;
75        fcube c;
76
77    mo_assert(ntri>0);
78    mo_assert(nrow>0);
79    mo_assert(ncol>0);
80
81        c = (fcube) malloc((unsigned) (ntri * sizeof(fmatrix)));
82        if (c == NULL) maerror("1 in fcube().");
83        *c = (fmatrix) malloc((unsigned) (ntri * nrow * sizeof(fvector)));
84        if (*c == NULL) maerror("2 in fcube().");
85        **c = (fvector) malloc((unsigned) (ntri * nrow * ncol * sizeof(float)));
86        if (**c == NULL) maerror("3 in fcube().");
87        for (j = 1; j < nrow; j++) c[0][j] = c[0][j-1] + ncol;
88        for (i = 1; i < ntri; i++) {
89                c[i] = c[i-1] + nrow;
90                c[i][0] = c[i-1][0] + nrow * ncol;
91                for (j = 1; j < nrow; j++) c[i][j] = c[i][j-1] + ncol;
92        }
93        return c;
94}
95
96void
97free_fvector(v)
98fvector v;
99{
100        free((char *) v);
101}
102
103void
104free_fmatrix(m)
105fmatrix m;
106{
107        free((char *) *m);
108        free((char *) m);
109}
110
111void
112free_fcube(c)
113fcube c;
114{
115        free((char *) **c);
116        free((char *) *c);
117        free((char *) c);
118}
119
120
121/*
122 * double matrix utility
123 */
124
125dvector
126new_dvector(n)
127int n;
128/* memory allocate a double vector */
129{
130        dvector v;
131
132    mo_assert(n>0);
133
134        v = (dvector) malloc((unsigned) (n * sizeof(double)));
135        if (v == NULL) maerror("in dvector().");
136        return v;
137}
138
139dmatrix
140new_dmatrix(nrow, ncol)
141int nrow;
142int ncol;
143/* memory allocate a double matrix */
144{
145    int     i;
146    dmatrix m;
147
148    mo_assert(nrow>0);
149    mo_assert(ncol>0);
150
151    m = (dmatrix) malloc((unsigned) (nrow * sizeof(dvector)));
152    if (m == NULL) maerror("1 in dmatrix().");
153    *m = (dvector) malloc((unsigned) (nrow * ncol * sizeof(double)));
154    if (*m == NULL) maerror("2 in dmatrix().");
155    for (i = 1; i < nrow; i++) m[i] = m[i-1] + ncol;
156    return m;
157}
158
159dcube
160new_dcube(ntri, nrow, ncol)
161int ntri;
162int nrow;
163int ncol;
164/* memory allocate a double cube */
165{
166        int i, j;
167        dcube c;
168
169    mo_assert(ntri>0);
170    mo_assert(nrow>0);
171    mo_assert(ncol>0);
172   
173        c = (dcube) malloc((unsigned) (ntri * sizeof(dmatrix)));
174        if (c == NULL) maerror("1 in dcube().");
175        *c = (dmatrix) malloc((unsigned) (ntri * nrow * sizeof(dvector)));
176        if (*c == NULL) maerror("2 in dcube().");
177        **c = (dvector) malloc((unsigned) (ntri * nrow * ncol * sizeof(double)));
178        if (**c == NULL) maerror("3 in dcube().");
179        for (j = 1; j < nrow; j++) c[0][j] = c[0][j-1] + ncol;
180        for (i = 1; i < ntri; i++) {
181                c[i] = c[i-1] + nrow;
182                c[i][0] = c[i-1][0] + nrow * ncol;
183                for (j = 1; j < nrow; j++) c[i][j] = c[i][j-1] + ncol;
184        }
185        return c;
186}
187
188void
189free_dvector(v)
190dvector v;
191{
192        free((char *) v);
193}
194
195void
196free_dmatrix(m)
197dmatrix m;
198{
199        free((char *) *m);
200        free((char *) m);
201}
202
203void
204free_dcube(c)
205dcube c;
206{
207        free((char *) **c);
208        free((char *) *c);
209        free((char *) c);
210}
211
212
213/*
214 * char matrix utility
215 */
216
217cvector
218new_cvector(n)
219int n;
220/* memory allocate a char vector */
221{
222        cvector v;
223   
224    mo_assert(n>0);
225
226        v = (cvector) malloc((unsigned)n * sizeof(char));
227        if (v == NULL) maerror("in cvector().");
228        return v;
229}
230
231cmatrix
232new_cmatrix(nrow, ncol)
233int nrow;
234int ncol;
235/* memory allocate a char matrix */
236{
237        int i;
238        cmatrix m;
239
240    mo_assert(nrow>0);
241    mo_assert(ncol>0);
242   
243        m = (cmatrix) malloc((unsigned) (nrow * sizeof(cvector)));
244        if (m == NULL) maerror("1 in cmatrix().");
245        *m = (cvector) malloc((unsigned) (nrow * ncol * sizeof(char)));
246        if (*m == NULL) maerror("2 in cmatrix().");
247        for (i = 1; i < nrow; i++) m[i] = m[i-1] + ncol;
248        return m;
249}
250
251ccube
252new_ccube(ntri, nrow, ncol)
253int ntri;
254int nrow;
255int ncol;
256/* memory allocate a char cube */
257{
258        int i, j;
259        ccube c;
260
261    mo_assert(ntri>0);
262    mo_assert(nrow>0);
263    mo_assert(ncol>0);
264   
265        c = (ccube) malloc((unsigned) (ntri * sizeof(cmatrix)));
266        if (c == NULL) maerror("1 in ccube().");
267        *c = (cmatrix) malloc((unsigned) (ntri * nrow * sizeof(cvector)));
268        if (*c == NULL) maerror("2 in ccube().");
269        **c = (cvector) malloc((unsigned) (ntri * nrow * ncol * sizeof(char)));
270        if (**c == NULL) maerror("3 in ccube().");
271        for (j = 1; j < nrow; j++) c[0][j] = c[0][j-1] + ncol;
272        for (i = 1; i < ntri; i++) {
273                c[i] = c[i-1] + nrow;
274                c[i][0] = c[i-1][0] + nrow * ncol;
275                for (j = 1; j < nrow; j++) c[i][j] = c[i][j-1] + ncol;
276        }
277        return c;
278}
279
280void
281free_cvector(v)
282cvector v;
283{
284        free((char *) v);
285}
286
287void
288free_cmatrix(m)
289cmatrix m;
290{
291        free((char *) *m);
292        free((char *) m);
293}
294
295void
296free_ccube(c)
297ccube c;
298{
299        free((char *) **c);
300        free((char *) *c);
301        free((char *) c);
302}
303
304
305/*
306 * int matrix utility
307 */
308
309ivector
310new_ivector(n)
311int n;
312/* memory allocate a int vector */
313{
314        ivector v;
315
316    mo_assert(n>0);
317   
318        v = (ivector) malloc((unsigned) (n * sizeof(int)));
319        if (v == NULL) maerror("in ivector().");
320        return v;
321}
322
323imatrix
324new_imatrix(nrow, ncol)
325int nrow;
326int ncol;
327/* memory allocate a int matrix */
328{
329        int i;
330        imatrix m;
331
332    mo_assert(nrow>0);
333    mo_assert(ncol>0);
334   
335        m = (imatrix) malloc((unsigned) (nrow * sizeof(ivector)));
336        if (m == NULL) maerror("1 in imatrix().");
337        *m = (ivector) malloc((unsigned) (nrow * ncol * sizeof(int)));
338        if (*m == NULL) maerror("2 in imatrix().");
339        for (i = 1; i < nrow; i++) m[i] = m[i-1] + ncol;
340        return m;
341}
342
343icube
344new_icube(ntri, nrow, ncol)
345int ntri;
346int nrow;
347int ncol;
348/* memory allocate a int cube */
349{
350        int i, j;
351        icube c;
352
353    mo_assert(ntri>0);
354    mo_assert(nrow>0);
355    mo_assert(ncol>0);
356   
357        c = (icube) malloc((unsigned) (ntri * sizeof(imatrix)));
358        if (c == NULL) maerror("1 in icube().");
359        *c = (imatrix) malloc((unsigned) (ntri * nrow * sizeof(ivector)));
360        if (*c == NULL) maerror("2 in icube().");
361        **c = (ivector) malloc((unsigned) (ntri * nrow * ncol * sizeof(int)));
362        if (**c == NULL) maerror("3 in icube().");
363        for (j = 1; j < nrow; j++) c[0][j] = c[0][j-1] + ncol;
364        for (i = 1; i < ntri; i++) {
365                c[i] = c[i-1] + nrow;
366                c[i][0] = c[i-1][0] + nrow * ncol;
367                for (j = 1; j < nrow; j++) c[i][j] = c[i][j-1] + ncol;
368        }
369        return c;
370}
371
372void
373free_ivector(v)
374ivector v;
375{
376        free((char *) v);
377}
378
379void
380free_imatrix(m)
381imatrix m;
382{
383        free((char *) *m);
384        free((char *) m);
385}
386
387void
388free_icube(c)
389icube c;
390{
391        free((char *) **c);
392        free((char *) *c);
393        free((char *) c);
394}
395
396
397#endif /* MATRIX_UTILITY */
Note: See TracBrowser for help on using the repository browser.