home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 1 / ARM_CLUB_CD.iso / contents / apps / clib / progs / meschach / !Meschach / c / memtort < prev    next >
Encoding:
Text File  |  1994-01-13  |  16.9 KB  |  688 lines
  1. uld be 2)\n",k);
  2.    }
  3.    
  4.    for ( k = 0 ; k < 20; k++ )
  5.    {
  6.       i = sA->m - 1 - ((rand() >> 8) % 10);
  7.       j = sA->n - 1 - ((rand() >> 8) % 10);
  8.       s1 = rand()/((Real)MAX_RAND);
  9.       sp_set_val(sA,i,j,s1);
  10.       if ( fabs(s1 - sp_get_val(sA,i,j)) >= MACHEPS )
  11.     break;
  12.    }
  13.    if ( k < 20 )
  14.      errmesg("sp_resize()");
  15.    sp_col_access(sA);
  16.    if ( ! chk_col_access(sA) )
  17.    {
  18.       errmesg("sp_col_access()");
  19.    }
  20.    sp_diag_access(sA);
  21.    for ( i = 0; i < sA->m; i++ )
  22.    {
  23.       r = &(sA->row[i]);
  24.       if ( r->diag != sprow_idx(r,i) )
  25.     break;
  26.    }
  27.    if ( i < sA->m )
  28.    {
  29.       errmesg("sp_diag_access()");
  30.    }
  31.    
  32.    k = sp_free_vars(&sA,&sB,NULL);
  33.    if (k != 2)
  34.      errmesg("sp_free_vars");
  35. #endif  /* SPARSE */   
  36.  
  37.  
  38. #ifdef COMPLEX
  39.    /* complex stuff */
  40.    
  41.    ONE = zmake(1.0,0.0);
  42.    printf("# ONE = "); z_output(ONE);
  43.    printf("# Check: MACHEPS = %g\n",MACHEPS);
  44.    /* allocate, initialise, copy and resize operations */
  45.    /* ZVEC */
  46.    notice("vector initialise, copy & resize");
  47.    zv_get_vars(12,&zx,&zy,&zz,NULL);
  48.    
  49.    zv_rand(zx);
  50.    zv_rand(zy);
  51.    zz = zv_copy(zx,zz);
  52.    if ( zv_norm2(zv_sub(zx,zz,zz)) >= MACHEPS )
  53.      errmesg("ZVEC copy");
  54.    zv_copy(zx,zy);
  55.    
  56.    zv_resize_vars(10,&zx,&zy,NULL);
  57.    if ( zv_norm2(zv_sub(zx,zy,zz)) >= MACHEPS )
  58.      errmesg("ZVEC copy/resize");
  59.    
  60.    zv_resize_vars(20,&zx,&zy,NULL);
  61.    if ( zv_norm2(zv_sub(zx,zy,zz)) >= MACHEPS )
  62.      errmesg("VZEC resize");
  63.    zv_free_vars(&zx,&zy,&zz,NULL);
  64.  
  65.    
  66.    /* ZMAT */
  67.    notice("matrix initialise, copy & resize");
  68.    zm_get_vars(8,5,&zA,&zB,&zC,NULL);
  69.    
  70.    zm_rand(zA);
  71.    zm_rand(zB);
  72.    zC = zm_copy(zA,zC);
  73.    if ( zm_norm_inf(zm_sub(zA,zC,zC)) >= MACHEPS )
  74.      errmesg("ZMAT copy");
  75.    
  76.    zm_copy(zA,zB);
  77.    zm_resize_vars(3,5,&zA,&zB,&zC,NULL);
  78.    
  79.    if ( zm_norm_inf(zm_sub(zA,zB,zC)) >= MACHEPS )
  80.      errmesg("ZMAT copy/resize");
  81.    zm_resize_vars(20,20,&zA,&zB,&zC,NULL);
  82.    
  83.    if ( zm_norm_inf(zm_sub(zA,zB,zC)) >= MACHEPS )
  84.      errmesg("ZMAT resize");
  85.    
  86.    zm_free_vars(&zA,&zB,&zC,NULL);
  87. #endif /* COMPLEX */
  88.  
  89. #endif  /* if defined(ANSI_C) || defined(VARARGS) */
  90.  
  91.    printf("# test of mem_info_bytes and mem_info_numvar\n");
  92.    printf("  TYPE VEC: %ld bytes allocated, %d variables allocated\n",
  93.       mem_info_bytes(TYPE_VEC,0),mem_info_numvar(TYPE_VEC,0));
  94.  
  95.    notice("static memory test");
  96.    mem_info_on(TRUE);
  97.    mem_stat_mark(1);
  98.    for (i=0; i < 100; i++)
  99.      stat_test1(i);
  100.    mem_stat_free(1);
  101.  
  102.    mem_stat_mark(1);
  103.    for (i=0; i < 100; i++) {
  104.      stat_test1(i);
  105. #ifdef COMPLEX
  106.      stat_test4(i);
  107. #endif
  108.   }
  109.  
  110.    mem_stat_mark(2);
  111.    for (i=0; i < 100; i++)
  112.      stat_test2(i);
  113.  
  114.    mem_stat_mark(3);
  115. #ifdef SPARSE
  116.    for (i=0; i < 100; i++)
  117.      stat_test3(i);
  118. #endif
  119.  
  120.    mem_info();
  121.    mem_dump_list(stdout,0);
  122.  
  123.    mem_stat_free(1);
  124.    mem_stat_free(3);
  125.    mem_stat_mark(4);
  126.  
  127.    for (i=0; i < 100; i++) {
  128.       stat_test1(i);
  129. #ifdef COMPLEX
  130.       stat_test4(i);
  131. #endif
  132.    } 
  133.  
  134.    mem_stat_dump(stdout,0);
  135.    if (mem_stat_show_mark() != 4) {
  136.       errmesg("not 4 in mem_stat_show_mark()");
  137.    }
  138.    
  139.    mem_stat_free(2);
  140.    mem_stat_free(4);
  141.  
  142.    if (mem_stat_show_mark() != 0) {
  143.       errmesg("not 0 in mem_stat_show_mark()");
  144.    }
  145.  
  146.    /* add new list of types */
  147.  
  148.    mem_attach_list(FOO_LIST,FOO_NUM_TYPES,foo_type_name,
  149.            foo_free_func,foo_info_sum);
  150.    if (!mem_is_list_attached(FOO_LIST))
  151.      errmesg("list FOO_LIST is not attached");
  152.  
  153.    mem_dump_list(stdout,FOO_LIST);
  154.    foo_1 = foo_1_get(6);
  155.    foo_2 = foo_2_get(3);
  156.    for (i=0; i < foo_1->dim; i++)
  157.      for (j=0; j < foo_1->fix_dim; j++)
  158.        foo_1->a[i][j] = i+j;
  159.    for (i=0; i < foo_2->dim; i++)
  160.      for (j=0; j < foo_2->fix_dim; j++)
  161.        foo_2->a[i][j] = i+j;
  162.    printf(" foo_1->a[%d][%d] = %g\n",5,9,foo_1->a[5][9]);
  163.    printf(" foo_2->a[%d][%d] = %g\n",2,1,foo_2->a[2][1]);
  164.    
  165.    mem_stat_mark(5);
  166.    mem_stat_reg_list((void **)&foo_1,TYPE_FOO_1,FOO_LIST);
  167.    mem_stat_reg_list((void **)&foo_2,TYPE_FOO_2,FOO_LIST);
  168.    mem_stat_dump(stdout,FOO_LIST);
  169.    mem_info_file(stdout,FOO_LIST);
  170.    mem_stat_free_list(5,FOO_LIST);
  171.    mem_stat_dump(stdout,FOO_LIST);
  172.    if ( foo_1 != NULL )
  173.      errmesg(" foo_1 is not released");
  174.    if ( foo_2 != NULL )
  175.      errmesg(" foo_2 is not released");
  176.    mem_dump_list(stdout,FOO_LIST);
  177.    mem_info_file(stdout,FOO_LIST);
  178.  
  179.    mem_free_vars(FOO_LIST);
  180.    if ( mem_is_list_attached(FOO_LIST) )
  181.      errmesg("list FOO_LIST is not detached");
  182.  
  183.    mem_info();
  184.    
  185. #if REAL == FLOAT
  186.    printf("# SINGLE PRECISION was used\n");
  187. #elif REAL == DOUBLE
  188.    printf("# DOUBLE PRECISION was used\n");
  189. #endif
  190.  
  191. #define ANSI_OR_VAR
  192.  
  193. #ifndef ANSI_C
  194. #ifndef VARARGS
  195. #undef ANSI_OR_VAR
  196. #endif
  197. #endif
  198.  
  199. #ifdef ANSI_OR_VAR
  200.  
  201.    printf("# you should get: \n");
  202. #if (REAL == FLOAT)
  203.      printf("#   type VEC: 276 bytes allocated, 3 variables allocated\n");
  204. #elif (REAL == DOUBLE)
  205.      printf("#   type VEC: 516 bytes allocated, 3 variables allocated\n");
  206. #endif
  207.    printf("#   and other types are zeros\n");
  208.  
  209. #endif /*#if defined(ANSI_C) || defined(VARAGS) */
  210.  
  211.    printf("# Finished memory torture test\n");
  212.    return;
  213. }
  214. FileDataŵmfunc:#Eÿÿÿüß?^
  215. /**************************************************************************
  216. **
  217. ** Copyright (C) 1993 David E. Steward & Zbigniew Leyk, all rights reserved.
  218. **
  219. **                 Meschach Library
  220. ** 
  221. ** This Meschach Library is provided "as is" without any express 
  222. ** or implied warranty of any kind with respect to this software. 
  223. ** In particular the authors shall not be liable for any direct, 
  224. ** indirect, special, incidental or consequential damages arising 
  225. ** in any way from use of the software.
  226. ** 
  227. ** Everyone is granted permission to copy, modify and redistribute this
  228. ** Meschach Library, provided:
  229. **  1.  All copies contain this copyright notice.
  230. **  2.  All modified copies shall carry a notice stating who
  231. **      made the last modification and the date of such modification.
  232. **  3.  No charge is made for this software or works derived from it.  
  233. **      This clause shall not be construed as constraining other software
  234. **      distributed on the same medium as this software, nor is a
  235. **      distribution fee considered a charge.
  236. **
  237. ***************************************************************************/
  238.  
  239.  
  240. /*
  241.   This file contains routines for computing functions of matrices
  242.   especially polynomials and exponential functions
  243.   Copyright (C) Teresa Leyk and David Stewart, 1993
  244.   */
  245.  
  246. #include <stdio.h>
  247. #include <math.h>
  248. #include "matrix.h"
  249. #include "matrix2.h"
  250.  
  251. static char    rcsid[] = "$Id: mfunc.c,v 1.1 1994/01/13 05:33:58 des Exp $";
  252.  
  253.  
  254.  
  255. /* _m_pow -- computes integer powers of a square matrix A, A^p
  256.    -- uses tmp as temporary workspace */
  257. MAT    *_m_pow(A, p, tmp, out)
  258. MAT    *A, *tmp, *out;
  259. int    p;
  260. {
  261.    int        it_cnt, k, max_bit;
  262.    
  263.    /*
  264.      File containing routines for evaluating matrix functions
  265.      esp. the exponential function
  266.      */
  267.  
  268. #define    Z(k)    (((k) & 1) ? tmp : out)
  269.    
  270.    if ( ! A )
  271.      error(E_NULL,"_m_pow");
  272.    if ( A->m != A->n )
  273.      error(E_SQUARE,"_m_pow");
  274.    if ( p < 0 )
  275.      error(E_NEG,"_m_pow");
  276.    out = m_resize(out,A->m,A->n);
  277.    tmp = m_resize(tmp,A->m,A->n);
  278.    
  279.    if ( p == 0 )
  280.      m_ident(out);
  281.    else if ( p > 0 )
  282.    {
  283.       it_cnt = 1;
  284.       for ( max_bit = 0; ; max_bit++ )
  285.     if ( (p >> (max_bit+1)) == 0 )
  286.       break;
  287.       tmp = m_copy(A,tmp);
  288.       
  289.       for ( k = 0; k < max_bit; k++ )
  290.       {
  291.      m_mlt(Z(it_cnt),Z(it_cnt),Z(it_cnt+1));
  292.      it_cnt++;
  293.      if ( p & (1 << (max_bit-1)) )
  294.      {
  295.         m_mlt(A,Z(it_cnt),Z(it_cnt+1));
  296.         /* m_copy(Z(it_cnt),out); */
  297.         it_cnt++;
  298.      }
  299.      p <<= 1;
  300.       }
  301.       if (it_cnt & 1)
  302.     out = m_copy(Z(it_cnt),out);
  303.    }
  304.  
  305.    return out;
  306.  
  307. #undef Z   
  308. }
  309.  
  310. /* m_pow -- computes integer powers of a square matrix A, A^p */
  311. MAT    *m_pow(A, p, out)
  312. MAT    *A, *out;
  313. int    p;
  314. {
  315.    static MAT    *wkspace = MNULL;
  316.    
  317.    if ( ! A )
  318.      error(E_NULL,"m_pow");
  319.    if ( A->m != A->n )
  320.      error(E_SQUARE,"m_pow");
  321.    
  322.    wkspace = m_resize(wkspace,A->m,A->n);
  323.    MEM_STAT_REG(wkspace,TYPE_MAT);
  324.    
  325.    return _m_pow(A, p, wkspace, out);
  326.    
  327. }
  328.  
  329. /**************************************************/
  330.  
  331. /* _m_exp -- compute matrix exponential of A and save it in out
  332.    -- uses Pade approximation followed by repeated squaring
  333.    -- eps is the tolerance used for the Pnteractive input of vector */
  334. VEC     *ifin_vec(fp,vec)
  335. FILE    *fp;
  336. VEC     *vec;
  337. {
  338.      u_int      i,dim,dynamic;  /* dynamic set if memory allocated here */
  339.      
  340.      /* get vector dimension */
  341.      if ( vec != (VEC *)NULL && vec->dim<MAXDIM )
  342.      {  dim = vec->dim; dynamic = FALSE;        }
  343.      else
  344.      {
  345.       dynamic = TRUE;
  346.       do
  347.       {
  348.            fprintf(stderr,"Vector: dim: ");
  349.            if ( fgets(line,MAXLINE,fp)==NULL )
  350.             error(E_INPUT,"ifin_vec");
  351.       } while ( sscanf(line,"%u",&dim)<1 || dim>MAXDIM );
  352.       vec = v_get(dim);
  353.      }
  354.      
  355.      /* input elements */
  356.      for ( i=0; i<dim; i++ )
  357.       do
  358.       {
  359.       redo:
  360.            fprintf(stderr,"entry %u: ",i);
  361.            if ( !dynamic )
  362.             fprintf(stderr,"old %14.9g new: ",vec->ve[i]);
  363.            if ( fgets(line,MAXLINE,fp)==NULL )
  364.             error(E_INPUT,"ifin_vec");
  365.            if ( (*line == 'b' || *line == 'B') && i > 0 )
  366.            {        i--;    dynamic = FALSE;        goto redo;         }
  367.            if ( (*line == 'f' || *line == 'F') && i < dim-1 )
  368.            {        i++;    dynamic = FALSE;        goto redo;         }
  369. #if REAL == DOUBLE
  370.       } while ( *line=='\0' || sscanf(line,"%lf",&vec->ve[i]) < 1 );
  371. #elif REAL == FLOAT
  372.           } while ( *line=='\0' || sscanf(line,"%f",&vec->ve[i]) < 1 );
  373. #endif
  374.      
  375.      return (vec);
  376. }
  377.  
  378. /* bfin_vec -- batch-file input of vector */
  379. VEC     *bfin_vec(fp,vec)
  380. FILE    *fp;
  381. VEC     *vec;
  382. {
  383.      u_int      i,dim;
  384.      int        io_code;
  385.      
  386.      /* get dimension */
  387.      skipjunk(fp);
  388.      if ((io_code=fscanf(fp," Vector: dim:%u",&dim)) < 1 ||
  389.      dim>MAXDIM )
  390.       error(io_code==EOF ? 7 : 6,"bfin_vec");
  391.      
  392.      /* allocate memory if necessary */
  393.      if ( vec==(VEC *)NULL )
  394.       vec = v_resize(vec,dim);
  395.      
  396.      /* get entries */
  397.      skipjunk(fp);
  398.      for ( i=0; i<dim; i++ )
  399. #if REAL == DOUBLE
  400.       if ((io_code=fscanf(fp,"%lf",&vec->ve[i])) < 1 )
  401. #elif REAL == FLOAT
  402.       if ((io_code=fscanf(fp,"%f",&vec->ve[i])) < 1 )
  403. #endif
  404.            error(io_code==EOF ? 7 : 6,"bfin_vec");
  405.      
  406.      return (vec);
  407. }
  408.  
  409. /**************************************************************************
  410.   Output routines
  411.   **************************************************************************/
  412. static char    *format = "%14.9g ";
  413.  
  414. char    *setformat(f_string)
  415. char    *f_string;
  416. {
  417.     char    *old_f_string;
  418.     old_f_string = format;
  419.     if ( f_string != (char *)NULL && *f_string != '\0' )
  420.     format = f_string;
  421.  
  422.     return old_f_string;
  423. }
  424.  
  425. void    m_foutput(fp,a)
  426. FILE    *fp;
  427. MAT     *a;
  428. {
  429.      u_int      i, j, tmp;
  430.      
  431.      if ( a == (MAT *)NULL )
  432.      {  fprintf(fp,"Matrix: NULL\n");   return;         }
  433.      fprintf(fp,"Matrix: %d by %d\n",a->m,a->n);
  434.      if ( a->me == (Real **)NULL )
  435.      {  fprintf(fp,"NULL\n");           return;         }
  436.      for ( i=0; i<a->m; i++ )   /* for each row... */
  437.      {
  438.       fprintf(fp,"row %u: ",i);
  439.       for ( j=0, tmp=2; j<a->n; j++, tmp++ )
  440.       {             /* for each col in row... */
  441.            fprintf(fp,format,a->me[i][j]);
  442.            if ( ! (tmp % 5) )       putc('\n',fp);
  443.       }
  444.       if ( tmp % 5 != 1 )   putc('\n',fp);
  445.      }
  446. }
  447.  
  448. void    px_foutput(fp,px)
  449. FILE    *fp;
  450. PERM    *px;
  451. {
  452.      u_int      i;
  453.      
  454.      if ( px == (PERM *)NULL )
  455.      {  fprintf(fp,"Permutation: NULL\n");      return;         }
  456.      fprintf(fp,"Permutation: size: %u\n",px->size);
  457.      if ( px->pe == (u_int *)NULL )
  458.      {  fprintf(fp,"NULL\n");   return;         }
  459.      for ( i=0; i<px->size; i++ )
  460.     if ( ! (i % 8) && i != 0 )
  461.       fprintf(fp,"\n  %u->%u ",i,px->pe[i]);
  462.     else
  463.       fprintf(fp,"%u->%u ",i,px->pe[i]);
  464.      fprintf(fp,"\n");
  465. }
  466.  
  467. void    v_foutput(fp,x)
  468. FILE    *fp;
  469. VECles is non-negative */
  470.    if ( num < 0 ) {
  471.  
  472.       if (mlist->info_sum[type].numvar < 0)
  473.       {
  474.      fprintf(stderr,
  475.        "\n WARNING !! memory info: allocated # of variables is less than 0\n");
  476.      fprintf(stderr,"\t TYPE %s \n\n", mlist->type_names[type]);
  477.      if ( !isatty(fileno(stdout)) ) {
  478.         fprintf(stdout,
  479.       "\n WARNING !! memory info: allocated # of variables is less than 0\n");
  480.         fprintf(stdout,"\t TYPE %s \n\n", mlist->type_names[type]);
  481.      }
  482.       }
  483.    }
  484. }
  485.  
  486. FileDataŵmemoryÎMEýÿÿ.ÿô UŒ
  487. /**************************************************************************
  488. **
  489. ** Copyright (C) 1993 David E. Steward & Zbigniew Leyk, all rights reserved.
  490. **
  491. **                 Meschach Library
  492. ** 
  493. ** This Meschach Library is provided "as is" without any express 
  494. ** or implied warranty of any kind with respect to this software. 
  495. ** In particular the authors shall not be liable for any direct, 
  496. ** indirect, special, incidental or consequential damages arising 
  497. ** in any way from use of the software.
  498. ** 
  499. ** Everyone is granted permission to copy, modify and redistribute this
  500. ** Meschach Library, provided:
  501. **  1.  All copies contain this copyright notice.
  502. **  2.  All modified copies shall carry a notice stating who
  503. **      made the last modification and the date of such modification.
  504. **  3.  No charge is made for this software or works derived from it.  
  505. **      This clause shall not be construed as constraining other software
  506. **      distributed on the same medium as this software, nor is a
  507. **      distribution fee considered a charge.
  508. **
  509. ***************************************************************************/
  510.  
  511.  
  512. /* memory.c 1.3 11/25/87 */
  513.  
  514. #include     "matrix.h"
  515.  
  516.  
  517. static    char    rcsid[] = "$Id: memory.c,v 1.13 1994/04/05 02:10:37 des Exp $";
  518.  
  519. /* m_get -- gets an mxn matrix (in MAT form) by dynamic memory allocation */
  520. MAT    *m_get(m,n)
  521. int    m,n;
  522. {
  523.    MAT    *matrix;
  524.    int    i;
  525.    
  526.    if (m < 0 || n < 0)
  527.      error(E_NEG,"m_get");
  528.  
  529.    if ((matrix=NEW(MAT)) == (MAT *)NULL )
  530.      error(E_MEM,"m_get");
  531.    else if (mem_info_is_on()) {
  532.       mem_bytes(TYPE_MAT,0,sizeof(MAT));
  533.       mem_numvar(TYPE_MAT,1);
  534.    }
  535.    
  536.    matrix->m = m;        matrix->n = matrix->max_n = n;
  537.    matrix->max_m = m;    matrix->max_size = m*n;
  538. #ifndef SEGMENTED
  539.    if ((matrix->base = NEW_A(m*n,Real)) == (Real *)NULL )
  540.    {
  541.       free(matrix);
  542.       error(E_MEM,"m_get");
  543.    }
  544.    else if (mem_info_is_on()) {
  545.       mem_bytes(TYPE_MAT,0,m*n*sizeof(Real));
  546.    }
  547. #else
  548.    matrix->base = (Real *)NULL;
  549. #endif
  550.    if ((matrix->me = (Real **)calloc(m,sizeof(Real *))) == 
  551.        (Real **)NULL )
  552.    {    free(matrix->base);    free(matrix);
  553.     error(E_MEM,"m_get");
  554.      }
  555.    else if (mem_info_is_on()) {
  556.       mem_bytes(TYPE_MAT,0,m*sizeof(Real *));
  557.    }
  558.    
  559. #ifndef SEGMENTED
  560.    /* set up pointers */
  561.    for ( i=0; i<m; i++ )
  562.      matrix->me[i] = &(matrix->base[i*n]);
  563. #else
  564.    for ( i = 0; i < m; i++ )
  565.      if ( (matrix->me[i]=NEW_A(n,Real)) == (Real *)NULL )
  566.        error(E_MEM,"m_get");
  567.      else if (mem_info_is_on()) {
  568.     mem_bytes(TYPE_MAT,0,n*sizeof(Real));
  569.        }
  570. #endif
  571.    
  572.    return (matrix);
  573. }
  574.  
  575.  
  576. /* px_get -- gets a PERM of given 'size' by dynamic memory allocation
  577.    -- Note: initialized to the identity permutation */
  578. PERM    *px_get(size)
  579. int    size;
  580. {
  581.    PERM    *permute;
  582.    int    i;
  583.  
  584.    if (size < 0)
  585.      error(E_NEG,"px_get");
  586.  
  587.    if ((permute=NEW(PERM)) == (PERM *)NULL )
  588.      error(E_MEM,"px_get");
  589.    else if (mem_info_is_on()) {
  590.       mem_bytes(TYPE_PERM,0,sizeof(PERM));
  591.       mem_numvar(TYPE_PERM,1);
  592.    }
  593.    
  594.    permute->size = permute->max_size = size;
  595.    if ((permute->pe = NEW_A(size,u_int)) == (u_int *)NULL )
  596.      error(E_MEM,"px_get");
  597.    else if (mem_info_is_on()) {
  598.       mem_bytes(TYPE_PERM,0,size*sizeof(u_int));
  599.    }
  600.    
  601.    for ( i=0; i<size; i++ )
  602.      permute->pe[i] = i;
  603.    
  604.    return (permute);
  605. }
  606.  
  607. /* v_get -- gets a VEC of dimension 'dim'
  608.    -- Note: initialized to zero */
  609. VEC    *v_get(size)
  610. int    size;
  611. {
  612.    VEC    *vector;
  613.    
  614.    if (size < 0)
  615.      error(E_NEG,"v_get");
  616.  
  617.    if ((vector=NEW(VEC)) == (VEC *)NULL )
  618.      error(E_MEM,"v_get");
  619.    else if (mem_info_is_on()) {
  620.       mem_bytes(TYPE_VEC,0,sizeof(VEC));
  621.       mem_numvar(TYPE_VEC,1);
  622.    }
  623.    
  624.    vector->dim = vector->max_dim = size;
  625.    if ((vector->ve=NEW_A(size,Real)) == (Real *)NULL )
  626.    {
  627.       free(vector);
  628.       error(E_MEM,"v_get");
  629.    }
  630.    else if (mem_info_is_on()) {
  631.       mem_bytes(TYPE_VEC,0,size*sizeof(Real));
  632.    }
  633.    
  634.    return (vector);
  635. }
  636.  
  637. /* m_free -- returns MAT & asoociated memory back to memory heap */
  638. int    m_free(mat)
  639. MAT    *mat;
  640. {
  641. #ifdef SEGMENTED
  642.    int    i;
  643. #endif
  644.    
  645.    if ( mat==(MAT *)NULL || (int)(mat->m) < 0 ||
  646.        (int)(mat->n) < 0 )
  647.      /* don't trust it */
  648.      return (-1);
  649.    
  650. #ifndef SEGMENTED
  651.    if ( mat->base != (Real *)NULL ) {
  652.       if (mem_info_is_on()) {
  653.      mem_bytes(TYPE_MAT,mat->max_m*mat->max_n*sizeof(Real),0);
  654.       }
  655.       free((char *)(mat->base));
  656.    }
  657. #else
  658.    for ( i = 0; i < mat->max_m; i++ )
  659.      if ( mat->me[i] != (Real *)NULL ) {
  660.     if (mem_info_is_on()) {
  661.        mem_bytes(TYPE_MAT,mat->max_n*sizeof(Real),0);
  662.     }
  663.     free((char *)(mat->me[i]));
  664.      }
  665. #endif
  666.    if ( mat->me != (Real **)NULL ) {
  667.       if (mem_info_is_on()) {
  668.      mem_bytes(TYPE_MAT,mat->max_m*sizeof(Real *),0);
  669.       }
  670.       free((char *)(mat->me));
  671.    }
  672.    
  673.    if (mem_info_is_on()) {
  674.       mem_bytes(TYPE_MAT,sizeof(MAT),0);
  675.       mem_numvar(TYPE_MAT,-1);
  676.    }
  677.    free((char *)mat);
  678.    
  679.    return (0);
  680. }
  681.  
  682.  
  683.  
  684. /* px_free -- returns PERM & asoociated memory back to memory heap */
  685. int    px_free(px)
  686. PERM    *px;
  687. {
  688.    if ( px==(PERM *)NULL || (int)(px->siz