Logo Search packages:      
Sourcecode: mafft version File versions  Download package

mtxutl.c

#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "mtxutl.h"

void MtxuntDouble( double **mtx, int n )
{
    int i, j;
    for( i=0; i<n; i++ ) for( j=0; j<n; j++ ) mtx[i][j] = 0.0;
    for( i=0; i<n; i++ ) mtx[i][i] = 1.0;
}

void MtxmltDouble( double **mtx1, double **mtx2, int n )
{
    int i, j, k;
    double s, *tmp;

      tmp = (double *)calloc( n, sizeof( double ) );
    for( i=0; i<n; i++ ) 
    {
        for( k=0; k<n; k++ ) tmp[k] = mtx1[i][k];
        for( j=0; j<n; j++ ) 
        {
            s = 0.0;
            for( k=0; k<n; k++ ) s += tmp[k] * mtx2[k][j];
            mtx1[i][j] = s;
        }
    }
      free( tmp );
}

char *AllocateCharVec( int l1 )
{
      char *cvec;
      
      cvec = (char *)calloc( l1, sizeof( char ) );
      if( cvec == NULL )
      {
            fprintf( stderr, "Cannot allocate %d character vector.\n", l1 );
            exit( 1 );
      }
      return( cvec );
}
      
#if 0
void ReallocateCharMtx( char **mtx, int l1, int l2 )
{
      int i;
      char *bk = (char *)malloc( l2+1 ); // hontou ha iranai
      if( bk == NULL )
      {
            fprintf( stderr, "Cannot allocate bk in ReallocateCharMtx\n" );
            exit( 1 );
      }
      for( i=0; i<l1; i++ ) 
      {
#if 1
            strcpy( bk, mtx[i] );
            mtx[i] = (char *)realloc( mtx[i], (l2+1) * sizeof( char ) );
            if( mtx[i] == NULL )
            {
                  fprintf( stderr, "Cannot reallocate %d x %d character matrix.\n", l1, l2 );
            }
            if( strcmp( bk, mtx[i] ) ) // hontou ha iranai
            {
                  fprintf( stderr, "changed!! \n%s\n \nto\n%s\n in realloc..\n", bk, mtx[i] );
                  strcpy( mtx[i], bk );
            }
#else
            strcpy( bk, mtx[i] );
            free( mtx[i] );
            mtx[i] = (char *)calloc( (l2+1), sizeof( char ) );
            strcpy( mtx[i], bk );
#endif
      }
      free( bk ); // hontou ha iranai
} 
#else
void ReallocateCharMtx( char **mtx, int l1, int l2 )
{
      int i;
      for( i=0; i<l1; i++ ) 
      {
            mtx[i] = (char *)realloc( mtx[i], (l2+1) * sizeof( char ) );
            if( mtx[i] == NULL )
            {
                  fprintf( stderr, "Cannot reallocate %d x %d character matrix.\n", l1, l2 );
            }
      }
} 
#endif

char **AllocateCharMtx( int l1, int l2 )
{
      int i;
      char **cmtx;
      
      cmtx = (char **)calloc( l1+1, sizeof( char * ) );
      if( cmtx == NULL )
      {
            fprintf( stderr, "Cannot allocate %d x %d character matrix.\n", l1, l2 );
            exit( 1 );
      }   
      if( l2 )
      {
            for( i=0; i<l1; i++ ) 
            {
                  cmtx[i] = AllocateCharVec( l2 );
            }
      }
      cmtx[l1] = NULL;
      return( cmtx );
} 

void FreeCharMtx( char **mtx )
{
/*
      char **x;
      x = mtx;
      while( *x != NULL ) free( *x++ );
      free( mtx );
*/
      int i;
      for( i=0; mtx[i]; i++ ) 
      {
            free( mtx[i] );
      }
      free( mtx );
}

float *AllocateFloatVec( int l1 )
{
      float *vec;

      vec = (float *)calloc( (unsigned int)l1, sizeof( float ) );
      if( vec == NULL )
      {
            fprintf( stderr, "Allocation error ( %d fload vec )\n", l1 );
            exit( 1 );
      }
      return( vec );
}

void FreeFloatVec( float *vec )
{
      free( (char *)vec );
}

float **AllocateFloatHalfMtx( int ll1 )
{
      float **mtx;
      int i;

      mtx = (float **)calloc( (unsigned int)ll1+1, sizeof( float * ) );
      if( mtx == NULL )
      {
            fprintf( stderr, "Allocation error ( %d fload halfmtx )\n", ll1 );
            exit( 1 );
      }
      for( i=0; i<ll1; i++ )
      {
            mtx[i] = (float *)calloc( ll1-i, sizeof( float ) );
            if( !mtx[i] )
            {
                  fprintf( stderr, "Allocation error( %d floathalfmtx )\n", ll1 );
                  exit( 1 );
            }
      }
      mtx[ll1] = NULL;
      return( mtx );
}

