matrix2.hpp

Go to the documentation of this file.

/*
**    TP CPE Lyon
**    Copyright (C) 2013 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 MATRIX2_HPP
#define MATRIX2_HPP

#include <iostream>
#include <vector>

#include <exception_cpe.hpp>

namespace cpe
{
class vec2;


class matrix2
{

public:

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

    matrix2();
    matrix2(float x00,float x01,
            float x10,float x11);

    // ********************************************* //
    // ********************************************* //
    //  Special initialization
    // ********************************************* //
    // ********************************************* //

    static matrix2 identity();
    static matrix2 zeros();
    static matrix2 rotation(float angle);
    static matrix2 scale(float s);
    static matrix2 scale(float s_x,float s_y);


    // ********************************************* //
    // ********************************************* //
    //  Element access
    // ********************************************* //
    // ********************************************* //

    float operator()(const size_t& k1,const size_t& k2) const;
    float& operator()(const size_t& k1,const size_t& k2);

    const float* pointer() const;
    float* pointer_unprotected();



    // ********************************************* //
    // ********************************************* //
    //  Math operator
    // ********************************************* //
    // ********************************************* //

    matrix2 operator+(const matrix2& m2) const;
    matrix2 operator+(float s) const;

    matrix2 operator-(const matrix2& m2) const;
    matrix2 operator-(float s) const;


    matrix2 operator*(float s) const;
    vec2 operator*(const vec2& v) const;
    matrix2 operator*(const matrix2& m2) const;
    matrix2 operator/(float s) const;


    matrix2& operator+=(const matrix2& m);
    matrix2& operator+=(float s);
    matrix2& operator-=(const matrix2& m);
    matrix2& operator-=(float s);
    matrix2& operator*=(float s);
    matrix2& operator/=(float s);

    matrix2 operator-() const;

    matrix2 product_compontentwise(const matrix2& m) const;
    matrix2& product_compontentwise_internal(const matrix2& m);

    matrix2 transposed() const;







    // ********************************************* //
    // ********************************************* //
    //  Projection matrix
    // ********************************************* //
    // ********************************************* //

    std::vector<float> to_vector() const;

private:

    // ********************************************* //
    // ********************************************* //
    //  Internal parameters
    // ********************************************* //
    // ********************************************* //

    float m[4];


    // ********************************************* //
    // ********************************************* //
    //  Helper
    // ********************************************* //
    // ********************************************* //

    void assert_size(const size_t& k1,const size_t& k2) const;

};

matrix2 operator+(float s,const matrix2& m);
matrix2 operator-(float s,const matrix2& m);
matrix2 operator*(float s,const matrix2& m);

// ********************************************* //
// ********************************************* //
//  Output
// ********************************************* //
// ********************************************* //

std::ostream& operator<<(std::ostream& stream,const matrix2& m);



class exception_matrix2 : public exception_cpe
{
public:

    exception_matrix2():exception_cpe(){}
    exception_matrix2(const std::string& msg_param,const std::string& file_param,const std::string& caller_param,const int& line_param):exception_cpe(msg_param,file_param,caller_param,line_param){}
};



}

#endif