MC_matrix.hpp

Go to the documentation of this file.

/*
**    Mesh Converter
**    Copyright (C) 2009 Damien Rohmer
**
**    This program 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.
**
**   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef         MC_MATRIX_N_H_
# define        MC_MATRIX_N_H_


#include <MC_double_vector.hpp>

#include <iostream>



namespace mesh_conv
{

    class MC_int_vector;
    class MC_v3d;
    class MC_v4d;
    class MC_v3d_vector;




    class MC_matrix
    {
    public:


        //************************************************//
        //************************************************//
        //CONSTRUCTORS
        //************************************************//
        //************************************************//

        MC_matrix();
        MC_matrix(const int& size_col,const int& size_row);
        MC_matrix(const int& size_col);
        MC_matrix(const MC_matrix& size_row);
        MC_matrix(const MC_v3d& v);
        MC_matrix(const MC_v3d& v1,const MC_v3d& v2);
        MC_matrix(const MC_v3d& v1,const MC_v3d& v2,const MC_v3d& v3);
        MC_matrix(const MC_v3d_vector& v);
        MC_matrix(const MC_double_vector& column);


        ~MC_matrix();



        //************************************************//
        //************************************************//
        //Size
        //************************************************//
        //************************************************//

        void check_integrity() const;

        MC_matrix& clear();

        int size_1() const;
        int size_2() const;
        MC_int_vector size() const;
        int size_vec() const;


        MC_matrix& resize(const MC_int_vector& new_size) ;
        MC_matrix& resize(const int& size_1,const int& size_2=-1) ;
        MC_matrix& resize_1(const int& size_1) ;
        MC_matrix& resize_2(const int& size_2) ;


        MC_matrix reshaped_1(const int& size_1) const;
        MC_matrix reshaped_2(const int& size_2) const;
        MC_matrix reshaped(const MC_int_vector& new_size) const;
        MC_matrix reshaped(const int& new_size_1,const int& new_size_2) const;

        MC_matrix repmat(const int& k_repeat) const ;
        MC_matrix repmat(const int& k_repeat_1,const int& k_repeat_2) const ;
        MC_matrix repmat(const MC_int_vector& k_repeat) const ;
        MC_matrix repmat_1(const int& k_repeat_1) const ;
        MC_matrix repmat_2(const int& k_repeat_2) const ;

    

        //************************************************//
        //************************************************//
        //Access
        //************************************************//
        //************************************************//


        MC_matrix& set_block(const MC_int_vector& index_1,const MC_int_vector& index_2,const MC_matrix& block);
        MC_matrix& set_block(const int& start_x,const int& end_x,const int& start_y,const int& end_y,const MC_matrix& block);

        const double& to_double() const;
        const MC_double_vector& to_vec () const;

        MC_matrix& add_row(const MC_v3d& x0) ;
        MC_matrix& add_row(const MC_v3d& x0,const MC_v3d& x1) ;
        MC_matrix& add_row(const MC_v3d& x0,const MC_v3d& x1,const MC_v3d& x2);
        MC_matrix& add_row(const MC_double_vector& col);
        MC_matrix& set_row(const int& id_row,const MC_double_vector& row);
        MC_double_vector get_row(const int& k_index) const;



        MC_matrix& add_col(const MC_v3d& x0);
        MC_matrix& add_col(const MC_v3d& x0,const MC_v3d& x1);
        MC_matrix& add_col(const MC_v3d& x0,const MC_v3d& x1,const MC_v3d& x2);
        MC_matrix& add_col(const MC_double_vector& col);

        MC_matrix& set_col(const int& id_col,const MC_double_vector& col);
        MC_double_vector get_col(const int& k_index) const;

        MC_matrix to_matrix4() const;
        std::pair <MC_matrix,MC_v3d> to_matrix3() const;


        //************************************************//
        //************************************************//
        //INIT
        //************************************************//
        //************************************************//

        static MC_matrix zeros(const int& size_1,const int& size_2);
        static MC_matrix zeros(const int& size);

        static MC_matrix identity(const int& size);

        static MC_matrix rotation_axis_to_axis(const MC_v3d& a1,const MC_v3d& a2);

        static MC_matrix rotation_registration(const MC_matrix& X,const MC_matrix& X0);
  
        static MC_matrix rotation(const MC_v3d& axis,const double& angle);
        static std::pair <MC_matrix,std::vector<MC_matrix> > rotation_axis_to_axis_with_gradient(const MC_v3d& a0,const MC_v3d& a1);

        static MC_matrix translation(const MC_v3d& tr);

        static MC_matrix scaling(const double& s);
        static MC_matrix scaling(const double& sx,const double& sy,const double& sz);

        //************************************************//
        //************************************************//
        //Math operator
        //************************************************//
        //************************************************//
  
        MC_matrix transposed() const;

        MC_matrix inverted() const;



        double norm_2() const;



  

        MC_matrix log_m(int *error_bit=0) const;
