MIPMatrix.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// MIP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------





#ifndef __MATRIX_H_
#define __MATRIX_H_

//#define _NONSTD_SOURCE

#define DEBUG_MEM      0

#ifdef MIP_HOST_APPLE
#include </usr/include/time.h>
#include <ctime>
#endif

#include <assert.h>
#include <stdio.h>
#include <iostream>
#include <sstream>
#include <vector>

#include <Types.h>
//#include <R2.h>



using namespace std;

namespace MipBaselib{


/* @{ */


typedef enum {
 IDENTITY_MATRIX,
 ZERO_MATRIX,
 NUM_CANONICAL_MATRIX
} CanonicalMIPMatrix;

static const char* CanonicalMIPMatrixName[NUM_CANONICAL_MATRIX] ={
 "IDENTITY_MATRIX",
 "ZERO_MATRIX"
};

struct MIPMatrix{
 public:
  int rows;
  int cols;
  Decimal **elms;
 
  /*costr*/
  MIPMatrix(int r,int c,CanonicalMIPMatrix init=ZERO_MATRIX){
//   printf("DEBUG MIPMatrix def-costr\n");
  
   assert(r>0);
   assert(c>0);
   rows = r;
   cols = c;
   if(DEBUG_MEM) cout << "DEBUG sto per costruire elms << "<< rows<<" << "<<cols << endl;
   elms = (Decimal**)new Decimal*[rows]; /*allocazione della matrice*/
   for(int k = 0; k<rows; k++)  elms[k] = (Decimal*) new Decimal[cols];
  
   for(int i = 0; i<rows; i++)
    for(int j = 0; j<cols; j++) elms[i][j] = 0.0;
   if(init==IDENTITY_MATRIX){
    assert(cols==rows);
    for(int i = 0; i<cols; i++) elms[i][i] = 1.0;
   }
//     printf("Ended succesfully\n");
  }

  /*Default constructor only for 4x4 identity matrix. RotoTranslation matrix.*/
  MIPMatrix()
  {
   rows = 4;
   cols = 4;
   if(DEBUG_MEM) cout << "DEBUG sto per costruire elms << "<< rows<<" << "<<cols << endl;
   elms = (Decimal**)new Decimal*[rows]; /*allocazione della matrice*/
   for(int k = 0; k<rows; k++)  elms[k] = (Decimal*) new Decimal[cols];
  
   for(int i = 0; i<rows; i++)
    for(int j = 0; j<cols; j++) 
              if(i == j) 
          elms[i][i] = 1.0;
       else   
          elms[i][j] = 0.0;
  }


  /*copy construtctor*/
  MIPMatrix(const MIPMatrix &A){
//   printf("DEBUG MIPMatrix copy-costr\n");
   rows=A.rows;
//   cout << "DEBUG rows = " << rows << endl;
   cols=A.cols;
//   cout << "DEBUG cols = " << cols << endl;
   elms = (Decimal**)new Decimal*[rows]; /*allocazione della matrice*/
   for(int k = 0; k<rows; k++)  elms[k] = (Decimal*) new Decimal[cols];
  
   for(int i = 0; i<rows; i++)
    for(int j = 0; j<cols; j++) elms[i][j] = A.elms[i][j];
//   printf("Ended succesfully\n");
  }
 
  /*destr*/
  ~MIPMatrix(){
   if(DEBUG_MEM) cout << "DEBUG elimino matrice modded "<<rows<<"x"<<cols<<endl;
//   print();
   
   for(int k = 0; k<rows; k++)  delete elms[k];
   delete elms;
   
  }
 
  /*special operators*/
  void eq(MIPMatrix &A);
  void sum(MIPMatrix &A, MIPMatrix &B);
  void sub(MIPMatrix &A, MIPMatrix &B);
  void mul(MIPMatrix &A, MIPMatrix &B);
  void trans(MIPMatrix &A);
  void MinorMatrix(MIPMatrix &A, int row, int col);//This function builds the minor matrix of an element in A matrix position (row,col)
  Decimal det22(MIPMatrix &A);
  Decimal inv22(MIPMatrix &A);
  Decimal det33(MIPMatrix &A);
  Decimal inv33(MIPMatrix &A);
  Decimal det44(MIPMatrix &A);
  Decimal inv44(MIPMatrix &A);
  Decimal det55(MIPMatrix &A);
  Decimal inv55(MIPMatrix &A);
  
  /*operators*/
  MIPMatrix& operator=(const MIPMatrix& A){
   if (this != &A){
//   printf("DEBUG MIPMatrix operator=\n");
   if((rows!=A.rows)||(cols!=A.cols)){
    /*deallocazione*/
    for(int k = 0; k<rows; k++)  delete elms[k];
    delete elms;
    /*riallocazione*/
    elms = (Decimal**)new Decimal*[A.rows]; /*allocazione della matrice*/
    for(int k = 0; k<A.rows; k++)  elms[k] = (Decimal*) new Decimal[A.cols];
    rows=A.rows;
    cols=A.cols;
   }
   for(int i = 0; i<rows; i++)
    for(int j = 0; j<cols; j++) elms[i][j] = A.elms[i][j];
   }return *this;
//   printf("Ended succesfully\n");
  }
 
 
  Decimal GetMIPMatrixVal(int r,int c)
  {
   assert(r>0);
   assert(c>0);
   assert(r<=rows);
   assert(c<=cols);
   return elms[r-1][c-1];
  }
  
  void SetMIPMatrixVal(int r,int c, Decimal val)
  {
   assert(r>0);
   assert(c>0);
   assert(r<=rows);
   assert(c<=cols);
   elms[r-1][c-1] = val;
   return;
  }

  void printMIPMatrix()
  {
    for(int i = 0; i<rows; i++)
   {
    for(int j = 0; j<cols; j++) 
       cout << elms[i][j] << "; ";
                                cout << "\n";
   }
   return;
  }

  string print(bool sameLine = false);
  void printStat(){cout << "matrice "<<rows<<"x"<<cols<<endl;}
};



};// end of namespace MipBaselib




#endif


/* @} */