[jboss-svn-commits] JBL Code SVN: r21601 - labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Mon Aug 18 08:14:14 EDT 2008
Author: dsotty
Date: 2008-08-18 08:14:14 -0400 (Mon, 18 Aug 2008)
New Revision: 21601
Added:
labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/HeavyEvaluatorDefinition.java
Log:
New branch for uncertainty support in 5.x
Added: labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/HeavyEvaluatorDefinition.java
===================================================================
--- labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/HeavyEvaluatorDefinition.java (rev 0)
+++ labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/HeavyEvaluatorDefinition.java 2008-08-18 12:14:14 UTC (rev 21601)
@@ -0,0 +1,370 @@
+package org.drools.base.evaluators;
+
+import uncertainty.factory.IDegreeFactory;
+
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.drools.IUncertainRuleBase;
+import org.drools.RuntimeDroolsException;
+import org.drools.WorkingMemory;
+import org.drools.base.BaseEvaluator;
+import org.drools.base.BaseUncertainEvaluator;
+import org.drools.base.ValueType;
+import org.drools.common.InternalWorkingMemory;
+import org.drools.rule.VariableRestriction.VariableContextEntry;
+import org.drools.spi.Evaluator;
+import org.drools.spi.FieldValue;
+import org.drools.spi.IUncertainEvaluator;
+import org.drools.spi.InternalReadAccessor;
+
+import com.thoughtworks.xstream.core.util.Pool.Factory;
+
+import uncertainty.truthvals.IUncertainDegree;
+
+
+
+
+/**
+ *
+ * @author sotty
+
+ *
+ */
+public class HeavyEvaluatorDefinition implements IUncertainBinaryEvaluatorDefinition {
+
+
+
+ public class YoungEvaluator extends BaseUncertainEvaluator implements IUncertainEvaluator {
+
+ private double zeroRange;
+ private double oneRange;
+
+
+ public YoungEvaluator(final ValueType type,
+ final boolean isNegated,
+ final String parameters) {
+ super( type,
+ isNegated ? NOT_HEAVY : HEAVY );
+ this.parseParameters( parameters );
+ }
+
+ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ super.readExternal(in);
+ zeroRange = in.readDouble();
+ oneRange = in.readDouble();
+ }
+
+ public void writeExternal(ObjectOutput out) throws IOException {
+ super.writeExternal(out);
+ out.writeDouble(zeroRange);
+ out.writeDouble(oneRange);
+ }
+
+
+ /**
+ * Evaluator membership function definition
+ *
+ * @param age
+ * @return (age - min) / (max - min) clamped between 0 and 1.
+ */
+ protected IUncertainDegree eval(double weight, IDegreeFactory factory) {
+
+ return evalMu(weight, factory);
+ }
+
+
+
+
+ protected IUncertainDegree evalMu(double weight, IDegreeFactory factory) {
+
+ double val = (weight-zeroRange)/(oneRange-zeroRange);
+
+ return factory.buildDegree(val);
+ }
+
+
+ public IUncertainDegree evaluateUncertain(WorkingMemory workingMemory,
+ InternalReadAccessor extractor, Object object1, FieldValue value) {
+
+ if (! (workingMemory.getRuleBase() instanceof IUncertainRuleBase)) {
+ throw new RuntimeDroolsException("Heavy Evaluator : Uncertainty has not been enabled in the current Rule Base");
+ }
+ IDegreeFactory factory = ((IUncertainRuleBase) workingMemory.getRuleBase()).getTruthFactory();
+
+ Object weight = extractor.getValue(object1);
+ if (weight == null)
+ return factory.Unknown();
+
+ return evalMu((Double) weight,factory);
+ }
+
+ public boolean evaluate(InternalWorkingMemory workingMemory,
+ InternalReadAccessor extractor, Object object1, FieldValue value) {
+ return evaluateUncertain(workingMemory, extractor, object1, value).toBoolean();
+ }
+
+
+ public IUncertainDegree evaluateUncertain(WorkingMemory workingMemory,
+ InternalReadAccessor leftExtractor, Object left,
+ InternalReadAccessor rightExtractor, Object right) {
+ throw new RuntimeDroolsException( "The 'heavy' operator is a unary predicate" );
+ }
+
+ public boolean evaluate(InternalWorkingMemory workingMemory,
+ InternalReadAccessor leftExtractor, Object left,
+ InternalReadAccessor rightExtractor, Object right) {
+ return evaluateUncertain(workingMemory, leftExtractor, left, rightExtractor, right).toBoolean();
+ }
+
+
+ public IUncertainDegree evaluateUncertainCachedLeft(WorkingMemory workingMemory,
+ VariableContextEntry context, Object object1) {
+ throw new RuntimeDroolsException( "The 'heavy' operator unimplemented method II" );
+ }
+ public boolean evaluateCachedLeft(InternalWorkingMemory workingMemory,
+ VariableContextEntry context, Object object1) {
+ return evaluateUncertainCachedLeft(workingMemory, context, object1).toBoolean();
+ }
+
+
+ public IUncertainDegree evaluateUncertainCachedRight(WorkingMemory workingMemory,
+ VariableContextEntry context, Object object2) {
+ throw new RuntimeDroolsException( "The 'heavy' operator unimplemented method II" );
+ }
+ public boolean evaluateCachedRight(InternalWorkingMemory workingMemory,
+ VariableContextEntry context, Object object2) {
+ return evaluateUncertainCachedRight(workingMemory, context, object2).toBoolean();
+ }
+
+
+
+
+ @Override
+ public int hashCode() {
+ final int PRIME = 31;
+ int result = super.hashCode();
+ long one = Math.round(oneRange);
+ long zero = Math.round(zeroRange);
+ result = PRIME * result + (int) (one ^ (one >>> 32));
+ result = PRIME * result + (int) (zero ^ (zero >>> 32));
+ return result;
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if ( this == obj ) return true;
+ if ( !super.equals( obj ) ) return false;
+ if ( getClass() != obj.getClass() ) return false;
+ final YoungEvaluator other = (YoungEvaluator) obj;
+ return oneRange == other.oneRange && zeroRange == other.zeroRange;
+ }
+
+ /**
+ * This methods tries to parse the string of parameters to customize
+ * the evaluator.
+ *
+ * @param parameters
+ */
+ private void parseParameters(String parameters) {
+ if ( parameters == null || parameters.trim().length() == 0 ) {
+ // open bounded range
+ this.zeroRange = 0;
+ this.oneRange = 100;
+ return;
+ }
+
+ try {
+ String[] ranges = parameters.split( "," );
+ if ( ranges.length == 1 ) {
+ // deterministic point in time
+ this.zeroRange = Double.parseDouble( ranges[0] );
+ this.oneRange = 100;
+ } else if ( ranges.length == 2 ) {
+ // regular range
+ this.zeroRange = Double.parseDouble( ranges[0] );
+ this.oneRange = Double.parseDouble( ranges[1] );
+ } else {
+ throw new RuntimeDroolsException( "[Heavy Evaluator]: Not possible to parse parameters: '" + parameters + "'" );
+ }
+ } catch ( NumberFormatException e ) {
+ throw new RuntimeDroolsException( "[Heavy Evaluator]: Not possible to parse parameters: '" + parameters + "'",
+ e );
+ }
+ }
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ public static final Operator HEAVY = Operator.addOperatorToRegistry( "heavy",
+ false );
+
+ public static final Operator NOT_HEAVY = Operator.addOperatorToRegistry( "heavy",
+ true );
+
+ private static final String[] SUPPORTED_IDS = {HEAVY.getOperatorString()};
+
+ private Map<String, Evaluator> cache = Collections.emptyMap();
+
+
+
+
+
+
+ public Evaluator getEvaluator(ValueType type, String operatorId,
+ boolean isNegated, String parameterText) {
+
+
+ if ( this.cache == Collections.EMPTY_MAP ) {
+ this.cache = new HashMap<String, Evaluator>();
+ }
+ String key = isNegated + ":" + parameterText;
+ Evaluator eval = this.cache.get( key );
+ if ( eval == null ) {
+ eval = new YoungEvaluator( type,
+ isNegated,
+ parameterText );
+ this.cache.put( key,
+ eval );
+ }
+ return eval;
+
+
+
+ }
+
+ public Evaluator getEvaluator(ValueType type, Operator operator,
+ String parameterText) {
+ return getEvaluator(type,operator.getOperatorString(),false,parameterText);
+ }
+
+ public Evaluator getEvaluator(ValueType type, Operator operator) {
+ return getEvaluator(type,operator.getOperatorString(),false,"");
+ }
+
+
+
+
+
+ /**
+ * Operator is known as "young"ValueType type, Operator op
+ */
+ public String[] getEvaluatorIds() {
+ return SUPPORTED_IDS;
+ }
+
+
+
+
+
+
+
+ /**
+ * Young can be negated
+ * It is only by chance that "not young" coincides with the concept "old".
+ */
+ public boolean isNegatable() {
+ return true;
+ }
+
+
+
+ /**
+ * This evaluator operates on fact properties (i.e. age)
+ * and not on factHandles.
+ * So this returns false
+ */
+ public boolean operatesOnFactHandles() {
+ return false;
+ }
+
+
+
+
+
+ /**
+ * Young operates on numbers modelling age
+ */
+ public boolean supportsType(ValueType type) {
+ return type.isNumber();
+ }
+
+
+
+
+
+
+
+ /*
+ * TODO: Try and understand what this means. Copied from AfterEvalDef.
+ */
+
+
+ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ cache = (Map<String, Evaluator>) in.readObject();
+ }
+
+ public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeObject(cache);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
More information about the jboss-svn-commits
mailing list