tsgDreamState.hpp

/*
 * Copyright (c) 2017, Miroslav Stoyanov
 *
 * This file is part of
 * Toolkit for Adaptive Stochastic Modeling And Non-Intrusive ApproximatioN: TASMANIAN
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions
 *    and the following disclaimer in the documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse
 *    or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * UT-BATTELLE, LLC AND THE UNITED STATES GOVERNMENT MAKE NO REPRESENTATIONS AND DISCLAIM ALL WARRANTIES, BOTH EXPRESSED AND IMPLIED.
 * THERE ARE NO EXPRESS OR IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, OR THAT THE USE OF THE SOFTWARE WILL NOT INFRINGE ANY PATENT,
 * COPYRIGHT, TRADEMARK, OR OTHER PROPRIETARY RIGHTS, OR THAT THE SOFTWARE WILL ACCOMPLISH THE INTENDED RESULTS OR THAT THE SOFTWARE OR ITS USE WILL NOT RESULT IN INJURY OR DAMAGE.
 * THE USER ASSUMES RESPONSIBILITY FOR ALL LIABILITIES, PENALTIES, FINES, CLAIMS, CAUSES OF ACTION, AND COSTS AND EXPENSES, CAUSED BY, RESULTING FROM OR ARISING OUT OF,
 * IN WHOLE OR IN PART THE USE, STORAGE OR DISPOSAL OF THE SOFTWARE.
 */
 
#ifndef __TASMANIAN_DREAM_STATE_HPP
#define __TASMANIAN_DREAM_STATE_HPP
 
#include "tsgDreamEnumerates.hpp"


 
namespace TasDREAM{

enum class NumChains : int {};

using ::TasGrid::NumDimensions;


class TasmanianDREAM{
public:
    TasmanianDREAM();
    TasmanianDREAM(int cnum_chains, int cnum_dimensions);
    TasmanianDREAM(NumChains chains, NumDimensions dims)
        : TasmanianDREAM(static_cast<int>(chains), static_cast<int>(dims)) {}

    TasmanianDREAM(int cnum_chains, const TasGrid::TasmanianSparseGrid &grid);
    ~TasmanianDREAM();

    static const char* getVersion(){ return TASMANIAN_VERSION_STRING; }
    static const char* getLicense(){ return TASMANIAN_LICENSE; }
    static int getVersionMajor(){ return TASMANIAN_VERSION_MAJOR; }
    static int getVersionMinor(){ return TASMANIAN_VERSION_MINOR; }

    int getNumDimensions() const{ return (int) num_dimensions; }
    int getNumChains() const{ return (int) num_chains; }
    size_t getNumHistory() const{ return pdf_history.size(); }

    bool isStateReady() const{ return init_state; }
    bool isPDFReady() const{ return init_values; }


    void setState(const std::vector<double> &new_state);


    void setState(std::function<void(double *)> update_state);


    void setPDFvalues(const std::vector<double> &new_values);


    void setPDFvalues(std::function<void(const std::vector<double> &state, std::vector<double> &values)> probability_distribution);

    void clearPDFvalues();


    void getIJKdelta(size_t i, size_t j, size_t k, double w, std::vector<double> &x) const;


    void getChainState(size_t i, double *x) const{ std::copy_n(state.begin() + i * num_dimensions, num_dimensions, x); }

    const std::vector<double>& getChainState() const{ return state; }


    double getPDFvalue(size_t i) const{ return pdf_values[i]; }


    void expandHistory(int num_snapshots);


    void saveStateHistory(size_t num_accepted);

    const std::vector<double>& getHistory() const{ return history; }

    const std::vector<double>& getHistoryPDF() const{ return pdf_history; }

    void getHistoryMeanVariance(std::vector<double> &mean, std::vector<double> &var) const;

    void getApproximateMode(std::vector<double> &mode) const;

    std::vector<double> getApproximateMode() const{
        std::vector<double> mode;
        getApproximateMode(mode);
        return mode;
    }

    void clearHistory();

    double getAcceptanceRate() const{ return ((pdf_history.empty()) ? 0 : ((double) accepted) / ((double) pdf_history.size())); }
 
    // file I/O
private:
    size_t num_chains, num_dimensions;
    bool init_state, init_values;
 
    size_t accepted;
 
    std::vector<double> state, history;
    std::vector<double> pdf_values, pdf_history;
};
 
}
 
#endif