---

RealBlockSMatrix.hpp

#ifndef __RealBlockSMatrix_H__
#define __RealBlockSMatrix_H__



#include <stdio.h>
#include "RealSMatrix.hpp"

class RealBlockSMatrix
{
private:

int                             width;

int                             n;
int                             localWidth;
RealSMatrix**           data;

public:
        
RealBlockSMatrix(int n, int lwidth);
RealBlockSMatrix(int n, const RealSMatrix& m);
RealBlockSMatrix(const RealBlockSMatrix& m);
RealBlockSMatrix operator=(const RealBlockSMatrix& m);

~RealBlockSMatrix();

RealBlockSMatrix* copy();

RealBlockSMatrix* AtA(RealBlockSMatrix* dest=0);

RealBlockSMatrix t();

int numberOItems(){ return n*n; }
int getXitems(){ return n; }
int getYitems(){ return n; }

int getItemWidth()const { return localWidth; }
int getItemHeight()const { return localWidth; }

int size(){ return width*width; }

int getWidth()const { return width; }
int getHeight()const { return width; }

// item base 0
void set0(int i, int j, RealSMatrix* value){ data[i][j]= value; }
RealSMatrix* get0(int i, int j)const { return data[i][j]; }

// item base 1
void set(int i, int j, RealSMatrix* value){ data[i-1][j-1]= value; }
RealSMatrix* get(int i, int j)const { return data[i-1][j-1]; }


// base 0
void set0(int i, int j, double value);
double get0(int i, int j)const;

// base 1
void set(int i, int j, double value);
double get(int i, int j)const;

// computations
void setAll(double value=0.0);
void set(RealBlockSMatrix* from);

// optimized transform (reduced cons)
RealBlockSMatrix* multA_X(RealBlockSMatrix* dest);                                      // X <-- A*X
 
void addA_kX(RealBlockSMatrix& dest, double k=1.0);                             // A <-- A+k*X 
void addA_k_vvT(RealVector& v, double k=1.0);                           // A <-- A+k*(v*vT) 
double vTAv(RealVector& v);                                                     // quadratic form: vT*A*v 
double rayleighQuotient(RealVector& v){return vTAv(v)/v.vT_v();}        // r= vT*A*v/(vT*v) approximates an eigenvalue 

double det();
double trace();
double cond();

// norm
double normeMin();
double normeInfinite();
double norme2();                        // spectral norme= sqrt( max eigenvalue )
double normeF();                        // frobenius norme      

double sum();

double minimum();
double maximum();
double mean(){ return sum()/size(); }
double sigma();

// matrix generation
RealBlockSMatrix* jacobiEV(RealVector* dEigenValue, RealBlockSMatrix* vEigenVector); // Numerical Recipes p365-6

// math vectorial op
RealBlockSMatrix sqrt();
RealBlockSMatrix pow(double pow);
RealBlockSMatrix sqr();
RealBlockSMatrix exp();
RealBlockSMatrix log();
RealBlockSMatrix log(double base);

RealBlockSMatrix sin();
RealBlockSMatrix cos();
RealBlockSMatrix tan(); 

// matrix operations
// =================

// scalar single operations
void operator+=(double value);
void operator-=(double value);
void operator*=(double value);
void operator/=(double value);

// matrix single operations
void operator+=(const RealBlockSMatrix& m);
void operator-=(const RealBlockSMatrix& m);
void operator*=(const RealBlockSMatrix& m);

// friends
friend RealVectorT operator*(const RealVectorT& vt, const RealBlockSMatrix& m); 
friend RealVector operator*(const RealBlockSMatrix& m, const RealVector& v);    
        
void output();
void output(FILE* 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.