Matrix.h

/********************************************************************/
/* Copyright (c) 2015 DG Technologies Inc. and Yuzi Mizuno          */
/* All rights reserved.                                             */
/********************************************************************/
#ifndef _MGMatrix_HH_
#define _MGMatrix_HH_

#include <glm/glm.hpp>
#include "mg/MGCL.h"

//  MGMatrix.h
//  Defines Class MGMatrix
//
//  Forward Declarations
class MGVector;
class MGUnit_vector;
class MGTransf;
class MGIfstream;
class MGOfstream;


class MG_DLL_DECLR MGMatrix {

public:

MG_DLL_DECLR friend MGMatrix operator* (double scale, const MGMatrix& mat);

MG_DLL_DECLR friend std::ostream& operator<< (std::ostream&, const MGMatrix&);


explicit MGMatrix(int sdim=0);

MGMatrix(const MGVector&, const MGVector&);

MGMatrix(const MGVector&, const MGVector&, const MGVector& );

MGMatrix(int dim, double scale);

MGMatrix(
    int dim,            
    const double* values,
    bool column_wise=true
);

MGMatrix(const MGVector& vec, double angle);

MGMatrix(
    int dim,    
    int axis1,      
    int axis2,      
  double cosv, 
  double sinv 
);

MGMatrix(int dim, const MGMatrix&, int start1=0, int start2=0);

MGMatrix(const MGMatrix& mat);

~MGMatrix(){if(m_matrix) delete[] m_matrix;};


MGMatrix& operator=(const MGMatrix& mat);

double operator() (int i, int j) const{return ref(i,j);}

double& operator() (int i, int j) {
    assert(i<sdim() && j<sdim());
    return m_matrix[i+j*m_sdim];
}

MGMatrix operator* (double) const;

MGMatrix& operator*= (double);

MGMatrix operator* (const MGMatrix&) const;

MGMatrix& operator*= (const MGMatrix&);

MGTransf operator* (const MGTransf&) const;

bool operator== (const MGMatrix&) const;
bool operator!= (const MGMatrix&) const;


void convert_to_glMatrix(
    glm::mat4& glMatI//double glMat[16] ///<OpenGL Matrix will be output.
)const;

double determinant() const;

MGMatrix& from_axis(
  const MGUnit_vector& uvec,
  int axis=0                
 );

bool is_null()const{return m_sdim==0;};

double ref(int i, int j) const;

MGMatrix& reflection(const MGVector& vec);

void resize(int nsdim);

int sdim() const{return m_sdim;}

MGMatrix& set_x_axis(
    const MGUnit_vector& unit 
);

MGMatrix& set_reflect_2D(const MGVector& );

MGMatrix& set_rotate_2D(double angle);

MGMatrix& set_rotate_2D(double cval, double sval);

MGMatrix& set_axis(
  const MGUnit_vector& uvec,    
  int axis=0                
);

MGMatrix& set_vector(
  const MGUnit_vector& uvec,    
  int axis=0                
);

MGMatrix& set_xy_axis(
    const MGUnit_vector& uvecx, 
    const MGUnit_vector& uvecy
);

MGMatrix& set_xy_vector(
    const MGUnit_vector& uvecx, 
    const MGUnit_vector& uvecy
);

MGMatrix& set_reflect_3D (const MGVector&  vec);

MGMatrix& set_rotate(const MGVector& V0, const MGVector& V1);

MGMatrix& set_rotate_3D (const MGVector& vec, double angle);

MGMatrix& set_rotate_3D (const MGVector& vec, double cval, double sval);

MGMatrix& set_scale (double);

MGMatrix& set_diff_scale (double*);

MGMatrix& set_glMatrix(const double glMat[16]);

void set_null();

MGMatrix transpose() const;

MGMatrix& to_axis(
    const MGUnit_vector& uvec,  
    int axis=0              
);

int dump_size() const;

int dump(MGOfstream& ) const;

int restore(MGIfstream& );

double scale()const;


private:

    int m_sdim;     
    double* m_matrix;   
  
private:

MGMatrix multiply(const MGMatrix& m2) const;

};
    
MG_DLL_DECLR MGVector operator* (const MGVector& v, const MGMatrix& m);

MG_DLL_DECLR MGVector& operator*= (MGVector& v, const MGMatrix& m);

MG_DLL_DECLR MGUnit_vector& operator*= (MGUnit_vector& v,const MGMatrix&);
 // end of BASE group
#endif