MarkovChainFactory.hpp

Go to the documentation of this file.

#ifndef HOPS_MARKOVCHAINFACTORY_HPP
#define HOPS_MARKOVCHAINFACTORY_HPP
 
#include <type_traits>
 
#include <hops/MarkovChain/Draw/NoOpDrawAdapter.hpp>
#include <hops/MarkovChain/Draw/MetropolisHastingsFilter.hpp>
#include <hops/MarkovChain/ModelMixin.hpp>
#include <hops/MarkovChain/MarkovChain.hpp>
#include <hops/MarkovChain/MarkovChainType.hpp>
#include <hops/MarkovChain/MarkovChainAdapter.hpp>
#include <hops/MarkovChain/ParallelTempering/Coldness.hpp>
#include <hops/MarkovChain/ParallelTempering/ParallelTempering.hpp>
#include <hops/MarkovChain/Proposal/AdaptiveMetropolisProposal.hpp>
#include <hops/MarkovChain/Proposal/BallWalkProposal.hpp>
#include <hops/MarkovChain/Proposal/CoordinateHitAndRunProposal.hpp>
#include <hops/MarkovChain/Proposal/CSmMALAProposal.hpp>
#include <hops/MarkovChain/Proposal/DikinProposal.hpp>
#include <hops/MarkovChain/Proposal/GaussianProposal.hpp>
#include <hops/MarkovChain/Proposal/HitAndRunProposal.hpp>
#include <hops/MarkovChain/Recorder/AcceptanceRateRecorder.hpp>
#include <hops/MarkovChain/Recorder/NegativeLogLikelihoodRecorder.hpp>
#include <hops/MarkovChain/Recorder/StateRecorder.hpp>
#include <hops/MarkovChain/Recorder/TimestampRecorder.hpp>
#include <hops/MarkovChain/StateTransformation.hpp>
#include <hops/Model/Model.hpp>
#include <hops/Transformation/Transformation.hpp>
#include <utility>
#include "ModelWrapper.hpp"
 
namespace hops {
    class MarkovChainFactory {
    public:
        template<typename MatrixType, typename VectorType, typename Proposal>
        static std::unique_ptr<MarkovChain> createMarkovChain(
                Proposal m_proposal
        ) {
            return addRecordersAndAdapter(MetropolisHastingsFilter(m_proposal));
        }
 
        template<typename MatrixType, typename VectorType>
        static std::unique_ptr<MarkovChain> createMarkovChain(
                MarkovChainType type,
                MatrixType inequalityLhs,
                VectorType inequalityRhs,
                VectorType startingPoint
        ) {
            if (!isInteriorPoint(inequalityLhs, inequalityRhs, startingPoint)) {
                throw std::domain_error("Starting point outside polytope is always constant.");
            }
 
            switch (type) {
                case MarkovChainType::BallWalk : {
                    return addRecordersAndAdapter(
                            NoOpDrawAdapter(
                                    BallWalkProposal(
                                            Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>(
                                                    inequalityLhs), inequalityRhs, startingPoint)
                            )
                    );
                }
                case MarkovChainType::CoordinateHitAndRun : {
                    return addRecordersAndAdapter(
                            NoOpDrawAdapter(
                                    CoordinateHitAndRunProposal(
                                            Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>(
                                                    inequalityLhs), inequalityRhs, startingPoint)
                            )
                    );
                }
                case MarkovChainType::DikinWalk : {
                    return addRecordersAndAdapter(
                            MetropolisHastingsFilter(
                                    DikinProposal(inequalityLhs, inequalityRhs, startingPoint)
                            )
                    );
                }
                case MarkovChainType::Gaussian : {
                    return addRecordersAndAdapter(
                            MetropolisHastingsFilter(
                                    GaussianProposal(
                                            Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>(
                                                    inequalityLhs), inequalityRhs, startingPoint)
                            )
                    );
                }
                case MarkovChainType::HitAndRun: {
                    return addRecordersAndAdapter(
                            NoOpDrawAdapter(
                                    HitAndRunProposal(
                                            Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>(
                                                    inequalityLhs), inequalityRhs, startingPoint)
                            )
                    );
                }
                default: {
                    throw std::invalid_argument("MarkovChainType not supported for uniform sampling.");
                }
            }
        }
 
