IncrementalSVD.h

 
// Description: The abstract incremental SVD algorithm defines algorithm
//              interface.
 
#ifndef included_IncrementalSVD_h
#define included_IncrementalSVD_h
 
#include "SVD.h"
#include "linalg/Options.h"
#include "utils/Database.h"
 
namespace CAROM {
 
class IncrementalSVD : public SVD
{
public:
    IncrementalSVD(
        Options options,
        const std::string& basis_file_name);
 
    virtual
    ~IncrementalSVD();
 
    virtual
    bool
    takeSample(
        double* u_in,
        bool add_without_increase = false);
 
    virtual
    const Matrix*
    getSpatialBasis();
 
    virtual
    const Matrix*
    getTemporalBasis();
 
    virtual
    const Vector*
    getSingularValues();
 
    virtual
    const Matrix*
    getSnapshotMatrix();
 
protected:
    virtual
    void
    buildInitialSVD(
        double* u) = 0;
 
    virtual
    bool
    buildIncrementalSVD(
        double* u, bool add_without_increase = false);
 
    virtual
    void
    computeBasis() = 0;
 
    void
    constructQ(
        double*& Q,
        const Vector* l,
        double k);
 
    bool
    svd(
        double* A,
        Matrix*& U,
        Matrix*& S,
        Matrix*& V);
 
    virtual
    void
    addLinearlyDependentSample(
        const Matrix* A,
        const Matrix* W,
        const Matrix* sigma) = 0;
 
    virtual
    void
    addNewSample(
        const Vector* j,
        const Matrix* A,
        const Matrix* W,
        Matrix* sigma) = 0;
 
    int
    numSamples()
    {
        return d_num_samples;
    }
 
    double
    checkOrthogonality(
        const Matrix* m);
 
    double d_linearity_tol;
 
    bool d_skip_linearly_dependent;
 
    int d_max_basis_dimension;
 
    int d_size;
 
    int d_rank;
 
    std::vector<int> d_proc_dims;
 
    long int d_total_dim;
 
    bool d_save_state;
 
    bool d_update_right_SV;
 
    Database* d_state_database;
 
    std::string d_state_file_name;
 
    static const int COMMUNICATE_U;
 
private:
    IncrementalSVD();
 
    IncrementalSVD(
        const IncrementalSVD& other);
 
    IncrementalSVD&
    operator = (
        const IncrementalSVD& rhs);
};
 
}
 
#endif