//        /** \brief return the log matrix if exists without the error_bit
//            \sa MC_matrix log_m(int *error_bit) const; */
//        MC_matrix log_m() const;

        MC_matrix pow_m(const int& k_pow) const;

        MC_matrix exp_m() const;


        MC_matrix lsqr_invert() const;

        std::pair<MC_matrix,MC_matrix> polar_decomposition() const;

        static std::pair<std::vector <MC_matrix>,std::vector <MC_matrix> > polar_decomposition(const std::vector <MC_matrix>& v_m);


        double trace() const;


        static MC_matrix kronecker(const MC_double_vector& v1,const MC_double_vector& v2);



        MC_matrix componentwise(const MC_matrix& M1) const;




        MC_matrix& operator+=(const double& a);
        MC_matrix& operator+=(const MC_matrix& M);
        MC_matrix& operator*=(const double& a);
        MC_matrix& operator/=(const double& a);



        friend MC_matrix operator+(const MC_matrix& M1,const double& alpha);
        friend MC_matrix operator+(const double& alpha,const MC_matrix& M1);
        friend MC_matrix operator+(const MC_matrix& M1,const MC_matrix& M2);


        friend MC_matrix operator-(const MC_matrix& M1,const double& alpha);
        friend MC_matrix operator-(const double& alpha,const MC_matrix& M1);
        friend MC_matrix operator-(const MC_matrix& M1,const MC_matrix& M2);

        friend MC_matrix operator*(const MC_matrix& M1,const double& alpha);
        friend MC_matrix operator*(const double& alpha,const MC_matrix& M1);
        friend MC_matrix operator*(const MC_matrix& M1,const MC_matrix& M2);
        friend MC_matrix operator*(const MC_matrix& M1,const MC_v3d& V);
        friend MC_double_vector operator*(const MC_matrix& M1,const MC_double_vector& v);

        MC_matrix& operator*=(const MC_matrix& M1);



        friend MC_matrix operator/(const MC_matrix& M1,const double& alpha);
        friend MC_matrix operator/(const double& alpha,const MC_matrix& M1);

        void internal_product(MC_v3d* to_multiply) const;
        void internal_product(MC_v4d* to_multiply) const;

        MC_matrix& add_translation(const MC_v3d& tr);

        //************************************************//
        //************************************************//
        //Get operator
        //************************************************//
        //************************************************//
  
        double& operator()(const int& k1,const int& k2);
        const double& operator()(const int& k1,const int& k2) const;
        double& operator()(const int& k_index);
        const double& operator()(const int& k_index) const;
        MC_matrix operator()(const MC_int_vector& k_index);

        MC_matrix operator()(const MC_int_vector& index_1,const MC_int_vector& index_2) const;
        MC_matrix operator()(const std::string& string_index_1,const std::string& string_index_2);
        MC_matrix operator()(const std::string& string_index);

        MC_v3d translation_part() const;

        MC_matrix& set_translation(const MC_v3d& tr);

        MC_matrix& set_rotation(const MC_matrix& m);

        const double* pointer() const;

        //************************************************//
        //************************************************//
        //Input / Output
        //************************************************//
        //************************************************//


        friend std::ostream& operator << (std::ostream& stream,const MC_matrix& _M);

        std::string to_string() const;

        static MC_matrix transformation(const std::string& input);


        //************************************************//
        //************************************************//
        //should go in tensor
        //************************************************//
        //************************************************//

        //2d Tensor
        static std::pair<MC_v3d,MC_v3d> tensor_to_axes(const MC_matrix& T);
        //3rd value must be 0
        static MC_matrix axes_to_tensor(const MC_v3d& e0,const MC_v3d& e1);
  

 private:

  void analyse_string(const std::string& to_analyse,int dim,int *start,double *increment,int *end) const;
  void analyse_string(const char* to_analyse,int dim,int *start,double *increment,int *end) const;


  protected:

  MC_double_vector M;

  int current_size[2];

};

}


#endif      /* !MC_matrix_H_ */