TDSPLinearSolver.h

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef TDSPLINEARSOLVER_H
#define TDSPLINEARSOLVER_H

#include <TList.h>
#include <TDSPVector.h>
#include <TDSPMatrix.h>
#include <TDSPSolver.h>

enum eLinearSolveMethod {
  kLinearSolveJacobi,
  kLinearSolveGaussSeidel,
  kLinearSolveCG,
  kLinearSolveGaussSeidelBinary,
  kLinearSolveML,
  kLinearSolveGaussSeidelQpsk,
  kLinearSolveNothing
};

class TDSPLinearSolver : public TDSPSolver  {


 protected:

  eLinearSolveMethod fMethod;

  TList       fAList; // List of Matrices

  UInt_t      fIterations; // The Number of Iterations of the last call
  UInt_t      fMaxIterations; // The maximal number of Iterations, after stopping calculations
  Double_t    fMeanIterations; // The mean number Iterations

  Double_t    fStopPrecision; // the Stop Precision of the iterations
  Double_t    fPrecision; // the last precision
  Double_t    fMeanPrecision; // The mean precision

  UInt_t      fAccumulation; // The accumulated number for making the averages

  Bool_t      fUsingAStack; 

  void        _push_means_();  // Help routine - which pushs a new values to the means
  void        _reset_means_(); // Help routine - which resets the mean-calculations

  // fY = fA * X + fB 

  TDSPVector* fB; 
  TDSPMatrix* fA; 

  TDSPVector* fGuessX; 


  // Hard Decisions

  UInt_t      fIter_Serial_HD;    // Do Serial Hard Decisions for fIterations>=fIter_Serial_HD (default=999999)
  UInt_t      fIter_Parallel_HD;  // Do Parallel Hard Decisions for fIterations>=fIter_Serial_HD (default=999999)

  // Some Helpers

  TDSPVector  Xtmp; // a temporary vector ...

 public: 

  // Constructor / Destructor

  TDSPLinearSolver(TDSPMatrix *a = NULL, TDSPVector *b=NULL,
           TDSPVector *y = NULL);

  ~TDSPLinearSolver();

  virtual void Print();

  // Get/Set Methods

  void SetMethod(eLinearSolveMethod e) { fMethod = e;}; // Set Method

  void SetA(TDSPMatrix*a);             // Set the Matrix a of the equation y=Ax+b
  void SetA(TDSPMatrix&a) { SetA(&a);}; // Set the Matrix a of the equation y=Ax+b
  void SetB(TDSPVector*b) { fB = b;};   // Set the Vector b of the equation y=Ax+b
  void SetB(TDSPVector&b) { SetB(&b);}; // Set the Vector b of the equation y=Ax+b
  void Guess(TDSPVector*g) { fGuessX = g;};   // Set the initial Guess of Vector x of the equation y=Ax+b
  void Guess(TDSPVector&g) { Guess(&g);}; // Set the initial Guess of Vector x of the equation y=Ax+b
  void Set(TDSPMatrix*a, TDSPVector *b, TDSPVector *y) { // Set Matrix a, Vector b , Vector y
    SetA(a);SetB(b);SetY(y);};

  void SetMaxIterations(UInt_t m) { fMaxIterations=m;};  // Set the maximal number of iterations
  void SetStopPrecision(Double_t e) { fStopPrecision = e;}; // Set the Stop Precision
 
  void SetSerialHD(UInt_t start) { fIter_Serial_HD = start; } // Use Serial Hard Decisions for Iterations>=start
  void SetParalleHD(UInt_t start) { fIter_Parallel_HD = start; } // Use Parallel Hard Decisions for Iterations>=start

  eLinearSolveMethod GetMethod() const { return fMethod;}; // Get Method
  eLinearSolveMethod Method() const { return fMethod;}; // Get Method

  TDSPVector* B() const    { return fB; }; // Get the Vector b of the equation y=Ax+b
  TDSPVector* GetB() const { return fB; }; // Get the Vector b of the equation y=Ax+b
  TDSPMatrix* A() const    { return fA; }; // Get the Matrix a of the equation y=Ax+b
  TDSPMatrix* GetA() const { return fA; }; // Get the Matrix a of the equation y=Ax+b

  UInt_t   GetMaxIterations() const { return fMaxIterations;};  // Get the maximal number of iterations
  UInt_t   GetIterations() const { return fIterations;};  // Get the last number of iterations
  Double_t GetMeanIterations() const { return fMeanIterations;}; // Get the mean number of iterations

  Double_t GetStopPrecision() const { return fStopPrecision;}; // Get the Stop Precision
  Double_t GetPrecision() const { return fPrecision;}; // Get the Last Precision
  Double_t GetMeanPrecision() const { return fMeanPrecision;}; // Get the Mean Precision

  UInt_t   GetSerialHD() const { return fIter_Serial_HD;};
  UInt_t   GetParallelHD() const { return fIter_Parallel_HD;};
  
  void     ResetMeans() { _reset_means_();};

  virtual Int_t GetNumInputs();
  virtual Int_t GetNumOutputs();

  Bool_t Solve();

  void StackA(TDSPMatrix*);

  ClassDef(TDSPLinearSolver,1)

};


inline Int_t TDSPLinearSolver::GetNumInputs() {
  if (fA) return fA->GetCols();
  Error("GetNumInputs","Requesting number of Inputs - but no Matrix set !");
  return 0;
}                 

inline Int_t TDSPLinearSolver::GetNumOutputs() {
  if (fA) return fA->GetRows();
  Error("GetNumOutputs","Requesting number of Outputs - but no Matrix set !");
  return 0;
}                 

inline void TDSPLinearSolver::_push_means_() {
  fMeanIterations  = (fAccumulation*fMeanIterations+fIterations);
  fMeanPrecision   = (fAccumulation*fMeanPrecision+fPrecision);
  fMeanIterations /= ++fAccumulation;
  fMeanPrecision  /= fAccumulation;
}

inline void TDSPLinearSolver::_reset_means_() {
  fAccumulation   = 0;
  fMeanIterations = 0;
  fMeanPrecision  = 0;
}

#endif

---