        template<typename MatrixType, typename VectorType, typename Proposal>
        static std::unique_ptr<MarkovChain> createMarkovChain(
                Proposal m_proposal,
                MatrixType unroundingTransformation,
                VectorType unroundingShift
        ) {
            return addRecordersAndAdapter(
                    MetropolisHastingsFilter(
                            StateTransformation(
                                    m_proposal, Transformation(unroundingTransformation, unroundingShift)
                            )
                    )
            );
        }
 
        template<typename MatrixType, typename VectorType>
        static std::unique_ptr<MarkovChain> createMarkovChain(
                MarkovChainType type,
                MatrixType roundedInequalityLhs,
                VectorType roundedInequalityRhs,
                VectorType startingPoint,
                MatrixType unroundingTransformation,
                VectorType unroundingShift
        ) {
            if (!isInteriorPoint(roundedInequalityLhs, roundedInequalityRhs, startingPoint)) {
                throw std::domain_error("Starting point outside polytope is always constant.");
            }
 
            switch (type) {
                case MarkovChainType::BallWalk : {
                    return addRecordersAndAdapter(
                            NoOpDrawAdapter(
                                    StateTransformation(
                                            BallWalkProposal(
                                                    Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>(
                                                            roundedInequalityLhs),
                                                    roundedInequalityRhs,
                                                    startingPoint),
                                            Transformation(unroundingTransformation, unroundingShift)
                                    )
                            )
                    );
                }
                case MarkovChainType::CoordinateHitAndRun : {
                    return addRecordersAndAdapter(
                            NoOpDrawAdapter(
                                    StateTransformation(
                                            CoordinateHitAndRunProposal(
                                                    Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>(
                                                            roundedInequalityLhs),
                                                    roundedInequalityRhs,
                                                    startingPoint),
                                            Transformation(unroundingTransformation, unroundingShift)
                                    )
                            )
                    );
                }
                case MarkovChainType::DikinWalk : {
                    return addRecordersAndAdapter(
                            MetropolisHastingsFilter(
                                    StateTransformation(
                                            DikinProposal(
                                                    roundedInequalityLhs,
                                                    roundedInequalityRhs,
                                                    startingPoint),
                                            Transformation(unroundingTransformation, unroundingShift)
                                    )
                            )
                    );
                }
                case MarkovChainType::Gaussian : {
                    return addRecordersAndAdapter(
                            MetropolisHastingsFilter(
                                    StateTransformation(
                                            GaussianProposal(
                                                    Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>(
                                                            roundedInequalityLhs),
                                                    roundedInequalityRhs,
                                                    startingPoint),
                                            Transformation(unroundingTransformation, unroundingShift)
                                    )
                            )
                    );
                }
                case MarkovChainType::HitAndRun: {
                    return addRecordersAndAdapter(
                            NoOpDrawAdapter(
                                    StateTransformation(
                                            HitAndRunProposal(
                                                    Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>(
                                                            roundedInequalityLhs),
                                                    roundedInequalityRhs,
                                                    startingPoint),
                                            Transformation(unroundingTransformation, unroundingShift)
                                    )
                            )
                    );
                }
                default: {
                    throw std::invalid_argument("MarkovChainType not supported for uniform sampling.");
                }
            }
        }
 
        template<typename MatrixType, typename VectorType, typename Proposal>
        static std::unique_ptr<MarkovChain> createMarkovChain(
                Proposal m_proposal,
                std::shared_ptr<Model> model
        ) {
            return addRecordersAndAdapter(
                    NegativeLogLikelihoodRecorder(
                            MetropolisHastingsFilter(
                                    ModelMixin(
                                            m_proposal,
                                            Coldness(ModelWrapper(std::move(model)))
                                    )
                            )
                    )
            );
        }
 