float **AllocateFloatMtx( int ll1, int ll2 )
{
      float **mtx;
      int i;

      mtx = (float **)calloc( (unsigned int)ll1+1, sizeof( float * ) );
      if( mtx == NULL )
      {
            fprintf( stderr, "Allocation error ( %d x %d fload mtx )\n", ll1, ll2 );
            exit( 1 );
      }
      if( ll2 )
      {
            for( i=0; i<ll1; i++ )
            {
                  mtx[i] = (float *)calloc( ll2, sizeof( float ) );
                  if( !mtx[i] )
                  {
                        fprintf( stderr, "Allocation error( %d x %d floatmtx )\n", ll1, ll2 );
                        exit( 1 );
                  }
            }
      }
      mtx[ll1] = NULL;
      return( mtx );
}

void FreeFloatHalfMtx( float **mtx, int n )
{
      int i;

      for( i=0; i<n; i++ ) 
      {
            if( mtx[i] ) FreeFloatVec( mtx[i] );
      }
      free( mtx );
}
void FreeFloatMtx( float **mtx )
{
      int i;

      for( i=0; mtx[i]; i++ ) 
      {
            FreeFloatVec( mtx[i] );
      }
      free( mtx );
}

int *AllocateIntVec( int ll1 )
{
      int *vec;

      vec = (int *)calloc( ll1, sizeof( int ) );
      if( vec == NULL )
      {     
            fprintf( stderr, "Allocation error( %d int vec )\n", ll1 );
            exit( 1 );
      }
      return( vec );
}     

void FreeIntVec( int *vec )
{
      free( (char *)vec );
}

float **AllocateFloatTri( int ll1 )
{
      float **tri;
      int i;

      tri = (float **)calloc( (unsigned int)ll1+1, sizeof( float * ) );
      if( !tri )
      {
            fprintf( stderr, "Allocation error ( float tri )\n" );
            exit( 1 );
      }
      for( i=0; i<ll1; i++ ) 
      {
            tri[i] = AllocateFloatVec( i+3 );
      }
      tri[ll1] = NULL;
            
      return( tri );
}

void FreeFloatTri( float **tri )
{
/*
      float **x;
      x = tri;
      while( *tri != NULL ) free( *tri++ );
      free( x );
*/
      int i;
      for( i=0; tri[i]; i++ ) 
            free( tri[i] );
      free( tri );
}
            
int **AllocateIntMtx( int ll1, int ll2 )
{
      int i;
      int **mtx;

      mtx = (int **)calloc( ll1+1, sizeof( int * ) );
      if( !mtx )
      {
            fprintf( stderr, "Allocation error( %d x %d int mtx )\n", ll1, ll2 );
            exit( 1 );
      }
      if( ll2 )
      {
            for( i=0; i<ll1; i++ ) 
            {
                  mtx[i] = AllocateIntVec( ll2 );
            }
      }
      mtx[ll1] = NULL;
      return( mtx );
}

/*
void FreeIntMtx( int **mtx )
{
*
      int **x;
      x = mtx;
      while( !*mtx ) free( *mtx++ );
      free( x );
*
      int i;
      for( i=0; mtx[i] != NULL; i++ ) 
            free( (char *)mtx[i] );
      free( (char *)mtx );
}
*/

char ***AllocateCharCub( int ll1, int ll2, int  ll3 )
{
      int i;
      char ***cub;

      cub = (char ***)calloc( ll1+1, sizeof( char ** ) );
      if( !cub ) 
      {
            fprintf( stderr, "Allocation error( %d x %d x %d char cube\n", ll1, ll2, ll3 );
            exit( 1 );
      }
      for( i=0; i<ll1; i++ ) 
      {
            cub[i] = AllocateCharMtx( ll2, ll3 );
      }
      cub[ll1] = NULL;
      return( cub );
}

void FreeCharCub( char ***cub )
{
      int i;

      for( i=0; cub[i]; i++ ) 
      {
            FreeCharMtx( cub[i] );
      }
      free( cub );
}

void freeintmtx( int **mtx, int ll1, int ll2 )
{
    int i;

    for( i=0; i<ll1; i++ ) 
        free( (char *)mtx[i] );
    free( (char *)mtx );
}
      
void FreeIntMtx( int **mtx )
{
      int i;

      for( i=0; mtx[i]; i++ ) 
            free( (char *)mtx[i] );
      free( (char *)mtx );
}

