/home/travis/build/lis-epfl/MAVRIC_Library/util/matrix.hpp

/*******************************************************************************
 * Copyright (c) 2009-2016, MAV'RIC Development Team
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 * may be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 ******************************************************************************/

/*******************************************************************************
 * \file    matrix.hpp
 *
 * \author  MAV'RIC Team
 * \author  Julien Lecoeur
 *
 * \brief   Templated matrix library
 *
 ******************************************************************************/


#ifndef MATRIX_HPP__
#define MATRIX_HPP__


#include <cstdint>
#include <array>
#include <initializer_list>


template<uint32_t N, uint32_t P, typename T>
class Mat;

namespace mat
{

class op
{
public:
    template<uint32_t N, uint32_t P, typename T>
    static void add(const Mat<N,P,T>& m1, const Mat<N,P,T>& m2, Mat<N,P,T>& res);


    template<uint32_t N, uint32_t P, typename T>
    static void add(const Mat<N,P,T>& m1, const T value, Mat<N,P,T>& res);


    template<uint32_t N, uint32_t P, typename T>
    static void subtract(const Mat<N,P,T>& m1, const Mat<N,P,T>& m2, Mat<N,P,T>& res);


    template<uint32_t N, uint32_t P, typename T>
    static void subtract(const Mat<N,P,T>& m1, const T value, Mat<N,P,T>& res);


    template<uint32_t N, uint32_t P, typename T>
    static void multiply(const Mat<N,P,T>& m1, const Mat<N,P,T>& m2, Mat<N,P,T>& res);


    template<uint32_t N, uint32_t P, typename T>
    static void multiply(const Mat<N,P,T>& m1, const T value, Mat<N,P,T>& res);


    template<uint32_t N, uint32_t P, typename T>
    static void transpose(const Mat<N,P,T>& m, Mat<P,N,T>& res);


    template<uint32_t N, uint32_t P, uint32_t Q, typename T>
    static void dot(const Mat<N,P,T>& m1, const Mat<P,Q,T>& m2, Mat<N,Q,T>& res);


    template<uint32_t N, typename T>
    static bool inverse(const Mat<N,N,T>& m, Mat<N,N,T>& res);


    template<uint32_t N, uint32_t P, uint32_t I, uint32_t J, uint32_t Q, uint32_t R, typename T>
    static bool insert(const Mat<N,P,T>& m1, const Mat<Q,R,T>& m2, Mat<N,P,T>& res);

    template<uint32_t N, uint32_t P, uint32_t I, uint32_t J, uint32_t Q, uint32_t R, typename T>
    static bool insert_inplace(Mat<N,P,T>& m1, const Mat<Q,R,T>& m2);


    template<uint32_t N, uint32_t P, typename T>
    static void clip(Mat<N,P,T>& m, const Mat<N,P,T>& min, const Mat<N,P,T>& max);


    template<uint32_t N, uint32_t P, typename T>
    static void clip(Mat<N,P,T>& m, float min, float max);
};

}


template<uint32_t N, uint32_t P, typename T=float>
class Mat
{
friend class mat::op;   


public:
    Mat(T value=0.0f, bool diag=false);

    Mat(const Mat<N,P>& mat);


    Mat(const std::array<T,N*P> arr);


    Mat(const std::initializer_list<T> list);


    uint32_t rows(void);


    uint32_t cols(void);


    uint32_t index(uint32_t i, uint32_t j);

    const T& operator()(const uint32_t& i, const uint32_t& j) const;
    T& operator()(const uint32_t& i, const uint32_t& j);


    const T& operator[](const uint32_t& index) const;
    T& operator[](const uint32_t& index);


    Mat add(const Mat& m) const;


    Mat add(const T value) const;


    Mat operator+(const Mat& m) const;


    Mat operator+(T value) const;


    // template<uint32_t NN, uint32_t PP, typename TT>
    template<typename TT>
    friend Mat operator+(const T value, const Mat& m);


    void add_inplace(const Mat& m);


    void add_inplace(const T value);


    void operator+=(const Mat& m);


    void operator+=(const T value);


    Mat subtract(const Mat& m) const;


    Mat subtract(const T value) const;


    Mat operator-(const Mat& m) const;


    Mat operator-(const T value) const;


    // template<uint32_t NN, uint32_t PP, typename TT>
    template<typename TT>
    friend Mat operator-(const T value, const Mat& m);


    void subtract_inplace(const Mat& m);


    void subtract_inplace(const T value);


    void operator-=(const Mat& m);


    void operator-=(const T value);

    Mat multiply(const Mat& m) const;


    Mat multiply(const T value) const;


    Mat operator*(const Mat& m) const;


    Mat operator*(const T value) const;


    template<typename TT>
    friend Mat operator*(const T value, const Mat& m);


    void multiply_inplace(const Mat& m);


    void multiply_inplace(const T value);


    void operator*=(const Mat& m);


    void operator*=(const T value);


    template<uint32_t Q>
    Mat<N,Q,T> dot(const Mat<P,Q,T>& m) const
    {
        Mat<N,Q,T> res;
        mat::op::dot(*this, m, res);
        return res;
    }


    template<uint32_t Q>
    Mat<N,Q,T> operator%(const Mat<P,Q,T>& m) const
    {
        return dot(m);
    }


    Mat<P,N,T> transpose(void) const;


    Mat<P,N,T> operator~(void) const;


    Mat inverse(bool& success) const;


    Mat inv(bool& success) const;


    template<uint32_t I, uint32_t J, uint32_t Q, uint32_t R>
    Mat insert(const Mat<Q,R,T>& m) const;


    template<uint32_t I, uint32_t J, uint32_t Q, uint32_t R>
    bool insert_inplace(const Mat<Q,R,T>& m);


    void clip(const Mat& min, const Mat& max);


    void clip(float min, float max);

private:
    std::array<T,N*P> d;   
};


typedef Mat<3, 1, float> Vector3f;


#include "matrix.hxx"


#endif /* MATRIX_HPP__ */