[jboss-svn-commits] JBL Code SVN: r21602 - 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:27 EDT 2008
Author: dsotty
Date: 2008-08-18 08:14:26 -0400 (Mon, 18 Aug 2008)
New Revision: 21602
Added:
labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/IUncertainBinaryEvaluatorDefinition.java
labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/NearlyEvaluatorDefinition.java
labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/YoungEvaluatorDefinition.java
Log:
New branch for uncertainty support in 5.x
Added: labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/IUncertainBinaryEvaluatorDefinition.java
===================================================================
--- labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/IUncertainBinaryEvaluatorDefinition.java (rev 0)
+++ labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/IUncertainBinaryEvaluatorDefinition.java 2008-08-18 12:14:26 UTC (rev 21602)
@@ -0,0 +1,22 @@
+/**
+ *
+ */
+package org.drools.base.evaluators;
+
+import org.drools.RuntimeDroolsException;
+import org.drools.common.InternalWorkingMemory;
+import org.drools.rule.VariableRestriction.VariableContextEntry;
+import org.drools.spi.FieldValue;
+import org.drools.spi.InternalReadAccessor;
+
+import uncertainty.truthvals.IUncertainDegree;
+
+/**
+ * @author davide
+ *
+ */
+public interface IUncertainBinaryEvaluatorDefinition extends EvaluatorDefinition {
+
+
+
+}
Added: labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/NearlyEvaluatorDefinition.java
===================================================================
--- labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/NearlyEvaluatorDefinition.java (rev 0)
+++ labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/NearlyEvaluatorDefinition.java 2008-08-18 12:14:26 UTC (rev 21602)
@@ -0,0 +1,400 @@
+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 uncertainty.truthvals.IUncertainDegree;
+
+
+
+
+/**
+ *
+ * @author sotty
+
+ *
+ */
+public class NearlyEvaluatorDefinition implements IUncertainBinaryEvaluatorDefinition {
+
+
+
+ public class NearlyEvaluator extends BaseUncertainEvaluator implements IUncertainEvaluator {
+
+ private Double sigma;
+ //private Double mu;
+
+
+ public NearlyEvaluator(final ValueType type,
+ final boolean isNegated,
+ final String parameters) {
+ super( type,
+ isNegated ? NOT_NEARLY : NEARLY );
+ this.parseParameters( parameters );
+ }
+
+ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ super.readExternal(in);
+// mu = in.readDouble();
+ sigma = in.readDouble();
+ }
+
+ public void writeExternal(ObjectOutput out) throws IOException {
+ super.writeExternal(out);
+// out.writeDouble(mu);
+ out.writeDouble(sigma);
+ }
+
+
+ /**
+ * Evaluator membership function definition
+ *
+ * @param age
+ * @return (age - min) / (max - min) clamped between 0 and 1.
+ */
+ protected IUncertainDegree eval(Double x, Double mu, IDegreeFactory factory) {
+ return evalMu(x, mu, factory);
+ }
+
+
+
+
+ protected IUncertainDegree evalMu(Double x, Double mu, IDegreeFactory factory) {
+
+ Double val = Math.exp( - Math.pow( (x-mu)/sigma , 2) );
+
+ return factory.buildDegree(val);
+ }
+
+
+
+
+
+
+ public IUncertainDegree evaluateUncertain(WorkingMemory workingMemory,
+ InternalReadAccessor extractor, Object object1, FieldValue value) {
+
+
+ if (! (workingMemory.getRuleBase() instanceof IUncertainRuleBase)) {
+ throw new RuntimeDroolsException("Nearly Evaluator : Uncertainty has not been enabled in the current Rule Base");
+ }
+
+
+
+ IDegreeFactory factory = ((IUncertainRuleBase) workingMemory.getRuleBase()).getTruthFactory();
+
+
+ Object field = extractor.getValue(object1);
+ if (field == null)
+ return factory.Unknown();
+
+
+ Double val = ((Number) field).doubleValue();
+
+
+ return evalMu(val,value.getDoubleValue(),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) {
+
+ if (! (workingMemory.getRuleBase() instanceof IUncertainRuleBase)) {
+ throw new RuntimeDroolsException("Nearly Evaluator : Uncertainty has not been enabled in the current Rule Base");
+ }
+
+ IDegreeFactory factory = ((IUncertainRuleBase) workingMemory.getRuleBase()).getTruthFactory();
+
+
+ Object field1 = leftExtractor.getValue(left);
+ if (field1 == null)
+ return factory.Unknown();
+ Double val1 = ((Number) field1).doubleValue();
+
+
+ Object field2 = rightExtractor.getValue(right);
+ if (field2 == null)
+ return factory.Unknown();
+ Double val2 = ((Number) field2).doubleValue();
+
+
+ return evalMu(val1,val2,factory);
+
+ }
+
+ 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 'young' 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 'young' 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();
+ result = PRIME * result + (int) (sigma.longValue() ^ (sigma.longValue() >>> 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 NearlyEvaluator other = (NearlyEvaluator) obj;
+ return sigma == other.sigma;
+ }
+
+ /**
+ * 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.sigma = new Double(1);
+ return;
+ }
+
+ try {
+
+ this.sigma = Double.parseDouble( parameters );
+
+ } catch ( NumberFormatException e ) {
+ throw new RuntimeDroolsException( "[Young Evaluator]: Not possible to parse parameters: '" + parameters + "'",
+ e );
+ }
+ }
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ public static final Operator NEARLY = Operator.addOperatorToRegistry( "nearly",
+ false );
+
+ public static final Operator NOT_NEARLY = Operator.addOperatorToRegistry( "nearly",
+ true );
+
+ private static final String[] SUPPORTED_IDS = {NEARLY.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 NearlyEvaluator( 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;
+ }
+
+
+
+
+
+ /**
+ *
+ */
+ 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);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+}
Added: labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/YoungEvaluatorDefinition.java
===================================================================
--- labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/YoungEvaluatorDefinition.java (rev 0)
+++ labs/jbossrules/branches/uncDrools5x/drools-core/src/main/java/org/drools/base/evaluators/YoungEvaluatorDefinition.java 2008-08-18 12:14:26 UTC (rev 21602)
@@ -0,0 +1,368 @@
+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 uncertainty.truthvals.IUncertainDegree;
+
+
+
+
+/**
+ *
+ * @author sotty
+
+ *
+ */
+public class YoungEvaluatorDefinition 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_YOUNG : YOUNG );
+ 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 age, IDegreeFactory factory) {
+ return evalMu(age, factory);
+ }
+
+
+
+
+ protected IUncertainDegree evalMu(Double age, IDegreeFactory factory) {
+
+ Double val = (age-zeroRange)/(oneRange-zeroRange);
+
+ return factory.buildDegree(1-val);
+ }
+
+ public IUncertainDegree evaluateUncertain(WorkingMemory workingMemory,
+ InternalReadAccessor extractor, Object object1, FieldValue value) {
+
+
+ if (! (workingMemory.getRuleBase() instanceof IUncertainRuleBase)) {
+ throw new RuntimeDroolsException("Young Evaluator : Uncertainty has not been enabled in the current Rule Base");
+ }
+ IDegreeFactory factory = ((IUncertainRuleBase) workingMemory.getRuleBase()).getTruthFactory();
+
+ Object field = extractor.getValue(object1);
+ if (field == null)
+ return factory.Unknown();
+
+ Double age = new Double((Integer) field);
+
+
+ return evalMu(age,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 'young' 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 'young' 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 'young' 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();
+ result = PRIME * result + (int) (oneRange.longValue() ^ (oneRange.longValue() >>> 32));
+ result = PRIME * result + (int) (zeroRange.longValue() ^ (zeroRange.longValue() >>> 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 = new Double(0);
+ this.oneRange = new Double(100);
+ return;
+ }
+
+ try {
+ String[] ranges = parameters.split( "," );
+ if ( ranges.length == 1 ) {
+ // deterministic point in time
+ this.zeroRange = Double.parseDouble( ranges[0] );
+ this.oneRange = new Double(100);
+ } else if ( ranges.length == 2 ) {
+ // regular range
+ this.zeroRange = Double.parseDouble( ranges[0] );
+ this.oneRange = Double.parseDouble( ranges[1] );
+ } else {
+ throw new RuntimeDroolsException( "[Young Evaluator]: Not possible to parse parameters: '" + parameters + "'" );
+ }
+ } catch ( NumberFormatException e ) {
+ throw new RuntimeDroolsException( "[Young Evaluator]: Not possible to parse parameters: '" + parameters + "'",
+ e );
+ }
+ }
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ public static final Operator YOUNG = Operator.addOperatorToRegistry( "young",
+ false );
+
+ public static final Operator NOT_YOUNG = Operator.addOperatorToRegistry( "young",
+ true );
+
+ private static final String[] SUPPORTED_IDS = {YOUNG.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