/*
 *  ====================================================================== 
 *  Data Structures for Matrix Module                                  
 *  ====================================================================== 
 *  Copyright (C) 1993-96 by Mark Austin and David Mazzoni.
 *                                                                     
 *  This software is provided "as is" without express or implied warranty.
 *  Permission is granted to use this software on any computer system,
 *  and to redistribute it freely, subject to the following restrictions:
 * 
 *  1. The authors are not responsible for the consequences of use of
 *     this software, even if they arise from defects in the software.
 *  2. The origin of this software must not be misrepresented, either
 *     by explicit claim or by omission.
 *  3. Altered versions must be plainly marked as such, and must not
 *     be misrepresented as being the original software.
 *  4. This notice is to remain intact.
 *                                                                     
 *  Written by: M.A. Austin                           July 1992 - Jan 1993
 *  ====================================================================== 
 */

#ifndef MATRIX_H
#define MATRIX_H

/* [a] : Data Structures for Matrices of numbers/engineering quantities */

typedef struct {
        double dReal, dImaginary;
} COMPLEX;

typedef enum {
	IntegerArray  = 1,
	DoubleArray   = 2,
	ComplexArray  = 3
} DATA_TYPE;

typedef enum {
	Sequential = 1,
	Indirect   = 2,
	Skyline    = 3,
	Sparse     = 4
} INTERNAL_REP;

typedef struct MATRIX {
        char       *cpName;
        int        iNoRows;
        int     iNoColumns;
        INTERNAL_REP   Rep;
        DATA_TYPE     Type;
        union {
            int       **ipp;
            double    **dpp;
            COMPLEX   **cpp;
        } uMatrix;
} MATRIX;

/* [b] : Declarations for Root Matrix Functions */

#if (__STDC__ == 1)

 MATRIX *matCopy( MATRIX * );
 MATRIX *matTranspose( MATRIX * );
 MATRIX *matDimension( MATRIX * );
 MATRIX *matDiag( MATRIX * );
 MATRIX *matZero( MATRIX * );
 MATRIX *matOne( MATRIX * );

 MATRIX *matScale(MATRIX *, double );
 MATRIX *matScaleIndirectDouble( MATRIX *, double );

 MATRIX *matMult( MATRIX * , MATRIX * );
 MATRIX *matMultReplace( MATRIX *, MATRIX * );

 MATRIX *matAdd( MATRIX * , MATRIX * );
 MATRIX *matAddReplace( MATRIX *, MATRIX * );
 MATRIX *matSub( MATRIX * , MATRIX * );
 MATRIX *matSubReplace( MATRIX *, MATRIX * );
 MATRIX *matNegate( MATRIX * );
 MATRIX *matNegateReplace( MATRIX *);

 void    matPrint( MATRIX * );
 void    matDump( MATRIX * );
 void    matFree( MATRIX * );
 double  matDet( MATRIX * );
 double  matL2Norm( MATRIX * );

 MATRIX *matSolve( MATRIX *, MATRIX *);
 MATRIX *matLU( MATRIX * );
 MATRIX *matFB( MATRIX *, MATRIX * );

/* [c] : Matrix Functions with INDIRECT Storage Pattern */

 MATRIX   *matAllocIndirect( char *, DATA_TYPE , int , int );
 double  **matAllocIndirectDouble( int, int );
 int     **matAllocIndirectInteger( int, int );
 void      matFreeIndirectDouble( double **, int );
 void      matFreeIndirectInteger( int **, int );

 void    matPrintIndirectDouble( MATRIX * );
 void    matPrintIndirectIndirect( MATRIX * );

 MATRIX *matCopyIndirectDouble( MATRIX * );

 MATRIX *matAddIndirectDouble( MATRIX *, MATRIX *);
 MATRIX *matAddReplaceIndirectDouble( MATRIX *, MATRIX *);
 MATRIX *matSubIndirectDouble( MATRIX *, MATRIX *);
 MATRIX *matSubReplaceIndirectDouble( MATRIX *, MATRIX *);

 MATRIX *matMultIndirectDouble( MATRIX *, MATRIX *);
 MATRIX *matMultReplaceIndirectDouble( MATRIX *, MATRIX *);
 MATRIX *matMultIndirectSkylineDouble( MATRIX *, MATRIX *);
 MATRIX *matMultSkylineIndirectDouble( MATRIX *, MATRIX *);

 MATRIX *matNegateIndirectDouble( MATRIX * );
 MATRIX *matNegateReplaceIndirectDouble( MATRIX * );

 MATRIX *matTransposeIndirectDouble( MATRIX * );

 MATRIX *matLUDecompositionDouble(    MATRIX *, int * , double * );
 MATRIX *matLUBacksubstitutionDouble( MATRIX *, int * , MATRIX * );

