SVD.h

 
// Description: An abstract class defining the interface to the generic SVD
//              algorithm.
 
#ifndef included_SVD_h
#define included_SVD_h
 
#include "linalg/Matrix.h"
#include "linalg/Options.h"
#include <vector>
 
namespace CAROM {
 
class SVD
{
public:
    SVD(
        Options options);
 
    virtual
    bool
    takeSample(
        double* u_in,
        bool add_without_increase) = 0;
 
    int
    getDim() const
    {
        return d_dim;
    }
 
    virtual
    std::shared_ptr<const Matrix>
    getSpatialBasis() = 0;
 
    virtual
    std::shared_ptr<const Matrix>
    getTemporalBasis() = 0;
 
    virtual
    std::shared_ptr<const Vector>
    getSingularValues() = 0;
 
    virtual
    std::shared_ptr<const Matrix>
    getSnapshotMatrix() = 0;
 
    int getNumSamples() const
    {
        return d_num_samples;
    }
 
    int getMaxNumSamples() const
    {
        return d_max_num_samples;
    }
 
protected:
    bool
    isFirstSample() const
    {
        return (d_num_samples == 0);
    }
 
    const int d_dim;
 
    int d_num_samples;
 
    int d_num_rows_of_W;
 
    const int d_max_num_samples;
 
    std::shared_ptr<Matrix> d_basis;
 
    std::shared_ptr<Matrix> d_basis_right;
 
    std::shared_ptr<Matrix> d_U;
 
    std::shared_ptr<Matrix> d_W;
 
    std::shared_ptr<Vector> d_S;
 
    std::shared_ptr<Matrix> d_snapshots;
 
    bool d_debug_algorithm;
 
private:
    SVD();
 
    SVD(
        const SVD& other);
 
    SVD&
    operator = (
        const SVD& rhs);
};
 
}
 
#endif