SNgaussian.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 __SNgaussian_H__174236
#define __SNgaussian_H__174236

#include <array>

#include "SNgeneric.h"
#include "m_num.h"
#include "../exceptions/SNexceptions.cpp"
#include "../Utilities.h"


// forward definition
template <class T,unsigned int tp_size>
class SNgeneric;
//template <class T,unsigned int tp_size>
//class SNmatrix;
//template <class T,unsigned int tp_size>
//class SNmultiGaussian;
template <class T>
class SpecialValue;


// THE CLASS HEADER -----------------------------------------

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

    private:
        std::array<T,tp_size> data;     // see implementation of "_at"
        m_num data_column;
    
        SpecialValue<T> checkForSpecialElements(const m_num& i,const m_num& j) const;

        //** populate the matrix from the elements of the given matrix */
        template <class U,unsigned int s>
        void populate_from(const SNgeneric<U,s>&);

        SNgaussian(const std::array<T,tp_size>& d, const m_num& c);

        T _get(m_num,m_num) const override;
        T& _at(m_num,m_num) override;
    public :
        SNgaussian();

        template <class U,unsigned int s>
        SNgaussian(const SNgeneric<U,s>& A, const m_num& c=0);

        SNgaussian<T,tp_size> inverse() const;
        void setColumn(const m_num& col);
        m_num getColumn() const;
};


// GETTER/SETTER  ---------------------------------------

template <class T,unsigned int tp_size> 
void SNgaussian<T,tp_size>::setColumn(const m_num& col)
{
    if (col>tp_size-1)
    {
        throw OutOfRangeColumnNumber("The specified column number is larger than the size of the matrix.");
    }
    data_column=col;
}

template <class T,unsigned int tp_size> 
m_num SNgaussian<T,tp_size>::getColumn() const
{
    return data_column;
}

// CONSTRUCTOR  ---------------------------------------

template <class T,unsigned int tp_size> 
template <class U, unsigned int s>
void SNgaussian<T,tp_size>::populate_from(const SNgeneric<U,s>& A)
{
    m_num column=getColumn();
    if (s!=tp_size)
    {
        throw IncompatibleMatrixSizeException(tp_size,s);
    }

    T m = A.get(column,column);
    for (m_num i=column+1;i<tp_size;i++)
    {
        this->at(i,column)=-A.get(i,column)/m;
    }
}

// from a generic

template <class T,unsigned int tp_size> 
template<class U,unsigned int s>
SNgaussian<T,tp_size>::SNgaussian(const SNgeneric<U,s>& A , const m_num& c):
    data_column(c)
{
    populate_from(A);
}

// from the array

template <class T,unsigned int tp_size> 
SNgaussian<T,tp_size>::SNgaussian(const std::array<T,tp_size>& d, const m_num& c):
    data(d),
    data_column(c)
{}

// from nothing (the we leave a trash in 'data_column')

template <class T,unsigned int tp_size> 
SNgaussian<T,tp_size>::SNgaussian():
    data_column(tp_size+1)
{}

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

template <class T,unsigned int tp_size>
SpecialValue<T> SNgaussian<T,tp_size>::checkForSpecialElements(const m_num& i,const m_num& j) const
{
    if (i==j)
    {
        return SpecialValue<T>(1,true);
    }
    if (j!=getColumn())
    {
        return SpecialValue<T>(0,true);
    }
    if (i<j)
    {
        return SpecialValue<T>(0,true);
    }
    return SpecialValue<T>(0,false);
}

// _AT AND _GET METHODS ---------------------------------------

template <class T,unsigned int tp_size>
T SNgaussian<T,tp_size>::_get(m_num i,m_num j) const
{
    SpecialValue<T> sv=checkForSpecialElements(i,j);
    if (sv.special)
    {
        return sv.value;
    }
    return data.at(i-getColumn()-1);  //if you change here, you have to change _at
}

template <class T,unsigned int tp_size>
T& SNgaussian<T,tp_size>::_at(m_num i,m_num j) 

    
{
    if (data_column==tp_size+1)
    {
        throw NotInitializedMemberException("You are trying to populate a 'SNgaussian' before to initialize the member 'data_column'. Use setColumn().");
    }

    SpecialValue<T> sv=checkForSpecialElements(i,j);
    if (sv.special)
    {
        throw SNchangeNotAllowedException(i,j);
    }
    return data.at(i-getColumn()-1);  //if you change here, you have to change _get
}

// MATHEMATICS  ---------------------------------------


template <class T,unsigned int tp_size>
SNgaussian<T,tp_size> SNgaussian<T,tp_size>::inverse() const
{
    std::array<T,tp_size> new_data(data);
    for (unsigned int k=0;k<tp_size-getColumn()-1;++k)
    {
        new_data.at(k)=-new_data.at(k);
    }
    return SNgaussian(new_data,getColumn());
}

#endif