---

AbsF4TriDiagonalLS.hpp

#ifndef __AbsF4TriDiagonalLS_H__
#define __AbsF4TriDiagonalLS_H__


#include <stdio.h>
#include "F4TriDiagonalMatrix.hpp"
#include "Float4Vector.hpp"

class AbsF4TriDiagonalLS
{
protected:

int                                             nLines; 
int                                             N;

int                                             N4;


F4TriDiagonalMatrix*    A;
Float4Vector*                   x;                                      
 
Float4Vector*                   b;                                       

public:
        
AbsF4TriDiagonalLS(int asize)
        {
        nLines= 1;

        N=asize;        
        N4= N<<2;
        
        x= new Float4Vector(N);
        b= new Float4Vector(N);

        A= new F4TriDiagonalMatrix(N);
        }

AbsF4TriDiagonalLS(int asize, int lines)
        {
        nLines= lines;

        N=asize;
        N4= N<<2;

        x= new Float4Vector(N);
        b= new Float4Vector(N);

        A= new F4TriDiagonalMatrix(N);
        }


virtual ~AbsF4TriDiagonalLS()
        { 
        delete A; 
        delete x; 
        delete b;
        }

virtual void loadA(F4TriDiagonalMatrix* m){ A->load(m); }
virtual void loadMatrix(Float4Vector* u1, Float4Vector* d1, Float4Vector* l1){ A->load(u1,d1,l1); }
virtual void loadX(Float4Vector* data){ x->load(data); }
virtual void loadB(Float4Vector* data){ b->load(data); }

virtual int numberOfLines(){return nLines;} 

virtual int size(){ return (3*N-2); }

virtual int getWidth(){ return N; }
virtual int getHeight(){ return N; }

virtual Float4Vector* getX(){ return x; }
virtual Float4Vector* getB(){ return b; }
virtual F4TriDiagonalMatrix* getA(){ return A; }

/*
virtual void solve()=0;                                                         // SOLVING 1 to 4 channels to define later

virtual void solve(Float4Vector* aX, Float4Vector* aB)  // A not changed
        {
        loadX(aX);
        loadB(aB);

        solve();
        }

virtual void solve(F4TriDiagonalMatrix* aA, Float4Vector* aX, Float4Vector* aB) // new system
        {
        loadA(aA);

        loadX(aX);
        loadB(aB);

        solve();
        }
        

virtual Float4Vector* evaluate(Float4Vector* aX, Float4Vector* aB)
        {
        solve(aX, aB);

        return getX();
        }

virtual Float4Vector* evaluate(F4TriDiagonalMatrix* aA, Float4Vector* aX, Float4Vector* aB)
        {
        solve(aA, aX, aB);

        return getX();
        }
*/      
virtual void output()
        {
        printf("Linear System\n");
        A->output();
        printf("x: "); x->output();
        printf("b: "); b->output();
        }

virtual void output(FILE* file)
        {
        fprintf(file, "Linear System\n");
        A->output(file);
        fprintf(file, "x: "); x->output(file);
        fprintf(file, "b: "); b->output(file);
        }
};

#endif

Restoreinpaint sourceforge project `C++/Java Image Processing, Restoration, Inpainting Project'.

Bernard De Cuyper: Open Project Leader: Concept, design and development. Bernard De Cuyper & Eddy Fraiha 2002, 2003. Bernard De Cuyper 2004. Open and free, for friendly usage only. Modifications on Belgium ground of this piece of artistic work, by governement institutions or companies, must be notified to Bernard De Cuyper.