mdpsolver 0.10.3__tar.gz → 0.12.0__tar.gz

mdpsolver-0.12.0/.gitignore

@@ -0,0 +1,27 @@
+/.vs
+/VisualStudioProject
+.vscode/
+.claude/
+.DS_Store
+Python/.DS_Store
+
+
+__pycache__/
+*.pyc
+
+Python/src/mdpsolver/problems/
+build/
+dist/
+wheelhouse/
+Dockerfile
+
+CompilerNotes.txt
+*.exe
+*egg-info
+*.Rhistory
+Benchmark/results/
+
+# Compiled extension modules are built by CI (cibuildwheel) / local build
+# scripts, not committed to the repo.
+*.pyd
+*.so

mdpsolver-0.12.0/CPP_Source_Code/CBMmodel.cpp

@@ -0,0 +1,388 @@
+/*
+* MIT License
+*
+* Copyright (c) 2026 Anders Reenberg Andersen and Jesper Fink Andersen
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in all
+* copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*/
+
+
+#include <iostream>
+#include <fstream> //to import component probabilities
+#include <string>  //
+#include <sstream> //
+#include <math.h>
+#include <assert.h>
+#include <exception> //for exiting if probabilities cannot be loaded
+#include <algorithm>
+#include <valarray> //for min and max function
+#include "CBMmodel.h"
+
+using namespace std;
+
+CBMmodel::CBMmodel(double discount,
+					int components,
+            		int stages,
+            		string importProbPath,
+            		double preventiveCost,
+            		double correctiveCost,
+            		double setupCost,
+            		double failurePenalty,
+            		int kOfN): //default constructor
+    N(components),
+    L(stages-1),
+    discount(discount),
+    numberOfStates(intPow(stages,components)), //unsigned INT_MAX is 2147483647
+    numberOfActions(intPow(2,components)),
+    cp(preventiveCost),
+    cc(correctiveCost),
+    cs(setupCost),
+    p(failurePenalty),
+	kN(kOfN),
+    importProbs(!importProbPath.empty()),
+    pCompMat(components,vector<double>(stages)),
+	pFailCompMat(components, vector<double>(stages)),
+	sidxMat(numberOfStates, vector<int>(components)),
+	aidxMat(numberOfActions, vector<int>(components))
+{
+    //set K-out-of-N
+	if (kN<=0||kN>N){
+		kN=N;	
+	}
+
+    //import component probabilities
+    if (importProbs) {
+        importComponentProbs(importProbPath);
+    }
+	// calculate tail probabilities
+	for (int i = 0; i < N; ++i) {
+		pFailCompMat[i][0] = pCompMat[i][L];
+		for (int j = 1; j <= L; ++j) {
+			pFailCompMat[i][j] = pFailCompMat[i][j - 1] + pCompMat[i][L-j];
+		}
+	}
+	//initialize sidxMat
+	int sidx_temp,s_i;
+	for (int sidx = 0; sidx < numberOfStates; ++sidx) {
+		sidx_temp = sidx;
+		for (int i = 0; i < N; ++i) {
+			s_i = sidx_temp % (L+1);
+			sidxMat[sidx][i] = s_i;
+			sidx_temp /= (L+1);
+		}
+	}
+	//initialize aidxMat
+	int aidx_temp, a_i;
+	for (int aidx = 0; aidx < numberOfActions; ++aidx) {
+		aidx_temp = aidx;
+		for (int i = 0; i < N; ++i) {
+			a_i = aidx_temp % 2;
+			aidxMat[aidx][i] = a_i;
+			aidx_temp /= 2;
+		}
+	}
+}
+
+CBMmodel::CBMmodel(double discount,
+            		int components,
+            		int stages,
+            		vector<vector<double>> pcm,
+            		double preventiveCost,
+            		double correctiveCost,
+            		double setupCost,
+            		double failurePenalty,
+            		int kOfN): //default constructor
+    N(components),
+    L(stages-1),
+    discount(discount),
+    numberOfStates(intPow(stages,components)), //unsigned INT_MAX is 2147483647
+    numberOfActions(intPow(2,components)),
+    cp(preventiveCost),
+    cc(correctiveCost),
+    cs(setupCost),
+    p(failurePenalty),
+	kN(kOfN),
+    pCompMat(pcm),
+	pFailCompMat(components, vector<double>(stages)),
+	sidxMat(numberOfStates, vector<int>(components)),
+	aidxMat(numberOfActions, vector<int>(components))
+{
+    //set K-out-of-N
+	if (kN<=0||kN>N){
+		kN=N;	
+	}
+
+	// calculate tail probabilities
+	for (int i = 0; i < N; ++i) {
+		pFailCompMat[i][0] = pCompMat[i][L];
+		for (int j = 1; j <= L; ++j) {
+			pFailCompMat[i][j] = pFailCompMat[i][j - 1] + pCompMat[i][L-j];
+		}
+	}
+	//initialize sidxMat
+	int sidx_temp,s_i;
+	for (int sidx = 0; sidx < numberOfStates; ++sidx) {
+		sidx_temp = sidx;
+		for (int i = 0; i < N; ++i) {
+			s_i = sidx_temp % (L+1);
+			sidxMat[sidx][i] = s_i;
+			sidx_temp /= (L+1);
+		}
+	}
+	//initialize aidxMat
+	int aidx_temp, a_i;
+	for (int aidx = 0; aidx < numberOfActions; ++aidx) {
+		aidx_temp = aidx;
+		for (int i = 0; i < N; ++i) {
+			a_i = aidx_temp % 2;
+			aidxMat[aidx][i] = a_i;
+			aidx_temp /= 2;
+		}
+	}
+}
+
+
+CBMmodel::CBMmodel(const CBMmodel& orig) {
+}
+
+CBMmodel::~CBMmodel() {
+}
+
+//class functions
+double CBMmodel::reward(int &sidx, int &aidx) {
+    //reward function
+    r = 0;
+    set_up = false;
+    fail_count = 0;
+    for(int i = 0; i < N; ++i) {
+		s_i = sidxMat[sidx][i];//i'th component state
+		a_i = aidxMat[aidx][i];
+        if (a_i==1) {
+            set_up = true;
+            if (s_i==L) {
+                ++fail_count;
+                r += cc;
+            } else {
+                r += cp;
+            }
+        } else if (s_i==L) {
+            ++fail_count;
+        }
+    }
+    r += set_up*cs + ((N-fail_count) < kN)*p;
+    return r;
+}
+
+double CBMmodel::transProb(int &sidx, int &aidx, int &jidx) {
+	//transition probability function
+
+	//int step;
+	prob = 1;
+	for (int i = 0; i<N; ++i) {
+		j_i = sidxMat[jidx][i]; //i'th component state
+		s_i = sidxMat[sidx][i];
+		a_i = aidxMat[aidx][i];
+		if (a_i == 0 && j_i<s_i) { // impossible transitions
+			prob *= 0;
+		} else if (a_i == 0 && j_i >= s_i) { //no replacement
+			step = j_i - s_i;
+			if (j_i < L) {
+				prob *= pCompMat[i][step];
+			} else {
+				prob *= pFailCompMat[i][s_i];
+			}
+		} else { //replacement
+			prob *= pCompMat[i][j_i];
+		}
+	}
+	psj = prob; //set stored transition probability
+	return prob;
+}
+
+void CBMmodel::updateTransProbNextState(int sidx, int aidx, int jidx) {
+	//void CBMmodel::updateTransProbNextStateOptimized(int sidx, int aidx, int jidx) {
+	//updates psj and nextState, which are assumed to match.
+	//That is, input jidx should be nextState.
+
+	int step;
+	for (int i = 0; i<N; ++i) {
+		j_i = sidxMat[jidx][i]; //i'th component state
+		s_i = sidxMat[sidx][i];
+		a_i = aidxMat[aidx][i];
+
+		//assert(a_i == 1 || (a_i == 0 && j_i >= s_i));//check valid transition
+
+		if (a_i == 0) {
+			step = j_i - s_i;
+		} else {
+			step = j_i;
+		}
+
+		if (j_i<L) {
+			nextState += intPow(L + 1, i); //increment i'th component by one
+			//psj /= pCompMat[i][step]; //psj should be divided by what was previously used to calc component transition
+			if (j_i + 1 < L) {
+				psj *= pCompMat[i][step + 1] / pCompMat[i][step]; // still lower than L after increment
+			} else {
+				if (a_i == 0) {
+					psj *= pFailCompMat[i][s_i] / pCompMat[i][step];
+				} else {
+					psj *= pCompMat[i][j_i + 1] / pCompMat[i][step]; //going from 0 to L here
+				}
+			}
+			break; //we are done
+		} else {
+			nextState -= step * intPow(L + 1, i); //reset back to s_i or 0
+			//here j_i=L so psj was formely multiplied with a fail probability
+			if (a_i == 0) { //went from s_i to L
+				psj /= pFailCompMat[i][s_i];
+				if (s_i < L) {
+					psj *= pCompMat[i][0];
+				}
+			} else {
+				psj *= pCompMat[i][0] / pCompMat[i][L];
+			}
+		}
+	}
+}
+
+int CBMmodel::postDecisionIdx(int &sidx, int &aidx) {
+	//int CBMmodel::postDecisionIdxOptimized(int sidx, int aidx) {
+	//state index right after replacement, which is
+	//assumed instantaneous so components are set to age 0
+	pdidx = sidx;
+
+	for (int i = 0; i<N; ++i) {
+		s_i = sidxMat[sidx][i];
+		a_i = aidxMat[aidx][i];
+		if (a_i == 1) {
+			pdidx -= (s_i)*intPow(L + 1, i); // sets it to 0
+		}
+	}
+	nextState = pdidx; //store as the "first" next state
+	return pdidx;
+}
+
+
+void CBMmodel::updateNextState(int &sidx, int &aidx, int &jidx) {
+	//increment one component's deterioration level.
+	if (jidx != -1) {
+		nextState = jidx;
+	} else {
+		jidx = nextState; // default jidx value is current nextState
+	}
+	done = false;
+	for (int i = 0; i<N; ++i) {
+		j_i = sidxMat[jidx][i]; //i'th component state
+		s_i = sidxMat[sidx][i];
+		a_i = aidxMat[aidx][i];
+
+		if (!done && j_i<L) { //non-replacements
+			nextState += intPow(L + 1, i);
+			done = true;
+		} else if (!done) {
+			if (a_i == 0) {
+				nextState -= (j_i - s_i)*intPow(L + 1, i); //reset back to s_i
+			} else {
+				nextState -= (j_i)*intPow(L + 1, i); //reset back to 0
+			}
+		}
+	}
+}
+
+
+int CBMmodel::intPow(int a, int b) {
+    int i = 1;
+    for(int j = 1; j <= b; ++j) i *= a;
+    return i;
+}
+
+void CBMmodel::importComponentProbs(string path) {
+    string line;
+    ifstream inputFile (path);
+    try {
+        if(!inputFile.is_open()) {
+            throw path;
+        }
+    }
+    catch (string path) {
+        cout << "Exception: UNABLE TO OPEN FILE: " + path + "\n";
+        exit(EXIT_FAILURE);
+    }
+
+    int i = 0;
+    int j = 0;
+    string element;
+    while( getline(inputFile, line) ) {
+        istringstream lineStream(line);
+        // read every element from the line that is separated by commas
+        // and put it into pCompMat
+        j = 0;
+        while( getline(lineStream, element, ',') ){
+            pCompMat [i][j] = stod(element);
+            //cout << i << " " << j << " " << element << endl;
+            ++j;
+        }
+        ++i;
+    }
+    inputFile.close();
+}
+
+double CBMmodel::getDiscount(){
+    return discount;
+}
+
+int CBMmodel::getNumberOfStates(){
+    return numberOfStates;
+}
+
+void CBMmodel::updateNumberOfActions(int &sidx){	
+}
+
+int CBMmodel::getNumberOfActions(){
+    return numberOfActions;
+}      
+
+int * CBMmodel::getNextState(){
+    return &nextState;
+}
+
+double CBMmodel::getPsj(){
+    return psj;
+}
+
+int CBMmodel::getColumnIdx(int &sidx, int &aidx, int &cidx){
+	return 0;
+}
+
+int CBMmodel::getNumberOfJumps(int &sidx, int &aidx){
+	return 0;
+}
+
+int CBMmodel::getNumberOfActions(int &sidx){
+	return 0;
+}
+
+//int CBMmodel::getPolicy(int sidx){
+//    return policy[sidx];
+//}
+//
+//void CBMmodel::assignPolicy(int sidx, int action){
+//    policy[sidx] = action;
+//}