char ****AllocateCharHcu( int ll1, int ll2, int ll3, int ll4 )
{
      int i;
      char ****hcu;

      hcu = (char ****)calloc( ll1+1, sizeof( char *** ) );
      if( hcu == NULL ) exit( 1 );
      for( i=0; i<ll1; i++ ) 
            hcu[i] = AllocateCharCub( ll2, ll3, ll4 );
      hcu[ll1] = NULL;
      return( hcu );
}

void FreeCharHcu( char ****hcu )
{
      int i;
      for( i=0; hcu[i]; i++ )
      {
            FreeCharCub( hcu[i] );
      }
      free ( (char *)hcu );
}

double *AllocateDoubleVec( int ll1 )
{
      double *vec;

      vec = (double *)calloc( ll1, sizeof( double ) );
      return( vec );
}

void FreeDoubleVec( double *vec )
{
      free( vec );
}

int ***AllocateIntCub( int ll1, int ll2, int ll3 )
{
      int i;
      int ***cub;

      cub = (int ***)calloc( ll1+1, sizeof( int ** ) );
      if( cub == NULL )
      {
            fprintf( stderr, "cannot allocate IntCub\n" );
            exit( 1 );
      }
      for( i=0; i<ll1; i++ ) 
            cub[i] = AllocateIntMtx( ll2, ll3 );
      cub[ll1] = NULL;

      return cub;
}

void FreeIntCub( int ***cub )
{
      int i;
      for( i=0; cub[i]; i++ ) 
      {
            FreeIntMtx( cub[i] );
      }
      free( cub );
}

double **AllocateDoubleMtx( int ll1, int ll2 )
{
      int i;
      double **mtx;
      mtx = (double **)calloc( ll1+1, sizeof( double * ) );
      if( !mtx )
      {
            fprintf( stderr, "cannot allocate DoubleMtx\n" );
            exit( 1 );
      }
      if( ll2 )
      {
            for( i=0; i<ll1; i++ ) 
                  mtx[i] = AllocateDoubleVec( ll2 );
      }
      mtx[ll1] = NULL;

      return mtx;
}

void FreeDoubleMtx( double **mtx )
{
      int i;
      for( i=0; mtx[i]; i++ )
            FreeDoubleVec( mtx[i] );
      free( mtx );
}

float ***AllocateFloatCub( int ll1, int ll2, int  ll3 )
{
      int i;
      float ***cub;

      cub = (float ***)calloc( ll1+1, sizeof( float ** ) );
      if( !cub ) 
      {
            fprintf( stderr, "cannot allocate float cube.\n" );
            exit( 1 );
      }
      for( i=0; i<ll1; i++ ) 
      {
            cub[i] = AllocateFloatMtx( ll2, ll3 );
      }
      cub[ll1] = NULL;
      return( cub );
}

void FreeFloatCub( float ***cub )
{
      int i;

      for( i=0; cub[i]; i++ ) 
      {
            FreeFloatMtx( cub[i] );
      }
      free( cub );
}

double ***AllocateDoubleCub( int ll1, int ll2, int  ll3 )
{
      int i;
      double ***cub;

      cub = (double ***)calloc( ll1+1, sizeof( double ** ) );
      if( !cub ) 
      {
            fprintf( stderr, "cannot allocate double cube.\n" );
            exit( 1 );
      }
      for( i=0; i<ll1; i++ ) 
      {
            cub[i] = AllocateDoubleMtx( ll2, ll3 );
      }
      cub[ll1] = NULL;
      return( cub );
}

void FreeDoubleCub( double ***cub )
{
      int i;

      for( i=0; cub[i]; i++ ) 
      {
            FreeDoubleMtx( cub[i] );
      }
      free( cub );
}


short *AllocateShortVec( int ll1 )
{
      short *vec;

      vec = (short *)calloc( ll1, sizeof( short ) );
      if( vec == NULL )
      {     
            fprintf( stderr, "Allocation error( %d short vec )\n", ll1 );
            exit( 1 );
      }
      return( vec );
}     

void FreeShortVec( short *vec )
{
      free( (char *)vec );
}

short **AllocateShortMtx( int ll1, int ll2 )
{
      int i;
      short **mtx;


      mtx = (short **)calloc( ll1+1, sizeof( short * ) );
      if( !mtx )
      {
            fprintf( stderr, "Allocation error( %d x %d short mtx ) \n", ll1, ll2 );
            exit( 1 );
      }
      for( i=0; i<ll1; i++ ) 
      {
            mtx[i] = AllocateShortVec( ll2 );
      }
      mtx[ll1] = NULL;
      return( mtx );
}

void FreeShortMtx( short **mtx )
{
      int i;

      for( i=0; mtx[i]; i++ ) 
            free( (char *)mtx[i] );
      free( (char *)mtx );
}


Generated by  Doxygen 1.6.0   Back to index