CORE_Matrix.h

Go to the documentation of this file.

#ifndef CORE_Matrix_H
#define CORE_Matrix_H
#include "CORE_List.h"
#include "types.h"
#include <vector>
#include "CORE_SharedPointersList.h"

#include "CORE_String.h"
#include "CORE_Vector.h"
using namespace std;



template <class T>
class CORE_Matrix : public CORE_Object {
   
 
 private:
  vector< boost::shared_ptr<CORE_Vector<T> > > mMatrix; 

 
  

  
  // CONSTRUCTORS
 public:
  CORE_Matrix();  

  CORE_Matrix(const int& n);  
 
 

 
 
  // DESTRUCTORS
 public:
  virtual ~CORE_Matrix(); 
  
  
 public:
  // NEW operators 
  static inline boost::shared_ptr<CORE_Matrix<T> > New(const boost::shared_ptr<CORE_Matrix<T> >& v ) {
    boost::shared_ptr<CORE_Matrix<T> > p(new CORE_Matrix<T>(),
                                         CORE_Object::Delete()); 
    p->setThis(p);
    p->copy(v);
    return p;
  };  
  static inline boost::shared_ptr<CORE_Matrix<T> > New(const CORE_Matrix<T>& v ) {
    boost::shared_ptr<CORE_Matrix<T> > p(new CORE_Matrix<T>(),
                                         CORE_Object::Delete()); 
    p->setThis(p);
    p->copy(v);
    return p;
  }; 
  static inline boost::shared_ptr<CORE_Matrix<T> > New(const CORE_Matrix<T>* v ) {
    boost::shared_ptr<CORE_Matrix<T> > p(new CORE_Matrix<T>(),
                                         CORE_Object::Delete()); 
    p->setThis(p);
    if (v!=null) p->copy(*v);
    return p;
  };
  static inline boost::shared_ptr<CORE_Matrix<T> > New() {
    boost::shared_ptr<CORE_Matrix<T> > p(new CORE_Matrix<T>(),
                                         CORE_Object::Delete()); 
    p->setThis(p);
    return p;
  };
  static inline boost::shared_ptr<CORE_Matrix<T> > New(const int& dim) {
    boost::shared_ptr<CORE_Matrix<T> > p(new CORE_Matrix<T>(),
                                         CORE_Object::Delete()); 
    p->setThis(p);
    p->setSize(dim);
    return p;
  };
  // OPERATORS
 public:
  void getSharedPointer(boost::shared_ptr<CORE_Matrix<T> >& p){
    SP::CORE_Object r;
    CORE_Object::getSharedPointer(r);
    p=boost::dynamic_pointer_cast<CORE_Matrix<T> >(r);  
  };
  void getSharedPointer( boost::shared_ptr<const CORE_Matrix<T> >& p) const{            
    SPC::CORE_Object r;
    CORE_Object::getSharedPointer(r);           
    p=boost::dynamic_pointer_cast<const CORE_Matrix<T> >(r);                            
  }; 
 private:   
  inline boost::shared_ptr<CORE_Matrix<T> > getThis() {
    boost::shared_ptr<CORE_Matrix<T> > p;
    getSharedPointer(p);
    return p;                           
  }; 
  inline  boost::shared_ptr<const CORE_Matrix<T> > getThis() const {                                    
     boost::shared_ptr<const CORE_Matrix<T> > p;
    getSharedPointer(p);
    return p;   
  };
  public:

  inline const CORE_Vector<T>& operator[](const int& i) const { 
    ASSERT_IN(i>-1);
    ASSERT_IN(i<((int)mMatrix.size()));
    return *(mMatrix[i].get());
  };
   
  inline CORE_Vector<T>& operator[](const int& i)  {
    ASSERT_IN(i>-1);
    ASSERT_IN(i<((int)mMatrix.size()));
    return *(mMatrix[i].get());
  };

  
  // SET
  inline void setVector(const int& i,boost::shared_ptr<CORE_Vector<T> > v) {
    mMatrix[i]=v;
  };

  inline void setValue(const int& i,const int& j,const T& v) {
    (*(mMatrix[i]).get())[j]=v;
  }; 

  inline void addValue(const int& i,const T& v) {
    mMatrix[i]->add(v);
  };

