source: branches/lib/GDE/MAFFT/mafft-7.055-with-extensions/core/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 );
        }
        if( ll2 )
        {
                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 );
}