LeastSquares.h

Go to the documentation of this file.

#ifndef LeastSquares_h
#define LeastSquares_h

#include <vector>

#include "tnt/tnt_array2d.h"

#ifndef __sun__
#include "gmm/gmm.h"
#endif

#include "BasisFunction.h"

namespace Isis {
  class LeastSquares {
    public:

      LeastSquares(Isis::BasisFunction &basis, bool sparse = false,
                   int sparseRows = 0, int sparseCols = 0, bool jigsaw = false);
      ~LeastSquares();
      void AddKnown(const std::vector<double> &input, double expected,
                    double weight = 1.0);

      std::vector<double> GetInput(int row) const;
      double GetExpected(int row) const;
      int Rows() const;

      enum SolveMethod { SVD,     
                         QRD,     
                         SPARSE   
                       };

      int Solve(Isis::LeastSquares::SolveMethod method = SVD);
      double Evaluate(const std::vector<double> &input);
      std::vector<double> Residuals() const;
      double Residual(int i) const;
      void Weight(int index, double weight);

      int Knowns() const {
        return p_expected.size();
      };

      double GetSigma0() { return p_sigma0; }
      int GetDegreesOfFreedom() { return p_degreesOfFreedom; }
      void Reset ();

#ifndef __sun__
      void ResetSparse() { Reset(); }
      bool SparseErrorPropagation();
      std::vector<double> GetEpsilons () const { return p_epsilonsSparse; }
      void SetParameterWeights(const std::vector<double> weights) { p_parameterWeights = weights; }
      void SetNumberOfConstrainedParameters(int n) { p_constrainedParameters = n; }
      const gmm::row_matrix<gmm::rsvector<double> >& GetCovarianceMatrix () const { return p_normals; }
#endif

    private:
      void SolveSVD();
      void SolveQRD();
      void SolveCholesky () {}

#ifndef __sun__
      int SolveSparse();
      void FillSparseA(const std::vector<double> &data);
      bool ApplyParameterWeights();

      std::vector<double> p_xSparse;          
      std::vector<double> p_epsilonsSparse;   
      std::vector<double> p_parameterWeights; 
      gmm::row_matrix<gmm::rsvector<double> > p_sparseA; 
  private:
      gmm::row_matrix<gmm::rsvector<double> > p_normals; 
  private:
      gmm::dense_matrix<double> p_ATb;                   
      gmm::SuperLU_factor<double> p_SLU_Factor;          
#endif
      bool p_jigsaw;
      bool p_sparse;
      bool p_solved;  
      int p_currentFillRow;
      int p_sparseRows;
      int p_sparseCols;
      int p_constrainedParameters; 
      int p_degreesOfFreedom;      
      double p_sigma0;               
      std::vector<std::vector<double> > p_input; 
      std::vector<double> p_expected;            
      std::vector<double> p_sqrtWeight;          
      std::vector<double> p_residuals;           
      Isis::BasisFunction *p_basis; 



  };
};


#endif