Added tests

Author: bugfoo

pom.xml

@@ -4,7 +4,7 @@
 
   <groupId>lac</groupId>
   <artifactId>lac</artifactId>
-  <version>0.1.0</version>
+  <version>0.2.0</version>
   <packaging>jar</packaging>
 
   <name>lac</name>
@@ -21,6 +21,28 @@
       <artifactId>snakeyaml</artifactId>
       <version>1.24</version>
     </dependency>
+
+    <!-- https://mvnrepository.com/artifact/junit/junit -->
+    <dependency>
+        <groupId>junit</groupId>
+        <artifactId>junit</artifactId>
+        <version>4.12</version>
+        <scope>test</scope>
+    </dependency>
+
+    <!-- https://mvnrepository.com/artifact/org.mockito/mockito-core -->
+    <dependency>
+        <groupId>org.mockito</groupId>
+        <artifactId>mockito-core</artifactId>
+        <version>3.1.0</version>
+        <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.github.stefanbirkner</groupId>
+      <artifactId>system-rules</artifactId>
+      <version>1.19.0</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 
   <build>

src/main/java/lac/algorithms/Classifier.java

@@ -28,7 +28,7 @@ public class Classifier {
     /**
      * Value used when the classifier is not able to perform a prediction
      */
-    protected static short NO_PREDICTION = -1;
+    public static short NO_PREDICTION = -1;
 
     /**
      * Array of rules forming the classifier

src/main/java/lac/algorithms/Rule.java

@@ -133,7 +133,7 @@ public long getSupportRule() {
      * 
      * @return relative support for the consequent
      */
-    public long getSupportConsequent() {
+    public long getSupportKlass() {
         return this.supportKlass;
     }
 
@@ -153,12 +153,12 @@ public boolean matching(Short[] example) {
     /**
      * Function to check if a rule is equal to another given.
      * 
-     * @param rule Rule to compare with current
+     * @param other Rule to compare with current
      * @return true if they are equal, false otherwise
      */
     @Override
-    public boolean equals(Object o) {
-        Rule rule = (Rule) o;
+    public boolean equals(Object other) {
+        Rule rule = (Rule) other;
 
         if (this.klass != rule.getKlass())
             return false;
@@ -242,7 +242,7 @@ public long getSupportAntecedent() {
     /**
      * Function which sets the rule's klass.
      * 
-     * @param klasss rule's klass
+     * @param klass rule's klass
      */
     public void setKlass(short klass) {
         this.klass = klass;

src/main/java/lac/algorithms/acn/Rule.java

@@ -183,24 +183,26 @@ public boolean matching(Short[] example) {
         if (antecedent.isEmpty())
             return true;
 
-        if (this.isNegative()) {
+        if (!this.isNegative()) {
+            return super.matching(example);
+        } else {
             ArrayList<Short> positiveAntecedent = new ArrayList<Short>();
+            List<Short> exampleA = Arrays.asList(example);
 
             for (int i = 0; i < this.antecedent.size(); i++) {
                 if (this.negatedItems.get(i)) {
                     short negativeItem = this.antecedent.get(i);
 
                     // If contain negative Item, it cannot match this example
-                    if (antecedent.contains(negativeItem))
+                    if (exampleA.contains(negativeItem)) {
                         return false;
+                    }
                 } else {
                     positiveAntecedent.add(this.antecedent.get(i));
                 }
             }
 
             return Utils.isSubset(positiveAntecedent, example);
-        } else {
-            return super.matching(example);
         }
     }
 }

src/main/java/lac/algorithms/adt/Config.java

@@ -51,6 +51,15 @@ public void setMinConf(Double confidence) {
         this.minConf = confidence;
     }
 
+    /**
+     * Sets the minimum confidence
+     * 
+     * @param confidence
+     */
+    public void setMinConf(Integer confidence) {
+        this.minConf = confidence;
+    }
+
     /**
      * Get the minimum value for the merit measure
      * 
@@ -68,4 +77,22 @@ public double getMinMerit() {
     public void setMinMerit(Double minMerit) {
         this.minMerit = minMerit;
     }
+
+    /**
+     * Sets the minimum value for the merit measure
+     * 
+     * @param minMerit minimum value for merit
+     */
+    public void setMinMerit(Integer minMerit) {
+        this.minMerit = minMerit;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#toString()
+     */
+    public String toString() {
+        return "minConf=" + this.minConf + " minMerit=" + this.minMerit;
+    }
 }

src/main/java/lac/algorithms/adt/Rule.java

@@ -117,7 +117,7 @@ public double getPessimisticErrorEstimate() {
      * @see lac.algorithms.Rule#toString()
      */
     public String toString() {
-        return super.toString() + " hits: " + this.hits + " misses: " + this.misses + " per; "
+        return super.toString() + " hits: " + this.hits + " misses: " + this.misses + " per: "
                 + this.getPessimisticErrorEstimate();
     }
 

src/main/java/lac/algorithms/cba/Config.java

@@ -31,11 +31,6 @@ public class Config extends lac.algorithms.Config {
      */
     private double minConf = 0.5;
 
-    /**
-     * Maximum number of rules
-     */
-    private long limitRules = 80000;
-
     /**
      * Set the value of minimum support
      * 
@@ -72,24 +67,6 @@ public void setMinConf(Integer minConf) {
         this.minConf = minConf;
     }
 
-    /**
-     * Set the limit of rules to be extracted
-     * 
-     * @param limitRules to be extracted
-     */
-    public void setLimitRules(Long limitRules) {
-        this.limitRules = limitRules <= 0 ? Long.MAX_VALUE : limitRules;
-    }
-
-    /**
-     * Set the limit of rules to be extracted
-     * 
-     * @param limitRules to be extracted
-     */
-    public void setLimitRules(Integer limitRules) {
-        this.setLimitRules(new Long(limitRules));
-    }
-
     /**
      * Minimum value of support for the rules
      * 
@@ -114,6 +91,6 @@ public double getMinConf() {
      * @see java.lang.Object#toString()
      */
     public String toString() {
-        return "minSup=" + this.minSup + " minConf=" + this.minConf + " limitRules=" + this.limitRules;
+        return "minSup=" + this.minSup + " minConf=" + this.minConf;
     }
 }

src/main/java/lac/algorithms/cba/Rule.java

@@ -87,6 +87,9 @@ public Rule() {
      */
     public Rule(short klass) {
         super(klass);
+        this.klassesCovered = new HashMap<Short, Long>();
+        this.replace = new ArrayList<Replace>();
+        this.time = System.currentTimeMillis();
         this.pessimisticErrorRate = 0;
         this.hits = 0;
         this.misses = 0;
@@ -115,7 +118,7 @@ public double getPessimisticErrorRate() {
      * rule
      * 
      * @param a
-     * @return
+     * @return true if is subset, false otherwise
      */
     public boolean isSubset(Rule a) {
         if (this.klass != a.getKlass())

src/main/java/lac/algorithms/cmar/Config.java

@@ -47,6 +47,24 @@ public void setMinSup(Double minSup) {
         this.minSup = minSup;
     }
 
+    /**
+     * Set the minimum confidence for the rules
+     * 
+     * @param minConf minimum value for confidence
+     */
+    public void setMinConf(Integer minConf) {
+        this.minConf = minConf;
+    }
+
+    /**
+     * Set the minimum support for the rules
+     * 
+     * @param minSup minimum value for support
+     */
+    public void setMinSup(Integer minSup) {
+        this.minSup = minSup;
+    }
+
     /**
      * Set the minimum confidence for the rules
      * 

src/main/java/lac/algorithms/cmar/FPGrowth.java

@@ -373,7 +373,7 @@ protected void generateRules(short[] antecedent, int antecedentLength, long supp
             Rule rule = new Rule(itemsetOutputBuffer, entry.getKey());
             rule.setSupportAntecedent(support);
             rule.setSupportRule(entry.getValue());
-            rule.setSupportConsequent(dataset.getFrequencyByKlass().get(rule.getKlass()));
+            rule.setSupportKlass(dataset.getFrequencyByKlass().get(rule.getKlass()));
 
             if (rule.getSupportRule() >= this.minSupportRelative && rule.getConfidence() >= this.minConf)
                 rules.add(rule);