Ensemble.template.hpp

Go to the documentation of this file.

 
namespace Ensemble::internal {
    template<class MatrixType>
    class ScalableOperator {
        private:
            using Scalar = typename MatrixType::Scalar;
            MatrixType m_locOp;
 
        public:
            ScalableOperator(MatrixType&& locOp) : m_locOp{locOp} {
                // Write codes here
            }
 
            MatrixType construct_globalOp(size_t L) {
                MatrixType res;
                // Write codes here
                return res;
            };
    };
}  // namespace Ensemble::internal
 
class HamiltonianEnsemble {
    public:
        using MatrixType       = Eigen::MatrixX<Scalar>;
        using EigenSolver      = Eigen::SelfAdjointEigenSolver<MatrixType>;
        using ScalableOperator = Ensemble::internal::ScalableOperator<MatrixType>;
 
        static std::string dataname(size_t rep) { return "Hamiltonian_No" + std::to_string(rep); };
        static std::string usage(size_t nargs) {
            std::string usage = "HamiltonianEnsemble Usage: ";
            usage += std::to_string(nargs + 0) + ".(...) ";
            // Add codes here
            return usage;
        };
        static constexpr size_t nargs(void) { return 1; };
 
    private:
        HamiltonianEnsemble(char** CL_argv) {
            // Write codes here
        }
 
    public:
        HamiltonianEnsemble(const HamiltonianEnsemble&)              = delete;
        HamiltonianEnsemble& operator=(const HamiltonianEnsemble&)   = delete;
        HamiltonianEnsemble(HamiltonianEnsemble&&)                   = delete;
        HamiltonianEnsemble&        operator=(HamiltonianEnsemble&&) = delete;
        static HamiltonianEnsemble& get_instance(char** CL_argv) {
            static HamiltonianEnsemble instance(CL_argv);
            return instance;
        }
 
        void discard(size_t n) {
            // Write codes here
        }
 
        ScalableOperator sample() {
            ScalableOperator res;
            // Write codes to construct an observable here
            return res;
        }
};
 
class ObservableEnsemble {
    public:
        using MatrixType  = Eigen::MatrixX<Scalar>;
        using EigenSolver = Eigen::SelfAdjointEigenSolver<MatrixType>;
 
        static std::string dataname(size_t rep) { return "Observable_No" + std::to_string(rep); };
        static std::string usage(size_t nargs) {
            std::string usage = "ObservableEnsemble Usage: ";
            usage += std::to_string(nargs + 0) + ".(...) ";
            // Add codes here
            return usage;
        };
        static constexpr size_t nargs(void) { return 1; };
 
    private:
 
    public:
        ObservableEnsemble()                                     = default;
        ObservableEnsemble(const ObservableEnsemble&)            = delete;
        ObservableEnsemble& operator=(const ObservableEnsemble&) = delete;
        ObservableEnsemble(ObservableEnsemble&&)                 = default;
        ObservableEnsemble& operator=(ObservableEnsemble&&)      = default;
 
        void reset() {
            // Write codes here
        }
 
        void discard(size_t n) {
            // Write codes here
        }
 
        MatrixType sample() {
            MatrixType res;
            // Write codes to construct an observable here
            return res;
        }
 
        auto& stateSpace() { return; }
        auto& operatorSpace() { return; }
};