SNgeneric.h

Go to the documentation of this file.

/*
Copyright 2017 Laurent Claessens
contact : laurent@claessens-donadello.eu

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 __SNGENERIC_H__142708_
#define __SNGENERIC_H__142708_

#include <cmath>
#include <array>
#include <string>

#include "SNgaussian.h"
#include "SNline.h"
#include "m_num.h"

#include "MathUtilities.h"
#include "../Utilities.h"


// forward
template <class T,unsigned int tp_size>
class SNgaussian;

template <class T,unsigned int tp_size>
class SNgeneric
{
    private :

        virtual T _get(const m_num,const m_num) const=0;

        virtual T& _at(const m_num,const m_num)=0;


        virtual void checkRangeCorectness(const m_num&,const m_num&) const final;
    public:
        virtual unsigned int getSize() const final;

        virtual T& at(const m_num,const m_num) final;
        virtual T get(const m_num,const m_num) const final;

        virtual SNline<T,tp_size> getSNline(m_num l) const;

        template <class V,unsigned int s>
        void subtract(const SNgeneric<V,s>&);
        template <class V,unsigned int s>
        void subtract(const SNgaussian<V,s>&);

        SNgaussian<T,tp_size> getGaussian(const m_num c) const;

        template <class V,unsigned int s>
        bool isNumericallyEqual(const SNgeneric<V,s>& A,const double& epsilon) const;
};


// UTILITIES --------------------------

template <class T>
class SpecialValue
{
    public :
        T value;
        bool special;
        SpecialValue(T v,bool s) :
            value(v),
            special(s)
        {}
};

template <class T,unsigned int tp_size>
void SNgeneric<T,tp_size>::checkRangeCorectness(const m_num& l,const m_num& c) const 
{
    if (l>tp_size or c>tp_size)
    {
        throw SNoutOfRangeException(l,c,getSize());
    }
}

template <class T,unsigned int tp_size>
SNline<T,tp_size> SNgeneric<T,tp_size>::getSNline(m_num l) const
{
    std::array<T,tp_size> al;
    for (m_num c=0;c<tp_size;c++)
    {
        al.at(c)=this->get(l,c);
    }
    return SNline<T,tp_size>(al);
}

// OPERATORS ------------------------------

template <class V,unsigned int s>
std::ostream& operator<<(std::ostream& stream,const SNgeneric<V,s>& snm)
{
    const unsigned int tp_size=s;     // homogenize the notations.
    std::array<int,tp_size> col_size;

    // - we parse each column to know its size (max length of the elements).
    // - the size of the columns are stored in `col_size`
    // - we parse the matrix line by line, adding the right 
    //   amount of ' ' (blanck) to fit the length of the column 
    //   (+2 for aesthetics)

    for (m_num col=0;col<tp_size;++col)
    {
        unsigned int acc=0;
        for (m_num line=0;line<tp_size;++line)
        {
            V value = snm.get(line,col);
            unsigned int l_value = value_length(value);

            if (l_value>acc)
            {
                acc=l_value;
            }
        }
        col_size.at(col)=acc;
        col_size.at(col)=10;
    }

    for (m_num l=0;l<tp_size;l++)
    {
        for (m_num c=0;c<tp_size;++c)
        {
            V value = snm.get(l,c);
            stream<<value<<std::string(col_size.at(c)-value_length(value)+2,' ');
        }
        stream<<std::endl;
    }
    return stream;
}

// GET SIZE ------------------------------

template <class T,unsigned int tp_size>
unsigned int SNgeneric<T,tp_size>::getSize() const
{
    return tp_size;
}

// GET AND AT METHODS ------------------------------

template <class T,unsigned int tp_size>
T SNgeneric<T,tp_size>::get(const m_num i,const m_num j) const
{
    checkRangeCorectness(i,j);
    return _get(i,j);
}

template <class T,unsigned int tp_size>
T& SNgeneric<T,tp_size>::at(const m_num i,const m_num j)
{
    checkRangeCorectness(i,j);
    return _at(i,j);
}


// MATHEMATICAL FUNCTIONALITIES ------------------------


template <class T,unsigned int tp_size>
SNgaussian<T,tp_size> SNgeneric<T,tp_size>::getGaussian(const m_num c) const
{
    return SNgaussian<T,tp_size>(*this,c);
}


template <class T,unsigned int tp_size>
template <class V,unsigned int s>
void SNgeneric<T,tp_size>::subtract(const SNgeneric<V,s>& S)
{
    checkSizeCompatibility(*this,S);
    for (m_num i=0;i<tp_size;i++)
    {
        for (m_num j=0;j<tp_size;j++)
        {
            this->at(i,j)-=S.get(i,j);
        }
    }
}

template <class T,unsigned int tp_size>
template <class V,unsigned int s>
void SNgeneric<T,tp_size>::subtract(const SNgaussian<V,s>& G)
{
    checkSizeCompatibility(*this,G);
    m_num c=G.getColumn();

    // subtract the non trivial "half column"
    for (m_num i=c+1;i<tp_size;i++)
    {
        this->at(i,c)-=G.get(i,c);
    }
    // subtract the diagonal
    for (m_num i=0;i<tp_size;i++)
    {
        this->at(i,i)-=1;
    }
}

template <class T,unsigned int tp_size>
template <class V,unsigned int s>
bool SNgeneric<T,tp_size>::isNumericallyEqual(const SNgeneric<V,s>& A,const double& epsilon) const
{

    //tooGenericWarning("This is a very generic comparison function SNgeneric Vs SNgeneric. Cant'you be more specific ?");

    checkSizeCompatibility(*this,A);
    T abs_diff;
    for (m_num i=0;i<tp_size;i++)
    {
        for (m_num j=0;j<tp_size;j++)
        {
            abs_diff=std::abs(  this->get(i,j)-A.get(i,j)  );
            if (abs_diff>epsilon)
            {
                return false;
            }
        }
    }
    return true;
}

#endif