/*****************************************************************************
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