dyad.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2006 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: dyad.h,v $ $Revision: 1.10 $ $State: Exp $
*******************************************************************************/

#ifndef dyad_H_
#define dyad_H_

#include "geometry/geometryDefines.h"
#include <matrix/LibMatrix.h>

class DtMVector;

enum DtMatrixFlag
{
   IncompatibleMatrixSizes =   1
};

// The static variables allow for different offsets for the
// Matrix indexing. All instantiations of the matrix will 
// use the same indexing.
//
class DT_DLL_geometry DtMatrix
{
   friend class DtMVector;
   friend class DtLinearSystem;

   friend DtMatrix * DtMatrixMultiply(DtMatrix * m1,DtMatrix * m2, const char * s=0,generic_mm_multflag f=TRANSPOSE_NONE);
   friend DtMatrix * DtMatrixMultiply(DtMatrix * m,DtMVector * v, const char * s=0,generic_mm_multflag f=TRANSPOSE_NONE);
   friend DtMatrix * DtMatrixMergeVertically(DtMatrix * myMatT, DtMatrix * myMatB);
   friend DtMatrix * DtMatrixMergeHorizontallyWithTranspose(DtMatrix * matL,DtMatrix * matR);
   friend DtMatrix * DtMatrixMergeHorizontally(DtMatrix * matL, DtMatrix * matR);
   friend DtMatrix * DtMatrixScale(DtMatrix * m,double s);
   
   friend bool DtIntersectionUniqueSolution(const DtVector& loc1,
                                            const DtVector& loc2, 
                                            const DtDcm& m1,
                                            const DtDcm& m2);

   friend DtMatrix * DtMAdd(DtMatrix * myMatA,DtMatrix * myMatB);
   friend DtMatrix * DtMSubtract(DtMatrix * myMatA,DtMatrix * myMatB);
   friend DtMatrix * DtMSum(DtMatrix * myMatA,DtMatrix * B,double s);
   friend void LinearSystem(DtMatrix * myMatA, DtMatrix * myMatB, DtMatrix * myMatC, DtMatrix * myMatD, DtMVector * myMatX, DtMVector * myMatU, DtMVector * myMatY);
public:
   DtMatrix();
   DtMatrix(int a, int b, bool init = true, int c=-1, int r=-1);
   DtMatrix(DtMatrix* matM, bool copy = false);

   double**  Init(int a, int b, bool init, int c=-1, int r=-1);
   double**  Init(DtMatrix* matM, bool copy = false);

   void UnInit();
   virtual ~DtMatrix();

   DtMatrix* next;

   int rows(){return myRows;}
   int columns(){return myColumns;}

   double get(int i,int j);
   bool set(int i, int j, double val);

   static int rstart;   // Initial r index. 
   static int cstart;   // Initial c index.

   double** data ;   // Uses flexible array indexing.

   void print( const char * str);

   void setRows(int nR)
   {
      if(!myMaxRows)
      {
          myMaxRows=myRows;
          myRows=nR;
      }
   }
                  
   void setColumns(int nC)
   {
      if(!myMaxColumns)
      {
         myMaxColumns=myColumns;
         myColumns=nC;
      }
   }


   void restoreRows()
   {
      if(myMaxRows)
      {
          myRows=myMaxRows;
          myMaxRows=0;
      }
   }
   void restoreColumns()
   {
      if(myMaxColumns)
      {
          myColumns=myMaxColumns;
          myMaxColumns=0;
      }
   }

   void identity(bool clear=false);
   void all(double val);

   void        AXB(DtMatrix*  myMatB, DtMatrix* result);//Mike
   DtMatrix*   AXB(DtMatrix*  myMatB);
   DtMatrix*   AXBT(DtMatrix*  myMatB);

   bool        UXB(DtMatrix*  myMatB);
   bool        LXB(DtMatrix*  myMatB);

   DtMatrix*   UnMergeHorizontally(int c, DtMatrix* matR);
   DtMatrix*   UnMergeVertically(int r, DtMatrix* myMatB);

   DtMVector*  House(int rs, int nc); 
   DtMVector*  HouseT(int rs, int nc); 