mdpsolver-0.12.0/CPP_Source_Code/CBMmodel.h

@@ -0,0 +1,114 @@
+/*
+* MIT License
+*
+* Copyright (c) 2026 Anders Reenberg Andersen and Jesper Fink Andersen
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in all
+* copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*/
+
+
+#ifndef CBMMODEL_H
+#define CBMMODEL_H
+
+#include "ModelType.h"
+#include <vector>
+#include <string>
+
+using namespace std;
+
+class CBMmodel : public ModelType{
+public:
+    
+    //constructor and destructor
+    CBMmodel() {}; //dummy-constructor
+    CBMmodel(double discount=0.99,
+            int components=2,
+            int stages=10,
+            string importProbPath="pCompMat.csv",
+            double preventiveCost=-5,
+            double correctiveCost=-11,
+            double setupCost=-4,
+            double failurePenalty=-300,
+            int kOfN=-1);
+    CBMmodel(double discount=0.99,
+            int components=2,
+            int stages=10,
+            vector<vector<double>> pcm={},
+            double preventiveCost=-5,
+            double correctiveCost=-11,
+            double setupCost=-4,
+            double failurePenalty=-300,
+            int kOfN=-1);
+    CBMmodel(const CBMmodel& orig);
+    virtual ~CBMmodel();
+
+    //general MDP parameters
+    int N;
+    int L;
+    double discount;
+    int numberOfStates;
+    int numberOfActions;
+    //vector<int> policy;
+    //transition and reward parameters
+    double cp; //preventive replacement cost
+    double cc; //corrective replacement cost
+    double cs; //setup cost
+    double p; //system failure penalty
+    int kN; // k-out-of-N system, meaning system works iff k components work
+    bool importProbs;
+    vector<vector<double>> pCompMat; //component transition probs.
+	vector<vector<double>> pFailCompMat; //sum of element in pCompMat
+    //auxiliary variables
+    int nextState; //next state to process
+    double psj; //transition probability from state s to j
+	int s_i, a_i, j_i;
+	vector<vector<int>> sidxMat; // (sidx,i)'th element contains s_i for state index sidx
+	vector<vector<int>> aidxMat; // (aidx,i)'th element contains a_i for action index aidx
+    
+    // METHODS
+        
+    //GENERIC METHODS    
+    double reward(int &sidx, int &aidx) override;
+    double transProb(int &sidx, int &aidx, int &jidx) override;
+    void updateNextState(int &sidx, int &aidx, int &jidx) override;
+    int postDecisionIdx(int &sidx, int &aidx) override;
+    double getDiscount() override;
+    int getNumberOfStates() override;
+    void updateNumberOfActions(int &sidx) override;
+    int getNumberOfActions() override;
+    int getNumberOfActions(int &sidx) override;
+    int * getNextState() override;
+    double getPsj() override;
+    int getNumberOfJumps(int &sidx, int &aidx) override; //not used
+    int getColumnIdx(int &sidx, int &aidx, int &cidx) override; //not used
+    
+    //SPECIAL METHODS
+    void updateTransProbNextState(int, int, int);
+    int intPow(int, int);
+    void importComponentProbs(string path);
+    
+private:
+
+    double r,prob;
+    bool set_up,done;
+    int fail_count,step,pdidx;
+
+};
+
+#endif /* CBMMODEL_H */

