improve code re-use and coverage

Author: michaelhglass

src/main/java/org/jreliability/sl/SL.java

@@ -140,13 +140,24 @@ protected void initialize(Term term) {
 	public double getProbabiliy(Transformer<T, Double> transformer) {
 		operandsStack.clear();
 		termCache.clear();
-		evaluate(transformer);
+		evaluateProbability(transformer);
 		// Evaluate leaves the final bit stream of the top event on the stack
 		BitSet bitstream = operandsStack.pop();
 		double probability = (double) bitstream.cardinality() / bitstream.size();
 		return probability;
 	}
 
+	@Override
+	public boolean isProvidingService(Map<T, Boolean> variables) {
+		operandsStack.clear();
+		termCache.clear();
+		// Evaluate leaves the final bit stream of the top event on the stack
+		evaluateStructureFunction(variables);
+		BitSet bitstream = operandsStack.pop();
+		System.err.println(bitstream);
+		return bitstream.cardinality() > 0;
+	}
+
 	/**
 	 * The evaluation performs the actual stochastic logic calculations by a
 	 * sequential processing of the different terms according to their order and
@@ -155,7 +166,7 @@ public double getProbabiliy(Transformer<T, Double> transformer) {
 	 * 
 	 * @param transformer the probability of the basic events
 	 */
-	protected void evaluate(Transformer<T, Double> transformer) {
+	protected void evaluateProbability(Transformer<T, Double> transformer) {
 		for (Term term : termsForStackProcessing) {
 			if (term instanceof LiteralTerm) {
 				BitSet bitstream = termCache.get(term);
@@ -166,26 +177,73 @@ protected void evaluate(Transformer<T, Double> transformer) {
 					termCache.put(term, bitstream);
 				}
 				operandsStack.push(bitstream);
-			} else if (term instanceof FALSETerm) {
-				BitSet bitstream = new BitSet(bitStreamLength);
-				bitstream.clear();
-				operandsStack.push(bitstream);
-			} else if (term instanceof TRUETerm) {
-				BitSet bitstream = new BitSet(bitStreamLength);
-				bitstream.set(0, bitstream.size(), true);
+			} else {
+				evaluateNonLiteralTerms(term, bitStreamLength);
+			}
+		}
+	}
+
+	/**
+	 * Evaluates the {@link Term} as SL would, but a bit stream length of 1
+	 * 
+	 * @param variables
+	 */
+	protected void evaluateStructureFunction(Map<T, Boolean> variables) {
+		for (Term term : termsForStackProcessing) {
+			if (term instanceof LiteralTerm) {
+				BitSet bitstream = termCache.get(term);
+				if (bitstream == null) {
+					@SuppressWarnings("unchecked")
+					LiteralTerm<T> component = (LiteralTerm<T>) term;
+					T variable = component.get();
+					bitstream = new BitSet(bitStreamLengthStructureFunction);
+					// Default: Set all entries to 1 (captures 1 variables and all non-specified
+					// ones)
+					// Careful, this only works in coherent systems!
+					bitstream.set(0, bitstream.size(), true);
+					// Pull 0 variables to all 0 bit streams
+					if (variables.containsKey(variable)) {
+						boolean isFailed = !variables.get(variable);
+						if (isFailed) {
+							bitstream.clear();
+						}
+					}
+					termCache.put(term, bitstream);
+				}
 				operandsStack.push(bitstream);
-			} else if (term instanceof ANDTerm) {
-				evaluateAND(term);
-			} else if (term instanceof ORTerm) {
-				evaluateOR(term);
-			} else if (term instanceof NOTTerm) {
-				evaluateNOT(term);
 			} else {
-				throw new IllegalArgumentException("SL does not support terms of class " + term.getClass());
+				evaluateNonLiteralTerms(term, bitStreamLengthStructureFunction);
 			}
 		}
 	}
 
+	/**
+	 * Helper function to process all terms that are not {@link LiteralTerm}s to
+	 * enhance code re-use.
+	 * 
+	 * @param term            the term to evaluate
+	 * @param bitstreamlength the length of the bit stream
+	 */
+	protected void evaluateNonLiteralTerms(Term term, int bitstreamlength) {
+		if (term instanceof FALSETerm) {
+			BitSet bitstream = new BitSet(bitStreamLength);
+			bitstream.clear();
+			operandsStack.push(bitstream);
+		} else if (term instanceof TRUETerm) {
+			BitSet bitstream = new BitSet(bitStreamLength);
+			bitstream.set(0, bitstream.size(), true);
+			operandsStack.push(bitstream);
+		} else if (term instanceof ANDTerm) {
+			evaluateAND(term);
+		} else if (term instanceof ORTerm) {
+			evaluateOR(term);
+		} else if (term instanceof NOTTerm) {
+			evaluateNOT(term);
+		} else {
+			throw new IllegalArgumentException("SL does not support terms of class " + term.getClass());
+		}
+	}
+
 	/**
 	 * The evaluation of an {@link ANDTerm} with respective AND operation on the bit
 	 * streams of the operands.
@@ -270,65 +328,6 @@ protected BitSet generateRandomBitstream(double probability) {
 		return bitstream;
 	}
 
-	@Override
-	public boolean isProvidingService(Map<T, Boolean> variables) {
-		operandsStack.clear();
-		termCache.clear();
-		// Evaluate leaves the final bit stream of the top event on the stack
-		evaluateStructureFunction(variables);
-		BitSet bitstream = operandsStack.pop();
-		System.err.println(bitstream);
-		return bitstream.cardinality() > 0;
-	}
-
-	/**
-	 * Evaluates the {@link Term} as SL would, but a bit stream length of 1
-	 * 
-	 * @param variables
-	 */
-	protected void evaluateStructureFunction(Map<T, Boolean> variables) {
-		for (Term term : termsForStackProcessing) {
-			if (term instanceof LiteralTerm) {
-				BitSet bitstream = termCache.get(term);
-				if (bitstream == null) {
-					@SuppressWarnings("unchecked")
-					LiteralTerm<T> component = (LiteralTerm<T>) term;
-					T variable = component.get();
-					bitstream = new BitSet(bitStreamLengthStructureFunction);
-					// Default: Set all entries to 1 (captures 1 variables and all non-specified
-					// ones)
-					// Careful, this only works in coherent systems!
-					bitstream.set(0, bitstream.size(), true);
-					// Pull 0 variables to all 0 bit streams
-					if (variables.containsKey(variable)) {
-						boolean isFailed = !variables.get(variable);
-						if (isFailed) { // Set all entries to 0
-							bitstream.clear();
-						}
-					}
-					termCache.put(term, bitstream);
-				}
-				operandsStack.push(bitstream);
-			} else if (term instanceof FALSETerm) {
-				BitSet bitstream = new BitSet(bitStreamLengthStructureFunction);
-				bitstream.clear();
-				operandsStack.push(bitstream);
-			} else if (term instanceof TRUETerm) {
-				BitSet bitstream = new BitSet(bitStreamLengthStructureFunction);
-				bitstream.set(0, bitstream.size(), true);
-				operandsStack.push(bitstream);
-			} else if (term instanceof ANDTerm) {
-				evaluateAND(term);
-			} else if (term instanceof ORTerm) {
-				evaluateOR(term);
-			} else if (term instanceof NOTTerm) {
-				evaluateNOT(term);
-			} else {
-				throw new IllegalArgumentException("SL does not support terms of class " + term.getClass());
-			}
-		}
-	}
-
 	/**
 	 * Returns the length of the bitstreams when using the {@link StructureFunction}
 	 * interface.

src/test/java/org/jreliability/sl/SLTest.java

@@ -223,4 +223,19 @@ public void testIsProvidingService() {
 		Assertions.assertFalse(sl.isProvidingService(failedComponents));
 	}
 
+	@Test
+	public void testGetSetBitStreamLength() {
+		// Sensor 1 & 2 in parallel, sensor 3 in series
+		String var1 = "sensor1";
+		Term s1 = new LiteralTerm<>(var1);
+		SL<String> sl = new SL<String>(s1);
+		
+		// Default 1
+		Assertions.assertEquals(sl.getBitStreamLengthStructureFunction(), 1);
+		
+		sl.setBitStreamLengthStructureFunction(100);
+		// Default 1
+		Assertions.assertEquals(sl.getBitStreamLengthStructureFunction(), 100);
+	}
+	
 }