   bool        RHouse(DtMVector* house, int rs, int cs);
   bool        CHouse(DtMVector* house, int rs, int cs);

   DtMatrix*   QR(DtMatrix* matQ = 0);
   DtMatrix*   LQ(DtMatrix* matQ = 0);

   DtMatrix*   SQRT(DtMatrix* matDiag);
   DtMatrix*   LDU(DtMatrix*, DtMatrix*, DtMatrix*);

   void        Scale(double s);
   void        Accumulate(DtMatrix* myMatB, double s);

   void        SetIndexes(int i, int j);
   DtMVector*  LinProg(DtMVector* myMatB, DtMVector* max);

   void        IntersectionInit();
protected:
   int Status(DtMatrixFlag);

private:
   int             myRows;
   int            myColumns;
   int             myMaxRows;
   int            myMaxColumns;
   double**         myData;
   double**       myVData;
   bool              myUsed;

   // Experimental switch submatrix on the fly.
   double**       Data;
   double**       Data_data;
   double**       DataInit(int r,int c);
};


// The internal representation of 
// vectors are potentially different. To facilitate
// the common notion of a DtVector some changes are made;
// these changes are transparent to the proper use of
// DtMatrix Routines. data[i][j] will still work.
// We can now also use vec[k];
//
class DT_DLL_geometry DtMVector : public DtMatrix
{
   friend class DtMatrix;
   friend class DtLinearSystem;
   friend DtMatrix* DtMatrixMultiply(DtMatrix* m, DtMVector* v, const char* s, generic_mm_multflag f);
   
   friend bool DtIntersectionUniqueSolution(const DtVector& loc1,
                                            const DtVector& loc2, 
                                            const DtDcm& m1,
                                            const DtDcm& m2);

   friend DtMatrix* DtMAdd(DtMVector* myMatA, DtMVector* myMatB);
   friend DtMatrix* DtMSubtract(DtMVector* A, DtMVector* myMatB);
   friend DtMatrix* DtMSum(DtMVector* myMatA, DtMVector * myMatB, double s);
   friend void LinearSystem(DtMatrix* myMatA, DtMatrix* myMatB, DtMatrix* myMatC, DtMatrix* myMatD, DtMVector* myMatX, DtMVector* myMatU, DtMVector* myMatY);
   friend bool DtIntersection2(const DtVector& loc1, const DtVector& loc2, const DtDcm& m1, const DtDcm& m2, DtVector& l1, DtVector& l2);

public:
   DtMVector(int a, int bcolumnvector, bool initialize = true, int p = -1);
   DtMVector(DtMVector* V, bool copy = false);

   virtual     ~DtMVector();
   double      get(int i);
   bool        set(int i, double val);
   DtMatrix*   GenerateN(DtMatrix* mata);
   void        Accumulate(DtMVector* myMatB, double s, DtMatrix* myMatA);
   int         size(){return mySize;}
   void        unit(int i);
   double*     vec;
private:
   double*     myVec;
   int          mySize;
};


class DT_DLL_geometry DtLinearSystem
{
public:
   DtLinearSystem(int _dim_X, int _dim_U, int _dim_Y, bool init=true,int c=-1,int r=-1);
   DtMatrix myMatA;
   DtMatrix myMatB;
   DtMatrix myMatC;
   DtMatrix myMatD;
   DtMatrix myMatX;
   DtMatrix myMatU;
   DtMatrix myMatY;
   int myDimX;
   int myDimU;
   int myDimY;

private:
   DtMatrix myMatZ;
   DtMatrix myMatT;

};



void simplx(double ** a, int m,int n,int m1,int m2, int m3, int * icase, int * izrov, int * ipposv);
void simp1(double ** a, int mm, int * ll, int nll, int iabf, int * kp, double * bmax) ;
void simp2(double ** a, int n, int * l2, int nl2,int * ip, int kp,double * q1);
void simp3(double ** a,int i1, int k1, int ip, int kp);
void print(double ** a,int r, int c,const char *str);

#endif //_DYAD_H_