[jboss-svn-commits] JBL Code SVN: r19348 - in labs/jbossrules/contrib/machinelearning/decisiontree/src/dt: memory and 1 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Mon Mar 31 18:44:25 EDT 2008
Author: gizil
Date: 2008-03-31 18:44:24 -0400 (Mon, 31 Mar 2008)
New Revision: 19348
Added:
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/FactLiteralAttributeComparator.java
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/NumberComparator.java
Modified:
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/builder/C45TreeBuilder.java
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/builder/Entropy.java
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/BooleanDomain.java
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/Domain.java
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/LiteralDomain.java
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/NumericDomain.java
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/FactProcessor.java
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/ObjectReader.java
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/RulePrinter.java
labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/Util.java
Log:
at last binary discretization works, i tried only Golf object a small one
Modified: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/builder/C45TreeBuilder.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/builder/C45TreeBuilder.java 2008-03-31 21:40:54 UTC (rev 19347)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/builder/C45TreeBuilder.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -187,7 +187,7 @@
System.out.println(Util.ntimes("*", 20) + " 1st best attr: "+ choosenDomain.getName());
TreeNode currentNode = new TreeNode(choosenDomain);
-
+
Hashtable<Object, List<Fact>> filtered_facts = FactProcessor.splitFacts(facts, choosenDomain);
dt.FACTS_READ += facts.size();
Modified: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/builder/Entropy.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/builder/Entropy.java 2008-03-31 21:40:54 UTC (rev 19347)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/builder/Entropy.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -3,6 +3,7 @@
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.Comparator;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
@@ -24,7 +25,7 @@
String attributeWithGreatestGain = attrs.get(0);
Domain attrDomain = dt.getDomain(attributeWithGreatestGain);
Domain bestDomain = null;
-
+ List<Integer> split_indices = null;
Domain<?> targetDomain = dt.getDomain(dt.getTarget());
for (String attr : attrs) {
System.out.println("Which attribute to try: "+ attr);
@@ -38,22 +39,26 @@
} else {
/* 1. sort the values */
Collections.sort(facts, facts.get(0).getDomain(attr).factComparator());
-
List<Fact> splits = getSplitPoints(facts, dt.getTarget());
attrDomain = dt.getDomain(attr).clone();
attrDomain.addPseudoValue(facts.get(facts.size()-1).getFieldValue(attr));
- System.out.println("entropy.chooseContAttribute(1)*********** hey the new values to split: "+ attrDomain.getValues().get(0));
-
+ System.out.println("entropy.chooseContAttribute(1)*********** num of split for "+
+ attr+": "+ attrDomain.getValues().size()+ " ("+ attrDomain.getValues().get(0)+")");
+ split_indices = new ArrayList<Integer>();
+ System.out.println("entropy.chooseContAttribute(BOK) size "+split_indices.size());
gain = dt_info - info_contattr(facts, attrDomain, targetDomain,
- facts_in_class, splits);
- System.out.println("entropy.chooseContAttribute(2)*********** hey the new values to split: "+ attrDomain.getValues().size());
+ facts_in_class, split_indices, splits);
+ System.out.println("entropy.chooseContAttribute(2)*********** num of split for "+
+ attr+": "+ attrDomain.getValues().size());
}
if (gain > greatestGain) {
greatestGain = gain;
attributeWithGreatestGain = attr;
bestDomain = attrDomain;
+ if (!bestDomain.isDiscrete())
+ bestDomain.setIndices(split_indices);
}
}
@@ -88,13 +93,19 @@
public static double info_contattr(List<Fact> facts,
Domain splitDomain, Domain<?> targetDomain,
Hashtable<Object, Integer> facts_in_class,
+ List<Integer> split_indices,
List<Fact> split_facts) {
+
String splitAttr = splitDomain.getName();
List<?> splitValues = splitDomain.getValues();
String targetAttr = targetDomain.getName();
List<?> targetValues = targetDomain.getValues();
-
- System.out.println("What is the attributeToSplit? " + splitAttr);
+ System.out.println("entropy.info_cont() attributeToSplit? " + splitAttr);
+ int f_i=0;
+ for(Fact f: facts) {
+ System.out.println("entropy.info_cont() SORTING: "+f_i+" attr "+splitAttr+ " "+ f );
+ f_i++;
+ }
if (facts.size() <= 1) {
System.out
@@ -120,15 +131,17 @@
facts_at_attribute.setTargetDistForAttr(key1, facts_in_class);
facts_at_attribute.setSumForAttr(key1, facts.size());
- double best_sum = +100000.0;
+ double best_sum = -100000.0;
Object value_to_split = splitValues.get(0);
- int split_index, index = 1;
-
+ int split_index =1, index = 1;
Iterator<Fact> f_ite = facts.iterator();
Fact f1 = f_ite.next();
+ Comparator<Fact> targetComp = f1.getDomain(targetAttr).factComparator();
+ System.out.println("\nentropy.info_cont() SEARCHING: "+split_index+" attr "+splitAttr+ " "+ f1 );
while (f_ite.hasNext()) {/* 2. Look for potential cut-points. */
Fact f2 = f_ite.next();
+ System.out.print("entropy.info_cont() SEARCHING: "+(index+1)+" attr "+splitAttr+ " "+ f2 );
Object targetKey = f2.getFieldValue(targetAttr);
// System.out.println("My key: "+ targetKey.toString());
@@ -145,12 +158,13 @@
* two cutpoints of interest: 1.85 and 5 (mid-way between the points
* where the classes change from A to B or vice versa).
*/
- if (f1.getFieldValue(targetAttr) != f2.getFieldValue(targetAttr)) {
+
+ if ( targetComp.compare(f1, f2)!=0) {
// the cut point
Number cp_i = (Number) f1.getFieldValue(splitAttr);
Number cp_i_next = (Number) f2.getFieldValue(splitAttr);
- Number cut_point = (cp_i.doubleValue() + cp_i_next.doubleValue()) / 2;
+ Number cut_point = (Double)(cp_i.doubleValue() + cp_i_next.doubleValue()) / 2;
/*
* 3. Evaluate your favourite disparity measure
@@ -158,21 +172,27 @@
* and calculate its gain
*/
double sum = calc_info_attr(facts_at_attribute);
+ //System.out.println("**entropy.info_contattr() FOUND: "+ sum + " best sum "+best_sum +
+ System.out.println(" **Try "+ sum + " best sum "+best_sum +
+ " value ("+ f1.getFieldValue(splitAttr) +"-|"+ value_to_split+"|-"+ f2.getFieldValue(splitAttr)+")");
- if (sum < best_sum) {
+ if (sum > best_sum) {
best_sum = sum;
value_to_split = cut_point;
- System.out.println("Entropy.info_contattr() hacking: "+ sum + " best sum "+best_sum +
- " new split value "+ value_to_split);
+ System.out.println(Util.ntimes("?", 10)+"** FOUND: target ("+ f1.getFieldValue(targetAttr) +"-|T|-"+ f2.getFieldValue(targetAttr)+")");
split_index = index;
}
} else {}
f1 = f2;
index++;
}
- splitDomain.addValue(value_to_split);
-
- System.out.println("*********** hey the new values to split: "+ splitValues.size());
+ splitDomain.addPseudoValue(value_to_split);
+ Util.insert(split_indices, Integer.valueOf(split_index));
+ System.out.println("entropy.info_contattr(BOK_last) split_indices.size "+split_indices.size());
+ for(Integer i : split_indices)
+ System.out.println("entropy.info_contattr(FOUNDS) split_indices "+i + " the fact "+facts.get(i));
+ System.out.println("entropy.chooseContAttribute(1.5)*********** num of split for "+
+ splitAttr+": "+ splitDomain.getValues().size());
return best_sum;
}
Modified: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/BooleanDomain.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/BooleanDomain.java 2008-03-31 21:40:54 UTC (rev 19347)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/BooleanDomain.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -63,18 +63,27 @@
}
public Object readString(String data) {
- if (isValid(data))
- return Boolean.parseBoolean(data);
- else
+ System.out.print("What is the data : "+ data);
+ if (isValid(data)) {
+ if (data.trim().equalsIgnoreCase("true"))
+ return Boolean.TRUE;
+ else if ((data.trim().equalsIgnoreCase("false")))
+ return Boolean.FALSE;
+ else
+ return Boolean.parseBoolean(data);
+ }else
return null;
}
public boolean isValid(String string) {
try{
Boolean.parseBoolean(string);
+ //System.out.println("parse the boolean ");
return true;
}
catch (Exception e){
+ System.out.println("Can not parse the boolean "+e);
+ System.exit(0);
return false;
}
}
@@ -112,4 +121,12 @@
return null;
}
+ public void setIndices(List<Integer> split_indices) {
+ // TODO Auto-generated method stub
+ }
+
+ public List<Integer> getIndices() {
+ return null; //indices;
+ }
+
}
Modified: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/Domain.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/Domain.java 2008-03-31 21:40:54 UTC (rev 19347)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/Domain.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -31,6 +31,8 @@
Comparator<Fact> factComparator();
public Domain<T> clone();
+ void setIndices(List<Integer> split_indices);
+ List<Integer> getIndices();
}
Added: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/FactLiteralAttributeComparator.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/FactLiteralAttributeComparator.java (rev 0)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/FactLiteralAttributeComparator.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -0,0 +1,21 @@
+package dt.memory;
+
+import java.util.Comparator;
+
+import dt.tools.Util;
+
+public class FactLiteralAttributeComparator implements Comparator<Fact> {
+ private String attr_name;
+
+ public FactLiteralAttributeComparator(String _attr_name) {
+ attr_name = _attr_name;
+ }
+
+ public int compare(Fact f0, Fact f1) {
+ String n0 = (String) f0.getFieldValue(attr_name);
+ String n1 = (String) f1.getFieldValue(attr_name);
+
+ //System.out.println(Util.ntimes("!*", 10)+ " "+ n0 +" and " + n1 +" "+ n0.compareToIgnoreCase(n1));
+ return n0.compareToIgnoreCase(n1);
+ }
+}
\ No newline at end of file
Modified: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/LiteralDomain.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/LiteralDomain.java 2008-03-31 21:40:54 UTC (rev 19347)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/LiteralDomain.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -12,6 +12,7 @@
private boolean constant;
private boolean discrete;
private int readingSeq;
+ private Comparator<Fact> fComparator;
public LiteralDomain(String _name) {
@@ -19,6 +20,7 @@
fValues = new ArrayList<String>();
discrete = true;
readingSeq = -1;
+ fComparator = new FactLiteralAttributeComparator(_name);
}
public Domain<String> clone() {
@@ -26,6 +28,7 @@
dom.constant = constant;
dom.discrete = discrete;
dom.readingSeq = readingSeq;
+
return dom;
}
@@ -65,6 +68,8 @@
} else {
if (!fValues.contains(value))
fValues.add(value);
+ //Collections.sort(fValues, sComparator);
+ /* you have to sort these values or add them in sorted order*/
}
}
@@ -122,9 +127,14 @@
}
public Comparator<Fact> factComparator() {
- // TODO wee need groupings to be able to discretize the LiteralDomain
- System.out.println("LiteralDomain.factComparator() is not ready ");
- return null;
+ return fComparator;
}
+ public void setIndices(List<Integer> split_indices) {
+ // TODO Auto-generated method stub
+
+ }
+ public List<Integer> getIndices() {
+ return null; //indices;
+ }
}
Added: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/NumberComparator.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/NumberComparator.java (rev 0)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/NumberComparator.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -0,0 +1,17 @@
+package dt.memory;
+
+import java.util.Comparator;
+
+public class NumberComparator implements Comparator<Number> {
+ public NumberComparator() {
+ }
+
+ public int compare(Number n0, Number n1) {
+ if (n0.doubleValue() < n1.doubleValue())
+ return -1;
+ else if (n0.doubleValue() > n1.doubleValue())
+ return 1;
+ else
+ return 0;
+ }
+}
Modified: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/NumericDomain.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/NumericDomain.java 2008-03-31 21:40:54 UTC (rev 19347)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/memory/NumericDomain.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -9,18 +9,20 @@
private String fName;
private ArrayList<Number> fValues;
- private ArrayList<Fact> representatives;
+ private ArrayList<Integer> indices;
private boolean constant;
private boolean discrete;
private int readingSeq;
private Comparator<Fact> fComparator;
+ private Comparator<Number> nComparator;
public NumericDomain(String _name) {
fName = _name.trim();
fValues = new ArrayList<Number>();
discrete = true;
fComparator = new FactNumericAttributeComparator(_name);
+ nComparator = new NumberComparator();
readingSeq = -1;
}
@@ -35,7 +37,7 @@
public void setDiscrete(boolean d) {
this.discrete = d;
if (!this.discrete) {
- representatives = new ArrayList<Fact>();
+ indices = new ArrayList<Integer>();
}
}
@@ -63,16 +65,13 @@
if (discrete) {
return;
} else {
+
if (!fValues.contains(value))
fValues.add(value);
+ Collections.sort(fValues, nComparator);
}
}
- public void addRepresentative(Fact f) {
- if (!representatives.contains(f))
- representatives.add(f);
- Collections.sort(representatives, this.factComparator());
- }
public boolean contains(Number value) {
for(Number n: fValues) {
@@ -87,9 +86,6 @@
public List<Number> getValues() {
return fValues;
}
- public List<Fact> getRepresentatives() {
- return representatives;
- }
public int hashCode() {
@@ -177,4 +173,13 @@
return fComparator;
}
+ public void setIndices(List<Integer> split_indices) {
+ indices.clear();
+ indices.addAll(split_indices);
+ }
+
+ public List<Integer> getIndices() {
+ return indices;
+ }
+
}
Modified: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/FactProcessor.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/FactProcessor.java 2008-03-31 21:40:54 UTC (rev 19347)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/FactProcessor.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -1,8 +1,10 @@
package dt.tools;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.Comparator;
import java.util.Hashtable;
+import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
@@ -16,6 +18,7 @@
if (choosenDomain.isDiscrete()) {
return FactProcessor.splitFacts_disc(facts, choosenDomain);
} else {
+ Collections.sort(facts, choosenDomain.factComparator()); /* hack*/
return FactProcessor.splitFacts_cont(facts, choosenDomain);
}
}
@@ -32,13 +35,68 @@
}
return factLists;
}
-
+
/* it must work */
private static Hashtable<Object, List<Fact>> splitFacts_cont(
List<Fact> facts, Domain<?> attributeDomain) {
String attributeName = attributeDomain.getName();
+ System.out.println("FactProcessor.splitFacts_cont() attr_split "+ attributeName);
+
+ List<?> categorization = attributeDomain.getValues();
+ List<Integer> split_indices = attributeDomain.getIndices();
+ System.out.println("FactProcessor.splitFacts_cont() haniymis benim repsentativelerim: "+ categorization.size() + " and the split points "+ split_indices.size());
+
+ System.out.println("FactProcessor.splitFacts_cont() before splitting "+ facts.size());
+ int split_i =0;
+ for(int i=0; i<facts.size(); i++) {
+ if (split_i<split_indices.size() && split_indices.get(split_i).intValue()== i) {
+ System.out.println("PRINT*: FactProcessor.splitFacts_cont() will split at "+i + " the fact "+facts.get(i));
+ split_i ++;
+ } else {
+ System.out.println("PRINT: FactProcessor.splitFacts_cont() at "+i + " the fact "+facts.get(i));
+ }
+ }
+
+ Hashtable<Object, List<Fact>> factLists = new Hashtable<Object, List<Fact>>(categorization.size());
+ for (Object v: attributeDomain.getValues()) {
+ factLists.put(v, new ArrayList<Fact>());
+ }
+
+ //Comparator<Fact> cont_comp = attributeDomain.factComparator();
+ Iterator<Integer> splits_it = split_indices.iterator();
+ int start_point = 0;
+ int index = 0;
+ while (splits_it.hasNext()) {
+ int integer_index = splits_it.next().intValue();
+ Object category = attributeDomain.getValues().get(index);
+ //System.out.println("FactProcessor.splitFacts_cont() new category: "+ category);
+ Fact pseudo = new Fact();
+ try {
+ pseudo.add(attributeDomain, category);
+
+ System.out.println("FactProcessor.splitFacts_cont() new category: "+ category );
+ System.out.println(" ("+start_point+","+integer_index+")");
+ factLists.put(category, facts.subList(start_point, integer_index));
+ start_point = integer_index;
+
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ index++;
+
+ }
+ return factLists;
+ }
+
+ /* it must work */
+ private static Hashtable<Object, List<Fact>> splitFacts_cont_(
+ List<Fact> facts, Domain<?> attributeDomain) {
+
+ String attributeName = attributeDomain.getName();
+
System.out.println("FactProcessor.splitFacts_cont() kimi diziyoruz: "+ attributeName);
List<?> categorization = attributeDomain.getValues();
@@ -48,24 +106,33 @@
for (Object v: attributeDomain.getValues()) {
factLists.put(v, new ArrayList<Fact>());
}
- for (Fact f : facts) {
- Comparator<Fact> cont_comp = attributeDomain.factComparator();
- ListIterator<?> category_it = attributeDomain.getValues().listIterator(attributeDomain.getValues().size() - 1);
- while (category_it.hasPrevious()) {
- Object category = category_it.previous();
- Fact pseudo = new Fact();
- try {
- pseudo.add(attributeDomain, category);
- if (cont_comp.compare(f, pseudo) < 0) {
- factLists.get(category).add(f);
- }
- } catch (Exception e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
+
+ Comparator<Fact> cont_comp = attributeDomain.factComparator();
+ Iterator<?> category_it = attributeDomain.getValues().iterator();
+ int start_point = 0;
+ while (category_it.hasNext()) {
+ Object category = category_it.next();
+ System.out.println("FactProcessor.splitFacts_cont() new category: "+ category);
+ Fact pseudo = new Fact();
+ try {
+ pseudo.add(attributeDomain, category);
+ int insertion_point_1 = Collections.binarySearch(facts, pseudo, cont_comp);
+ if (insertion_point_1 < 0)
+ factLists.put(category, facts.subList(start_point, -1*insertion_point_1));
+ else {
+
+ System.out.println("FactProcessor.splitFacts_cont() last category: "+
+ category + " the point "+-1*insertion_point_1 + " the size "+ facts.size());
+ factLists.put(category, facts.subList(start_point, insertion_point_1));
+ break;
}
-
+ start_point = -1* insertion_point_1;
+
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
}
-
+
}
return factLists;
}
Modified: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/ObjectReader.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/ObjectReader.java 2008-03-31 21:40:54 UTC (rev 19347)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/ObjectReader.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -64,22 +64,14 @@
// String name = attr_domain.getName();
if (field.equalsIgnoreCase(attr_domain.getName())) {
- String fieldString = attributeValues
- .get(attr_domain.getReadingSeq());
- Object fieldValue = attr_domain
- .readString(fieldString);
+ String fieldString = attributeValues.get(attr_domain.getReadingSeq());
+ Object fieldValue = attr_domain.readString(fieldString);
if (attr_domain instanceof NumericDomain) {
- if (param_type_name[0].getName()
- .equalsIgnoreCase("int")) {
- fieldValue = ((Number) fieldValue)
- .intValue();
-
- } else if (param_type_name[0].getName()
- .equalsIgnoreCase("float")) {
- fieldValue = ((Number) fieldValue)
- .floatValue();
-
+ if (param_type_name[0].getName().equalsIgnoreCase("int")) {
+ fieldValue = ((Number) fieldValue).intValue();
+ } else if (param_type_name[0].getName().equalsIgnoreCase("float")) {
+ fieldValue = ((Number) fieldValue).floatValue();
} else if (!param_type_name[0].getName()
.equalsIgnoreCase("double")) {
System.out
@@ -89,8 +81,8 @@
System.exit(0);
}
} else if (attr_domain instanceof LiteralDomain) {
- if (param_type_name[0].getName()
- .equalsIgnoreCase("java.lang.String")) {
+ if (param_type_name[0].getName().equalsIgnoreCase("java.lang.String")) {
+ //fieldValue = ((Number) fieldValue).floatValue();
} else {
System.out
.println("What the hack, which type of string is this?? "
@@ -98,17 +90,18 @@
System.exit(0);
}
} else if (attr_domain instanceof BooleanDomain) {
- if (param_type_name[0].getName()
- .equalsIgnoreCase("boolean")) {
+ if (param_type_name[0].getName().equalsIgnoreCase("boolean")) {
+// if ((Boolean) fieldValue) {
+// System.out.println("What the hack, true"+ fieldValue);
+// System.exit(0);
+// }
+ fieldValue = ((Boolean) fieldValue).booleanValue();
} else {
- System.out
- .println("What the hack, which type of boolean is this?? "
- + fieldValue);
+ System.out.println("What the hack, which type of boolean is this?? "+ fieldValue);
System.exit(0);
}
} else {
- System.out
- .println("What the hack, which type of object is this?? "
+ System.out.println("What the hack, which type of object is this?? "
+ fieldValue);
System.exit(0);
}
Modified: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/RulePrinter.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/RulePrinter.java 2008-03-31 21:40:54 UTC (rev 19347)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/RulePrinter.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -60,7 +60,7 @@
}
int i = 0;
- Collections.sort(rules, Rule.getRankComparator());
+ //Collections.sort(rules, Rule.getRankComparator());
for( Rule rule: rules) {
i++;
System.out.println("//rule " +i + " write to drl \n"+ rule +"\n");
@@ -75,6 +75,8 @@
}
private void dfs(TreeNode my_node) {
+ System.out.println("How many guys there of "+my_node.getDomain().getName() +" : "+my_node.getDomain().getValues().size());
+
NodeValue node_value = new NodeValue(my_node);
nodes.push(node_value);
@@ -169,8 +171,8 @@
out.close();
//System.out.println("I wrote "+ toWrite);
} catch (IOException e) {
- System.out.println("No I cannot write to the file");
- System.exit(0);
+ System.out.println("No I cannot write to the file (appending) e:"+ e);
+ /* TODO */
}
} else {
@@ -182,7 +184,8 @@
out.close();
System.out.println("I wrote "+ toWrite);
} catch (IOException e) {
- System.out.println("No I cannot write to the file");
+ System.out.println("No I cannot write to the file (creating new file) e:"+ e);
+ /* TODO */
}
}
}
@@ -267,20 +270,18 @@
return out;
}
-
-
-
public static Comparator<Rule> getRankComparator() {
return new RuleComparator();
}
private static class RuleComparator implements Comparator<Rule>{
+ // this will sort from best rank to least rank
public int compare(Rule r1, Rule r2) {
if (r1.getRank() < r2.getRank())
- return -1;
+ return 1; // normally -1
else if (r1.getRank() > r2.getRank())
- return 1;
+ return -1; // normally 1
else
return 0;
}
@@ -327,8 +328,14 @@
if (node.getDomain().isDiscrete())
return node.getDomain() + " == "+ value;
- else
- return node.getDomain() + " <= "+ value;
+ else {
+ int size = node.getDomain().getValues().size();
+ System.out.println("How many guys there of "+node.getDomain().getName() +" and the value "+nodeValue+" : "+size);
+ if (node.getDomain().getValues().lastIndexOf(nodeValue) == size-1)
+ return node.getDomain() + " > "+ node.getDomain().getValues().get(size-2);
+ else
+ return node.getDomain() + " <= "+ value;
+ }
}
}
Modified: labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/Util.java
===================================================================
--- labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/Util.java 2008-03-31 21:40:54 UTC (rev 19347)
+++ labs/jbossrules/contrib/machinelearning/decisiontree/src/dt/tools/Util.java 2008-03-31 22:44:24 UTC (rev 19348)
@@ -1,6 +1,10 @@
package dt.tools;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
public class Util {
public static String ntimes(String s,int n){
@@ -74,6 +78,29 @@
public static String sum() {
return "sum";
}
+
+ public static void insert(List<Object> list, Object key, Comparator<Object> c) {
+ int insertion_point_1 = Collections.binarySearch(list, key, c);
+ if (insertion_point_1 <0)
+ list.add(-(insertion_point_1+1), key);
+ else {
+ System.out.println("Util.insert() It exits ???");
+ }
+
+ }
+ public static void insert(List list, Object key) {
+// if (list.isEmpty())
+// list.add(key);
+ int insertion_point_1 = Collections.binarySearch(list, key);
+// if (list.isEmpty())
+// System.out.println(Util.ntimes("*", 10)+Util.ntimes("BOK", 5) +" \n What the fuck index is when it is empty "+ insertion_point_1);
+ if (insertion_point_1 <0)
+ list.add(-(insertion_point_1+1), key);
+ else {
+ System.out.println("Util.insert() It exits ???");
+ }
+
+ }
More information about the jboss-svn-commits
mailing list