linearAlgebra.h

Go to the documentation of this file.

#ifndef _DLR_LINEARALGEBRA_LINEARALGEBRA_H_
#define _DLR_LINEARALGEBRA_LINEARALGEBRA_H_

#include <complex>
#include <dlrCommon/types.h>
#include <dlrNumeric/array1D.h>
#include <dlrNumeric/array2D.h>

namespace dlr {

  namespace linearAlgebra {

    void
    choleskyFactorization(const Array2D<Float64>& inputArray,
                          Array2D<Float64>& kArray,
                          bool isUpperTriangular = true);

    
    Float64
    determinant(const Array2D<Float64>& A);


    Array1D<Float64>
    eigenvaluesSymmetric(const Array2D<Float64>& inputArray);


    void
    eigenvectors(const Array2D<Float64>& inputArray,
                 Array1D< std::complex<Float64> >& eigenvalues,
                 Array2D< std::complex<Float64> >& eigenvectors,
                 bool isSortRequired = false);

    
    void
    eigenvectorsSymmetric(const Array2D<Float64>& inputArray,
                          Array1D<Float64>& eigenvalues,
                          Array2D<Float64>& eigenvectors);

  
    Array2D<Float64>
    inverse(const Array2D<Float64>& A);

  
    std::pair<Float64, Float64>
    linearFit(const Array1D<Float64>& array0,
              const Array1D<Float64>& array1);

  
    Array1D<Float64>
    linearLeastSquares(const Array2D<Float64>& A, const Array1D<Float64>& b);


    void
    linearSolveInPlace(Array2D<Float64>& A, Array1D<Float64>& b);


    void
    linearSolveInPlace(Array2D<Float64>& A, Array2D<Float64>& b);
  

    Array1D<Float64>
    linearSolveTridiagonal(const Array1D<Float64>& subDiagonal,
                           const Array1D<Float64>& centerDiagonal,
                           const Array1D<Float64>& superDiagonal,
                           const Array1D<Float64>& bVector);
  
    
    Array2D<Float64>
    pseudoinverse(const Array2D<Float64>& A);


    void
    qrFactorization(const Array2D<Float64>& inputArray,
                    Array2D<Float64>& qArray,
                    Array2D<Float64>& rArray);

    
    void
    singularValueDecomposition(const Array2D<Float64>& inputArray,
                               Array2D<Float64>& uArray,
                               Array1D<Float64>& sigmaArray,
                               Array2D<Float64>& vTransposeArray,
                               bool isNullSpaceRequired=false,
                               bool isFullRangeRequired=false);

  
    Array1D<Float64>
    singularValues(const Array2D<Float64>& inputArray);
  
  } // namespace linearAlgebra
  
} // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using linearAlgebra::determinant;
  using linearAlgebra::eigenvaluesSymmetric;
  using linearAlgebra::eigenvectorsSymmetric;
  using linearAlgebra::inverse;
  using linearAlgebra::linearFit;
  using linearAlgebra::linearLeastSquares;
  using linearAlgebra::linearSolveInPlace;
  using linearAlgebra::linearSolveTridiagonal;
  using linearAlgebra::pseudoinverse;
  using linearAlgebra::singularValueDecomposition;
  using linearAlgebra::singularValues;
  
} // namespace dlr

#endif // #ifndef _DLR_LINEARALGEBRA_LINEARALGEBRA_H_