/*****************************************************************************
Copyright 1993 MBARI                                                      
******************************************************************************
Summary  : Matrix routines
Filename : Matrix.h
Author   : Michael B. Matthews                                                
Project  : New ROV                                                        
Version  : Version 1.1                                                    
Created  : August 3, 1993                                                      
Modified :                                                                
Archived :                                                                
Notes    : 
*****************************************************************************/

#ifndef Matrix_h
#define Matrix_h

#include <vxWorks.h>            	/* VxWorks systems declarations       */
#include <stdioLib.h>           	/* VxWorks standard I/O library       */
#include <math.h>              		/* VxWorks floating point math library*/
#include <semLib.h>            		/* VxWorks semaphore library          */
#include <wdLib.h>             		/* VxWorks watchdog timer library     */
#include <systime.h>           		/* VxWorks system time declarations   */
#include <strLib.h>			/* VxWorks string library             */
#include <stdlib.h>
#include <trig.h>

#include <mbari/types.h>       		/* MBARI type declarations            */
#include <mbari/usrTime.h>     		/* MBARI time declarations            */
#include <mbari/kalmanDM.h>		/* kalman data manager definitions    */
#include <mbari/sensorDcon.h>		/* sensor data concentrator definitns */
#include <mbari/vmeIbc.h>		/* VME IBC definitions                */
#include <mbari/sensorsDm.h>		/*                                    */
#include <datamgr.h>           		/* data manager declarations          */
#include <dm_errno.h>          		/* data manager error declarations    */
#include "fppLib.h"             	/* vxWorks vxTas routine definition   */

#include <string.h>
#include <types.h>

#define DIMENSION_CHECK

enum {   
  NORMAL, 
  DIAGONAL,
  TRANSPOSE, 
  UPPER_TRIANGULAR, 
  LOWER_TRIANGULAR,
  ROW,
  COLUMN};

/* define floating-point precision */
typedef Flt64 FltN;

/* vector structure */
typedef struct {
  char* name;
  Word r;
  Word state;
  FltN *s;
} Vector;

/* matrix structure */
typedef struct {
  char* name;
  Word r;
  Word c;
  Word state;
  FltN **s;
} Matrix;

Vector* Vector_Create(int);
Vector* Vector_Duplicate(Vector*);
void Vector_Destroy(Vector*);
void Vector_Zero(Vector*);
void Vector_Init(Vector*, FltN);
void Vector_Addition(Vector*, Vector*, Vector*);
void Vector_Subtraction(Vector*, Vector*, Vector*);
void Vector_Multiplication(Vector*, Vector*, Vector*);
void Vector_Scalar_Multiplication(Vector*, FltN, Vector*);
void Vector_Randomize_Uniform(Vector*, FltN);
void Vector_Randomize_Gaussian(Vector*, FltN);
void Vector_Insert(Vector*, Vector*, int);
void Vector_Extract(Vector*, Vector*, int);
void Vector_Print(Vector*);
void Vector_Copy(Vector*, Vector*);
FltN Vector_Norm(Vector*);

Matrix* Matrix_Create(int, int);
Matrix* Matrix_Duplicate(Matrix*);
void Matrix_Destroy(Matrix*);
void Matrix_Init(Matrix*, FltN);
void Matrix_Zero(Matrix*);
void Matrix_Multiplication(Matrix*, Matrix*, Matrix*);
void Matrix_Scalar_Multiplication(Matrix*, FltN, Matrix*);
void Matrix_Transpose(Matrix*);
void Matrix_Print(Matrix*);
void Matrix_Identity(Matrix*);
void Matrix_Copy(Matrix*, Matrix*);
void Matrix_Inverse(Matrix*, Matrix*);
void Matrix_Addition(Matrix*, Matrix*, Matrix*);
void Matrix_Subtraction(Matrix*, Matrix*, Matrix*);
void Matrix_Insert(Matrix*, Matrix*, int, int);
void Matrix_Extract(Matrix*, Matrix*, int, int);
void Matrix_Randomize_Uniform(Matrix*, FltN);
void Matrix_Randomize_Uniform_Symmetrical(Matrix*, FltN);
void Matrix_Randomize_Gaussian(Matrix*, FltN);
void Matrix_Power(Matrix*, Matrix*, int);
void Matrix_Output(Matrix*, FILE*);
void Matrix_Symmetrize(Matrix*);
void Matrix_Exponential(Matrix*, Matrix*);
FltN Matrix_Trace(Matrix*);
FltN Matrix_Norm(Matrix*);
Matrix* Matrix_Input(FILE*);
void Matrix_Read(Matrix*, char*);

void Matrix_Vector_Multiplication(Matrix*, Vector*, Vector*);
void Matrix_Scalar_Multiplication(Matrix*, FltN, Matrix*);

FltN Random_Uniform(FltN);
FltN Random_Gaussian(FltN);
int fact(int);
FltN power(FltN, int);

void lubksb(Matrix*, int, int*, Vector*);
void ludcmp(Matrix*, int, int*, double*);

#endif