mdpsolver-0.12.0/CPP_Source_Code/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.15)
+
+project(solvermodule LANGUAGES CXX)
+
+# pybind11 now comes from PyPI (declared as a build-time dependency in
+# Python/pyproject.toml) instead of being vendored as a subdirectory.
+find_package(pybind11 CONFIG REQUIRED)
+
+file(GLOB SOURCES "*.cpp")
+
+pybind11_add_module(solvermodule ${SOURCES})
+
+set_target_properties(solvermodule PROPERTIES CXX_STANDARD 14 CXX_STANDARD_REQUIRED ON)
+
+# Find OpenMP package
+find_package(OpenMP)
+if(OpenMP_CXX_FOUND)
+    # Set compiler options for LLVM OpenMP
+    target_compile_options(solvermodule PRIVATE "$<$<CXX_COMPILER_ID:MSVC>:/openmp:llvm>")
+    # Link OpenMP flags to the target
+    target_link_libraries(solvermodule PUBLIC OpenMP::OpenMP_CXX)
+endif()
+
+# Install the compiled extension into the mdpsolver package directory of the wheel.
+install(TARGETS solvermodule DESTINATION mdpsolver)

mdpsolver-0.12.0/CPP_Source_Code/GeneralMDPmodel.cpp

@@ -0,0 +1,146 @@
+/*
+* MIT License
+*
+* Copyright (c) 2026 Anders Reenberg Andersen and Jesper Fink Andersen
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in all
+* copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*/
+
+#include "GeneralMDPmodel.h"
+#include <limits>
+
+GeneralMDPmodel::GeneralMDPmodel(Rewards * rw, TransitionMatrix * tm, double discount):
+rewards(rw),
+tranMat(tm),
+discount(discount)
+{
+    initialize();
+}
+
+GeneralMDPmodel::GeneralMDPmodel(const GeneralMDPmodel& orig) {
+}
+
+GeneralMDPmodel::~GeneralMDPmodel() {
+}
+
+
+void GeneralMDPmodel::initialize(){
+    tranMat->fillTables(csr);
+    numberOfStates=csr.numberOfStates;
+    cidx=0;
+
+    //The tables need one reward per pair of the transition probabilities. In a well-formed
+    //model the rewards have the same numbers of actions, and so the same numbering, and
+    //their array is used as it is. Otherwise (which checkModel() reports) a copy numbered
+    //like the pairs is made, so that the solver reads no memory outside the rewards.
+    bool aligned = rewards->numberOfRows() >= numberOfStates;
+    for (int sidx=0; aligned && sidx<numberOfStates; sidx++){
+        aligned = rewards->numberOfActions(sidx) == tranMat->numberOfActions(sidx);
+    }
+    if (aligned){
+        csr.reward = rewards->data();
+    }else{
+        alignedRewards.assign(csr.stateStart[numberOfStates], numeric_limits<double>::quiet_NaN());
+        for (int sidx=0; sidx<numberOfStates && sidx<rewards->numberOfRows(); sidx++){
+            for (int aidx=0; aidx<tranMat->numberOfActions(sidx) && aidx<rewards->numberOfActions(sidx); aidx++){
+                alignedRewards[pair(sidx,aidx)] = rewards->getReward(sidx,aidx);
+            }
+        }
+        csr.reward = alignedRewards.data();
+    }
+}
+
+double GeneralMDPmodel::reward(int &sidx, int &aidx){
+    //calculates and returns the reward of taking action
+    //aidx when in current state sidx
+
+    return csr.reward[pair(sidx,aidx)];
+}
+
+double GeneralMDPmodel::transProb(int &sidx, int &aidx, int &jidx){
+    //returns the jidx-th non-zero transition probability of taking
+    //action aidx in state sidx (jidx counts the non-zero probabilities)
+
+    return probability(entry(sidx,aidx,jidx));
+}
+
+int GeneralMDPmodel::getNumberOfJumps(int &sidx, int &aidx){
+    int64_t i = pair(sidx,aidx);
+    return (int)(csr.pairStart[i+1] - csr.pairStart[i]);
+}
+
+void GeneralMDPmodel::updateNextState(int &sidx, int &aidx, int &jidx){
+    //updates the next possible state, nextState, and the associated
+    //transition probability, psj.
+    int nJumps = getNumberOfJumps(sidx,aidx);
+    while (csr.column[entry(sidx,aidx,cidx)]!=jidx){ //this will in many cases immediately evaluate to False
+        cidx++;
+        if (cidx==nJumps){ //to make sure cidx is always feasible
+            cidx=0;
+        }
+    }
+    cidx++; //move one additional step
+    if (cidx==nJumps){
+        cidx=0;
+    }
+    nextState = csr.column[entry(sidx,aidx,cidx)];
+    psj = probability(entry(sidx,aidx,cidx));
+}
+
+int GeneralMDPmodel::getColumnIdx(int &sidx, int &aidx, int &cidx){
+    return csr.column[entry(sidx,aidx,cidx)];
+}
+
+int GeneralMDPmodel::postDecisionIdx(int &sidx, int &aidx){
+    //derives the first new/next state that is possible
+    //to reach from the current state sidx.
+    //both returns the value of the first new state, and
+    //stores it in the variable nextState.
+    cidx=0;
+    nextState = csr.column[entry(sidx,aidx,cidx)];
+    return nextState;
+}
+
+double GeneralMDPmodel::getDiscount(){
+    return discount;
+}
+
+int GeneralMDPmodel::getNumberOfStates(){
+    return numberOfStates;
+}
+
+void GeneralMDPmodel::updateNumberOfActions(int &sidx){
+    numberOfActions=(int)(csr.stateStart[sidx+1] - csr.stateStart[sidx]);
+}
+
+int GeneralMDPmodel::getNumberOfActions(){
+    return numberOfActions;
+}
+
+int GeneralMDPmodel::getNumberOfActions(int &sidx){
+    return (int)(csr.stateStart[sidx+1] - csr.stateStart[sidx]);
+}
+
+int * GeneralMDPmodel::getNextState(){
+    return &nextState;
+}
+
+double GeneralMDPmodel::getPsj(){
+    return psj;
+}