--- /dev/null
+#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 );
+}
+
git://source.jalview.org / jabaws.git / blobdiff