/* [d] : Matrix Functions with SKYLINE Storage Pattern */

 MATRIX *matAllocSkyline( char *, DATA_TYPE, int, int, int *);
 void    matDumpSkyline( MATRIX * );
 void    matFreeSkyline( MATRIX * );
 void    matPrintSkylineDouble( MATRIX * );

 MATRIX *matReallocSkyline( MATRIX * );
 MATRIX *matReallocSkylineDouble( MATRIX * );

 MATRIX *matAddSkyline( MATRIX *, MATRIX * );
 MATRIX *matSubSkyline( MATRIX *, MATRIX * );
 MATRIX *matCopySkyline( MATRIX * );
 MATRIX *matScaleSkyline( MATRIX *, double );

 void matSubspace( MATRIX *, MATRIX *, MATRIX *, MATRIX  *, int );

 MATRIX *matLUDecompositionSkyline( MATRIX *);
 MATRIX *matLUBacksubstitutionSkyline( MATRIX *, MATRIX *);

 MATRIX *matIndirectToSkyline( MATRIX * );
 MATRIX *matSkylineToIndirect( MATRIX * );

 MATRIX *matAssembleSkyline( MATRIX *, MATRIX *, int *, int * );
 MATRIX *matCholeskyDecompositionIndirect( MATRIX * );
 MATRIX *ElementMassMatrix();
 MATRIX *ElementStiffnessMatrix();
 MATRIX *DestinationMatrix();

#else  /* start case not STDC */

 MATRIX *matCopy();
 MATRIX *matTranspose();
 MATRIX *matDimension();
 MATRIX *matDiag();
 MATRIX *matZero();
 MATRIX *matOne();
 MATRIX *matAdd();
 MATRIX *matAddReplace();
 MATRIX *matSub();
 MATRIX *matSubReplace();
 MATRIX *matMult();
 MATRIX *matMultReplace();
 MATRIX *matNegate();
 void    matPrint();
 void    matDump();
 void    matFree();
 double  matDet();
 double  matL2Norm();

 MATRIX *matInverse();
 MATRIX *matSolve();
 MATRIX *matLU();
 MATRIX *matFB();

/* [c] : Matrix Functions with INDIRECT Storage Pattern */

 MATRIX  *matrixAllocIndirect();
 double **matrixAllocIndirectDouble();
 double **matrixAllocIndirectInteger();

 void    matFreeIndirectDouble();
 void    matFreeIndirectInteger();

 MATRIX *matCopyIndirectDouble();

 MATRIX *matAddIndirectDouble();
 MATRIX *matAddReplaceIndirectDouble();
 MATRIX *matSubIndirectDouble();
 MATRIX *matSubReplaceIndirectDouble();
 MATRIX *matNegateIndirectDouble();
 MATRIX *matNegateReplaceIndirectDouble();

 MATRIX *matMultIndirectDouble();
 MATRIX *matTransposeIndirectDouble();

 MATRIX *matLUDecompositionDouble();
 MATRIX *matLUBacksubstitutionDouble();

/* [d] : Matrix Functions with SKYLINE Storage Pattern */

 MATRIX *matAllocSkyline();
 void    matPrintSkylineDouble();

 void    matDumpSkyline();
 void    matFreeSkyline();

 MATRIX *matReSkyline();
 MATRIX *matReSkylineDouble();

 MATRIX *matAddSkyline();
 MATRIX *matSubSkyline();
 MATRIX *matMultSkyline();

 MATRIX *matMultIndirectSkylineDouble();
 MATRIX *matMultSkylineIndirectDouble();

 MATRIX *matCopySkyline();
 MATRIX *matScaleSkyline();
 void    matSubspace();

 MATRIX *matLUDecompositionSkyline();
 MATRIX *matLUBacksubstitutionSkyline();

 MATRIX *matIndirectToSkyline();
 MATRIX *matSkylineToIndirect();

 MATRIX *MatrixAssembleSkyline();
 MATRIX *CholeskyDecompositionIndirect();
 MATRIX *ElementMassMatrix();
 MATRIX *ElementStiffnessMatrix();
 MATRIX *DestinationMatrix();

#endif /* end case not STDC */

#endif