  inline void setSize(const int& n){
    mMatrix.resize(n);
  };

  inline void initValues(const T& v) {
    int n=mMatrix.size();
    for(int i=0;i<n;i++) mMatrix[i]->initValues(v);
  }; 
 

  inline void add(const boost::shared_ptr<const CORE_Vector<T> > v) {
    boost::shared_ptr<CORE_Vector<T> >c=CORE_Vector<T>::New(v);
    mMatrix.pusch_back(c);
  };  
  inline void add(boost::shared_ptr<CORE_Vector<T> >v) {
    mMatrix.puch_back(v);
  }; 
 
  template<class Y> void copy(const CORE_Matrix<Y>& cmat) {
    int n=cmat.getSize();
    mMatrix.resize(n);
    for (int i=0;i<n;i++) {
      boost::shared_ptr<CORE_Vector<T> > c=CORE_Vector<T>::New();
      c->copy(cmat);
      mMatrix[i]=c;
    }
  } 
  template<class Y> void copy(const CORE_Matrix<Y>* array) {
    if (array!=null) copy(*array); 
    else setSize(0);
  } 
  template<class Y> void copy(const  boost::shared_ptr<CORE_Matrix<T> >& array) {
    copy(array.get());
  }
  tBoolean set(const int i,const int& j,const T& v) {
    if (i>=mMatrix.size()) return false;
    CORE_Vector<T> *vect=mMatrix[i].get();
    if (vect==null) return false;
    if (vect->getSize()<=j) return false;
    (*vect[j])=v;
    return true;
  };

  inline void clear(){
    setSize(0);
  };

  // GET 
 
  inline const T& get(const int& i,const int& j) const {
    ASSERT_IN(i>-1);
    ASSERT_IN(i<((int)mMatrix.size()));
    return *(mMatrix[i].get())[j];
  }; 

  inline T& get(const int& i,const int& j) {
    ASSERT_IN(i>-1);
    ASSERT_IN(i<((int)mMatrix.size()));
     return *(mMatrix[i].get())[j];
  };
  
  inline int size() const {return mMatrix.size();};
  
  inline int getSize() const {return mMatrix.size();}; 

  inline int getSize(const int& i) const {return mMatrix[i]->getSize();};

  inline int getDimension(const int& i) const {return mMatrix[i]->getSize();}; 

  inline int getDimension() const {return mMatrix.size();};
  
 
  inline const T& getValue(const int& i,const int& j) const {return* (mMatrix[i].get())[j];};
 
 

  inline CORE_Vector<T>& getVector(const int& index) {
    return *(mMatrix[index].get());
  };
  inline const CORE_Vector<T>& getVector(const int& index) const{
    return *(mMatrix[index].get());
  };



  virtual tString toString() const;
 

};

#include "CORE_Matrix.hpp"

typedef CORE_Matrix<tBoolean> CORE_BooleanMatrix;
typedef CORE_Matrix<tCharacter> CORE_CharacterMatrix;
typedef CORE_Matrix<int> CORE_IntMatrix;
typedef CORE_Matrix<tReal> CORE_RealMatrix;
typedef CORE_Matrix<tComplex> CORE_ComplexMatrix;
typedef CORE_Matrix<tFlag> CORE_FlagMatrix;
typedef CORE_Matrix<tShort> CORE_ShortMatrix;
typedef CORE_Matrix<tString> CORE_StringMatrix;
typedef CORE_Matrix<tInteger> CORE_IntegerMatrix;
typedef CORE_Matrix<tRelativeInteger> CORE_RelativeIntegerMatrix;

//share pointer of primitive type vector
TYPEDEF_SPTR(CORE_BooleanMatrix);
TYPEDEF_SPTR(CORE_CharacterMatrix);
TYPEDEF_SPTR(CORE_IntMatrix);
TYPEDEF_SPTR(CORE_RealMatrix);
TYPEDEF_SPTR(CORE_ComplexMatrix);
TYPEDEF_SPTR(CORE_FlagMatrix);
TYPEDEF_SPTR(CORE_RelativeIntegerMatrix);
TYPEDEF_SPTR(CORE_IntegerMatrix);
TYPEDEF_SPTR(CORE_StringMatrix);
TYPEDEF_SPTR(CORE_ShortMatrix); 


#endif