        template<typename MatrixType, typename VectorType>
        static std::unique_ptr<MarkovChain> createMarkovChain(
                MarkovChainType type,
                MatrixType inequalityLhs,
                VectorType inequalityRhs,
                VectorType startingPoint,
                const std::shared_ptr<Model> &model
        ) {
            if (!isInteriorPoint(inequalityLhs, inequalityRhs, startingPoint)) {
                throw std::domain_error("Starting point outside polytope is always constant.");
            }
 
            switch (type) {
                case MarkovChainType::AdaptiveMetropolis : {
                    return addRecordersAndAdapter(
                            MetropolisHastingsFilter(
                                    ModelMixin(
                                            AdaptiveMetropolisProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                    decltype(inequalityRhs)>(
                                                    inequalityLhs, inequalityRhs, startingPoint),
                                            ModelWrapper(model)
                                    )
                            )
                    );
                }
                case MarkovChainType::BallWalk : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    BallWalkProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                            decltype(inequalityRhs)>(
                                                            inequalityLhs, inequalityRhs, startingPoint),
                                                    ModelWrapper(model)
                                            )
                                    )
                            )
                    );
                }
                case MarkovChainType::CoordinateHitAndRun : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    CoordinateHitAndRunProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                            decltype(inequalityRhs),
                                                            GaussianStepDistribution<typename decltype(inequalityRhs)::Scalar>>(
                                                            inequalityLhs, inequalityRhs, startingPoint),
                                                    ModelWrapper(model)
                                            )
                                    )
                            )
                    );
                }
                case MarkovChainType::CSmMALA: {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            CSmMALAProposal(ModelWrapper(model),
                                                            inequalityLhs,
                                                            inequalityRhs,
                                                            startingPoint)
                                    )
                            )
                    );
                }
                case MarkovChainType::DikinWalk : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    DikinProposal(inequalityLhs, inequalityRhs, startingPoint),
                                                    ModelWrapper(model)
                                            )
                                    )
                            )
                    );
                }
                case MarkovChainType::Gaussian : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    GaussianProposal<
                                                            Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                            decltype(inequalityRhs)
                                                    >(inequalityLhs, inequalityRhs, startingPoint),
                                                    ModelWrapper(model)
                                            )
                                    )
                            )
                    );
                }
                case MarkovChainType::HitAndRun: {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    HitAndRunProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                            decltype(inequalityRhs),
                                                            GaussianStepDistribution<typename decltype(inequalityRhs)::Scalar>>(
                                                            inequalityLhs, inequalityRhs, startingPoint),
                                                    ModelWrapper(model)
                                            )
                                    )
                            )
                    );
                }
                default: {
                    throw std::invalid_argument("Type not supported.");
                }
            }
        }
 
        template<typename MatrixType, typename VectorType>
        static std::unique_ptr<MarkovChain> createMarkovChainWithParallelTempering(
                MarkovChainType type,
                MatrixType inequalityLhs,
                VectorType inequalityRhs,
                VectorType startingPoint,
                const std::shared_ptr<Model> &model,
                RandomNumberGenerator synchronizedRandomNumberGenerator
        ) {
            if (!isInteriorPoint(inequalityLhs, inequalityRhs, startingPoint)) {
                throw std::domain_error("Starting point outside polytope is always constant.");
            }
 
            switch (type) {
                case MarkovChainType::AdaptiveMetropolis : {
                    return addRecordersAndAdapter(
                            MetropolisHastingsFilter(
                                    ModelMixin(
                                            AdaptiveMetropolisProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                    decltype(inequalityRhs)>(
                                                    inequalityLhs, inequalityRhs, startingPoint),
                                            Coldness(ModelWrapper(model))
                                    )
                            ),
                            synchronizedRandomNumberGenerator
                    );
                }
                case MarkovChainType::BallWalk : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    BallWalkProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                            decltype(inequalityRhs)>(
                                                            inequalityLhs, inequalityRhs, startingPoint),
                                                    Coldness(ModelWrapper(model))
                                            )
                                    )
                            ),
                            synchronizedRandomNumberGenerator
                    );
                }
                case MarkovChainType::CoordinateHitAndRun : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    CoordinateHitAndRunProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                            decltype(inequalityRhs),
                                                            GaussianStepDistribution<typename decltype(inequalityRhs)::Scalar>>(
                                                            inequalityLhs, inequalityRhs, startingPoint),
                                                    Coldness(ModelWrapper(model))
                                            )
                                    )
                            ),
                            synchronizedRandomNumberGenerator
                    );
                }
                case MarkovChainType::CSmMALA: {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            CSmMALAProposal(Coldness(ModelWrapper(model)),
                                                            inequalityLhs,
                                                            inequalityRhs,
                                                            startingPoint)
                                    )
                            ),
                            synchronizedRandomNumberGenerator
                    );
                }
                case MarkovChainType::DikinWalk : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    DikinProposal(inequalityLhs, inequalityRhs, startingPoint),
                                                    Coldness(ModelWrapper(model))
                                            )
                                    )
                            ),
                            synchronizedRandomNumberGenerator
                    );
                }
                case MarkovChainType::Gaussian : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    GaussianProposal<
                                                            Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                            decltype(inequalityRhs)
                                                    >(inequalityLhs, inequalityRhs, startingPoint),
                                                    Coldness(ModelWrapper(model))
                                            )
                                    )
                            ),
                            synchronizedRandomNumberGenerator
                    );
                }
                case MarkovChainType::HitAndRun: {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    HitAndRunProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                            decltype(inequalityRhs),
                                                            GaussianStepDistribution<typename decltype(inequalityRhs)::Scalar>>(
                                                            inequalityLhs, inequalityRhs, startingPoint),
                                                    Coldness(ModelWrapper(model))
                                            )
                                    )
                            ),
                            synchronizedRandomNumberGenerator
                    );
                }
                default: {
                    throw std::invalid_argument("Type not supported.");
                }
            }
        }
 
        template<typename MatrixType, typename VectorType, typename Proposal>
        static std::unique_ptr<MarkovChain> createMarkovChain(
                Proposal m_proposal,
                MatrixType unroundingTransformation,
                VectorType unroundingShift,
                std::shared_ptr<Model> model
        ) {
 
            return addRecordersAndAdapter(
                    NegativeLogLikelihoodRecorder(
                            MetropolisHastingsFilter(
                                    ModelMixin(
                                            StateTransformation(
                                                    m_proposal,
                                                    Transformation(unroundingTransformation, unroundingShift)
                                            ),
                                            Coldness(ModelWrapper(model))
                                    )
                            )
                    )
            );
        }
 
        template<typename MatrixType, typename VectorType>
        static std::unique_ptr<MarkovChain> createMarkovChain(
                MarkovChainType type,
                MatrixType roundedInequalityLhs,
                VectorType roundedInequalityRhs,
                VectorType startingPoint,
                MatrixType unroundingTransformation,
                VectorType unroundingShift,
                const std::shared_ptr<Model> &model
        ) {
            if (!isInteriorPoint(roundedInequalityLhs, roundedInequalityRhs, startingPoint)) {
                throw std::domain_error("Starting point outside polytope is always constant.");
            }
 
            switch (type) {
                case MarkovChainType::BallWalk : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    StateTransformation(
                                                            BallWalkProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                                    decltype(roundedInequalityRhs)>(
                                                                    roundedInequalityLhs,
                                                                    roundedInequalityRhs,
                                                                    startingPoint),
                                                            Transformation(unroundingTransformation, unroundingShift)
                                                    ),
                                                    ModelWrapper(model)
                                            )
                                    )
                            )
                    );
                }
                case MarkovChainType::CoordinateHitAndRun : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    StateTransformation(
                                                            CoordinateHitAndRunProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                                    decltype(roundedInequalityRhs),
                                                                    GaussianStepDistribution<typename decltype(roundedInequalityRhs)::Scalar>>(
                                                                    roundedInequalityLhs,
                                                                    roundedInequalityRhs,
                                                                    startingPoint),
                                                            Transformation(unroundingTransformation, unroundingShift)
                                                    ),
                                                    ModelWrapper(model)
                                            )
                                    )
                            )
                    );
                }
                case MarkovChainType::Gaussian : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    StateTransformation(
                                                            GaussianProposal<
                                                                    Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                                    decltype(roundedInequalityRhs)>(
                                                                    roundedInequalityLhs,
                                                                    roundedInequalityRhs,
                                                                    startingPoint
                                                            ),
                                                            Transformation(unroundingTransformation, unroundingShift)
                                                    ),
                                                    ModelWrapper(model)
                                            )
                                    )
                            )
                    );
                }
                case MarkovChainType::HitAndRun: {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    StateTransformation(
                                                            HitAndRunProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                                    decltype(roundedInequalityRhs),
                                                                    GaussianStepDistribution<typename decltype(roundedInequalityRhs)::Scalar>>(
                                                                    roundedInequalityLhs,
                                                                    roundedInequalityRhs,
                                                                    startingPoint),
                                                            Transformation(unroundingTransformation, unroundingShift)
                                                    ),
                                                    ModelWrapper(model)
                                            )
                                    )
                            )
                    );
                }
                default: {
                    throw std::invalid_argument("Type not supported.");
                }
            }
        }
 
        template<typename MatrixType, typename VectorType>
        static std::unique_ptr<MarkovChain> createMarkovChainWithParallelTempering(
                MarkovChainType type,
                MatrixType roundedInequalityLhs,
                VectorType roundedInequalityRhs,
                VectorType startingPoint,
                MatrixType unroundingTransformation,
                VectorType unroundingShift,
                const std::shared_ptr<Model>& model,
                RandomNumberGenerator synchronizedRandomNumberGenerator
        ) {
            if (!isInteriorPoint(roundedInequalityLhs, roundedInequalityRhs, startingPoint)) {
                throw std::domain_error("Starting point outside polytope is always constant.");
            }
 
            switch (type) {
                case MarkovChainType::BallWalk : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    StateTransformation(
                                                            BallWalkProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                                    decltype(roundedInequalityRhs)>(
                                                                    roundedInequalityLhs,
                                                                    roundedInequalityRhs,
                                                                    startingPoint),
                                                            Transformation(unroundingTransformation, unroundingShift)
                                                    ),
                                                    Coldness(ModelWrapper(model))
                                            )
                                    )
                            ),
                            synchronizedRandomNumberGenerator
                    );
                }
                case MarkovChainType::CoordinateHitAndRun : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    StateTransformation(
                                                            CoordinateHitAndRunProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                                    decltype(roundedInequalityRhs),
                                                                    GaussianStepDistribution<typename decltype(roundedInequalityRhs)::Scalar>>(
                                                                    roundedInequalityLhs,
                                                                    roundedInequalityRhs,
                                                                    startingPoint),
                                                            Transformation(unroundingTransformation, unroundingShift)
                                                    ),
                                                    Coldness(ModelWrapper(model))
                                            )
                                    )
                            ),
                            synchronizedRandomNumberGenerator
                    );
                }
                case MarkovChainType::Gaussian : {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    StateTransformation(
                                                            GaussianProposal<
                                                                    Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                                    decltype(roundedInequalityRhs)>(
                                                                    roundedInequalityLhs,
                                                                    roundedInequalityRhs,
                                                                    startingPoint
                                                            ),
                                                            Transformation(unroundingTransformation, unroundingShift)
                                                    ),
                                                    Coldness(ModelWrapper(model))
                                            )
                                    )
                            ),
                            synchronizedRandomNumberGenerator
                    );
                }
                case MarkovChainType::HitAndRun: {
                    return addRecordersAndAdapter(
                            NegativeLogLikelihoodRecorder(
                                    MetropolisHastingsFilter(
                                            ModelMixin(
                                                    StateTransformation(
                                                            HitAndRunProposal<Eigen::Matrix<typename MatrixType::Scalar, Eigen::Dynamic, Eigen::Dynamic>,
                                                                    decltype(roundedInequalityRhs),
                                                                    GaussianStepDistribution<typename decltype(roundedInequalityRhs)::Scalar>>(
                                                                    roundedInequalityLhs,
                                                                    roundedInequalityRhs,
                                                                    startingPoint),
                                                            Transformation(unroundingTransformation, unroundingShift)
                                                    ),
                                                    Coldness(ModelWrapper(model))
                                            )
                                    )
                            ),
                            synchronizedRandomNumberGenerator
                    );
                }
                default: {
                    throw std::invalid_argument("Type not supported.");
                }
            }
        }
 
 
    private:
        template<typename MatrixType, typename VectorType>
        static bool isInteriorPoint(const MatrixType &A, const VectorType &b, const VectorType &x) {
            return ((b - A * x).array() >= 0).all();
        }
 
        template<typename MarkovChainImpl>
        static std::unique_ptr<MarkovChain>
        addRecordersAndAdapter(const MarkovChainImpl &markovChainImpl,
                               RandomNumberGenerator synchronizedRandomNumberGenerator) {
            if constexpr(IsSetColdnessAvailable<MarkovChainImpl>::value) {
                auto mc = MarkovChainAdapter(
                        ParallelTempering(
                                AcceptanceRateRecorder(
                                        TimestampRecorder(
                                                StateRecorder(
                                                        markovChainImpl
                                                )
                                        )
                                ),
                                synchronizedRandomNumberGenerator
                        )
                );
                return std::make_unique<decltype(mc)>(mc);
            } else {
                throw std::invalid_argument("Can not use Parallel Tempering without model.");
            }
        };
 
        template<typename MarkovChainImpl>
        static std::unique_ptr<MarkovChain>
        addRecordersAndAdapter(const MarkovChainImpl &markovChainImpl) {
            auto mc = MarkovChainAdapter(
                    AcceptanceRateRecorder(
                            TimestampRecorder(
                                    StateRecorder(
                                            markovChainImpl
                                    )
                            )
                    )
            );
            return std::make_unique<decltype(mc)>(mc);
        }
    };
}
 
#endif //HOPS_MARKOVCHAINFACTORY_HPP