Fix: Time-bounded probs for CTMC are exactly 1 (no round-off) for target states.

git-svn-id: https://www.prismmodelchecker.org/svn/prism/prism/trunk@2341 bbc10eb1-c90d-0410-af57-cb519fbb1720

prism/include/DoubleVector.h

@@ -87,6 +87,14 @@ JNIEXPORT void JNICALL Java_dv_DoubleVector_DV_1TimesConstant
 JNIEXPORT void JNICALL Java_dv_DoubleVector_DV_1Filter
   (JNIEnv *, jobject, jlong, jlong, jlong, jint, jlong);
 
+/*
+ * Class:     dv_DoubleVector
+ * Method:    DV_MaxMTBDD
+ * Signature: (JJJIJ)V
+ */
+JNIEXPORT void JNICALL Java_dv_DoubleVector_DV_1MaxMTBDD
+  (JNIEnv *, jobject, jlong, jlong, jlong, jint, jlong);
+
 /*
  * Class:     dv_DoubleVector
  * Method:    DV_Clear

prism/include/dv.h

@@ -73,6 +73,7 @@ EXPORT DdNode *double_vector_to_bdd(DdManager *ddman, double *vec, int rel_op, d
 EXPORT DdNode *double_vector_to_bdd(DdManager *ddman, double *vec, int rel_op, double value1, double value2, DdNode **vars, int num_vars, ODDNode *odd);
 
 EXPORT void filter_double_vector(DdManager *ddman, double *vec, DdNode *filter, DdNode **vars, int num_vars, ODDNode *odd);
+EXPORT void max_double_vector_mtbdd(DdManager *ddman, double *vec, DdNode *vec2, DdNode **vars, int num_vars, ODDNode *odd);
 EXPORT double get_first_from_bdd(DdManager *ddman, double *vec, DdNode *filter, DdNode **vars, int num_vars, ODDNode *odd);
 EXPORT double min_double_vector_over_bdd(DdManager *ddman, double *vec, DdNode *filter, DdNode **vars, int num_vars, ODDNode *odd);
 EXPORT double max_double_vector_over_bdd(DdManager *ddman, double *vec, DdNode *filter, DdNode **vars, int num_vars, ODDNode *odd);

prism/src/dv/DoubleVector.cc

@@ -234,6 +234,28 @@ jlong __jlongpointer odd
 
 //------------------------------------------------------------------------------
 
+JNIEXPORT void JNICALL Java_dv_DoubleVector_DV_1MaxMTBDD
+(
+JNIEnv *env,
+jobject obj,
+jlong __jlongpointer vector,
+jlong __jlongpointer vector2,
+jlong __jlongpointer vars,
+jint num_vars,
+jlong __jlongpointer odd
+)
+{
+	max_double_vector_mtbdd(
+		ddman,
+		jlong_to_double(vector),
+		jlong_to_DdNode(vector2),
+		jlong_to_DdNode_array(vars), num_vars,
+		jlong_to_ODDNode(odd)
+	);
+}
+
+//------------------------------------------------------------------------------
+
 JNIEXPORT void JNICALL Java_dv_DoubleVector_DV_1Clear
 (
 JNIEnv *env,

prism/src/dv/DoubleVector.java

@@ -152,6 +152,13 @@ public class DoubleVector
 	{
 		DV_Filter(v, filter.ptr(), vars.array(), vars.n(), odd.ptr());
 	}
+	
+	// apply max operator, i.e. v[i] = max(v[i], v2[i]), where v2 is an mtbdd
+	private native void DV_MaxMTBDD(long v, long v2, long vars, int num_vars, long odd);
+	public void maxMTBDD(JDDNode v2, JDDVars vars, ODDNode odd)
+	{
+		DV_MaxMTBDD(v, v2.ptr(), vars.array(), vars.n(), odd.ptr());
+	}
 
 	// clear (free memory)
 	private native void DV_Clear(long v);

prism/src/dv/dv.cc

@@ -35,6 +35,7 @@ static void mtbdd_to_double_vector_rec(DdManager *ddman, DdNode *dd, DdNode **va
 static DdNode *double_vector_to_mtbdd_rec(DdManager *ddman, double *vec, DdNode **vars, int num_vars, int level, ODDNode *odd, long o);
 static DdNode *double_vector_to_bdd_rec(DdManager *ddman, double *vec, int rel_op, double value1, double value2, DdNode **vars, int num_vars, int level, ODDNode *odd, long o);
 static void filter_double_vector_rec(DdManager *ddman, double *vec, DdNode *filter, DdNode **vars, int num_vars, int level, ODDNode *odd, long o);
+static void max_double_vector_mtbdd_rec(DdManager *ddman, double *vec, DdNode *vec2, DdNode **vars, int num_vars, int level, ODDNode *odd, long o);
 static double get_first_from_bdd_rec(DdManager *ddman, double *vec, DdNode *filter, DdNode **vars, int num_vars, int level, ODDNode *odd, long o);
 static double min_double_vector_over_bdd_rec(DdManager *ddman, double *vec, DdNode *filter, DdNode **vars, int num_vars, int level, ODDNode *odd, long o);
 static double max_double_vector_over_bdd_rec(DdManager *ddman, double *vec, DdNode *filter, DdNode **vars, int num_vars, int level, ODDNode *odd, long o);
@@ -237,6 +238,39 @@ void filter_double_vector_rec(DdManager *ddman, double *vec, DdNode *filter, DdN
 
 //------------------------------------------------------------------------------
 
+// apply max operator, i.e. vec[i] = max(vec[i], vec2[i]), where vec2 is an mtbdd
+
+EXPORT void max_double_vector_mtbdd(DdManager *ddman, double *vec, DdNode *vec2, DdNode **vars, int num_vars, ODDNode *odd)
+{
+	max_double_vector_mtbdd_rec(ddman, vec, vec2, vars, num_vars, 0, odd, 0);
+}
+
+void max_double_vector_mtbdd_rec(DdManager *ddman, double *vec, DdNode *filter, DdNode **vars, int num_vars, int level, ODDNode *odd, long o)
+{
+	DdNode *dd;
+	double d;
+	
+	if (level == num_vars) {
+	
+		d = Cudd_V(filter);
+		if (d > vec[o]) {
+			vec[o] = d;
+		}
+	}
+	else {
+		if (odd->eoff > 0) {
+			dd = (filter->index > vars[level]->index) ? filter : Cudd_E(filter);
+			max_double_vector_mtbdd_rec(ddman, vec, dd, vars, num_vars, level+1, odd->e, o);
+		}
+		if (odd->toff > 0) {
+			dd = (filter->index > vars[level]->index) ? filter : Cudd_T(filter);
+			max_double_vector_mtbdd_rec(ddman, vec, dd, vars, num_vars, level+1, odd->t, o+odd->eoff);
+		}
+	}
+}	
+
+//------------------------------------------------------------------------------
+
 // get value of first element in BDD filter
 
 EXPORT double get_first_from_bdd(DdManager *ddman, double *vec, DdNode *filter, DdNode **vars, int num_vars, ODDNode *odd)

prism/src/prism/StateValues.java

@@ -43,6 +43,7 @@ public interface StateValues
 	void add(StateValues sp);
 	void timesConstant(double d);
 	void filter(JDDNode filter);
+	public void maxMTBDD(JDDNode vec2);
 	void clear();
 	int getNNZ();
 	String getNNZString();

prism/src/prism/StateValuesDV.java

@@ -196,6 +196,13 @@ public class StateValuesDV implements StateValues
 		values.filter(filter, vars, odd);
 	}
 	
+	// apply max operator, i.e. vec[i] = max(vec[i], vec2[i]), where vec2 is an mtbdd
+	
+	public void maxMTBDD(JDDNode vec2)
+	{
+		values.maxMTBDD(vec2, vars, odd);
+	}
+	
 	// clear (free memory)
 	
 	public void clear()

prism/src/prism/StateValuesMTBDD.java

@@ -212,6 +212,14 @@ public class StateValuesMTBDD implements StateValues
 		values = JDD.Apply(JDD.TIMES, values, filter);
 	}
 	
+	// apply max operator, i.e. vec[i] = max(vec[i], vec2[i]), where vec2 is an mtbdd
+	
+	public void maxMTBDD(JDDNode vec2)
+	{
+		JDD.Ref(vec2);
+		values = JDD.Apply(JDD.MAX, values, vec2);
+	}
+	
 	// clear
 	
 	public void clear()

prism/src/prism/StochModelChecker.java

@@ -196,6 +196,9 @@ public class StochModelChecker extends ProbModelChecker
 					throw e;
 				}
 				JDD.Deref(tmp);
+				// set values to exactly 1 for target (b2) states
+				// (these are computed inexactly during uniformisation)
+				probs.maxMTBDD(b2);
 			}
 			// [lTime,uTime] (including where lTime == uTime)
 			else {