Filters are now functions instead of Predicates.

michael-rapp · Aug 30, 2018 · af6fe96 · af6fe96
1 parent df154e5
commit af6fe96
Show file tree

Hide file tree

Showing 4 changed files with 31 additions and 34 deletions.
diff --git a/src/main/java/de/mrapp/apriori/Filter.kt b/src/main/java/de/mrapp/apriori/Filter.kt
@@ -24,7 +24,7 @@ import java.util.function.Predicate
  * @author Michael Rapp
  * @since 1.2.0
  */
-interface Filter<T> : Predicate<T> {
+interface Filter<T> : (T) -> Boolean {
 
     companion object {
 
@@ -94,8 +94,8 @@ interface Filter<T> : Predicate<T> {
             return ItemSetFilter(Predicate { x -> x.size in minSize..maxSize }, this)
         }
 
-        override fun test(t: ItemSet<*>): Boolean {
-            return predicate.test(t) && (parent?.test(t) ?: true)
+        override fun invoke(t: ItemSet<*>): Boolean {
+            return predicate.test(t) && (parent?.invoke(t) ?: true)
         }
 
     }
@@ -182,8 +182,8 @@ interface Filter<T> : Predicate<T> {
             }, this)
         }
 
-        override fun test(t: AssociationRule<*>): Boolean {
-            return predicate.test(t) && (parent?.test(t) ?: true)
+        override fun invoke(t: AssociationRule<*>): Boolean {
+            return predicate.test(t) && (parent?.invoke(t) ?: true)
         }
 
     }

diff --git a/src/main/java/de/mrapp/apriori/FrequentItemSets.kt b/src/main/java/de/mrapp/apriori/FrequentItemSets.kt
@@ -19,7 +19,6 @@ import de.mrapp.util.datastructure.SortedArraySet
 import java.io.Serializable
 import java.text.DecimalFormat
 import java.util.*
-import java.util.function.Predicate
 
 /**
  * A sorted set, which contains frequent item sets.
@@ -90,11 +89,11 @@ class FrequentItemSets<ItemType : Item> : SortedArraySet<ItemSet<ItemType>>,
         return FrequentItemSets(this, comparator)
     }
 
-    override fun filter(predicate: Predicate<in ItemSet<*>>): FrequentItemSets<ItemType> {
+    override fun filter(predicate: (ItemSet<*>) -> Boolean): FrequentItemSets<ItemType> {
         val filteredFrequentItemSets = FrequentItemSets(comparator())
 
         for (itemSet in this) {
-            if (predicate.test(itemSet)) {
+            if (predicate.invoke(itemSet)) {
                 filteredFrequentItemSets.add(itemSet)
             }
         }

diff --git a/src/main/java/de/mrapp/apriori/datastructure/Filterable.kt b/src/main/java/de/mrapp/apriori/datastructure/Filterable.kt
@@ -15,11 +15,9 @@ package de.mrapp.apriori.datastructure
 
 import de.mrapp.apriori.Filter
 
-import java.util.function.Predicate
-
 /**
- * Defines the interface, a data structure, which is filterable using [Predicate] or [Filter]
- * instances, must implement.
+ * Defines the interface, a data structure, which is filterable using a predicate function or
+ * [Filter] instance, must implement.
  *
  * @param DataStructureType The type of the data structure
  * @param T                 The type of the items, which are contained by the data structure
@@ -30,10 +28,10 @@ interface Filterable<DataStructureType, T> {
 
     /**
      * Filters the items, which are contained by the data structure. Only the items, which are
-     * accepted by the given [Predicate] or [Filter], are retained.
+     * accepted by the given function or [Filter] instance, are retained.
      *
      * @return A new data structure, which contains the filtered items
      */
-    fun filter(predicate: Predicate<in T>): DataStructureType
+    fun filter(predicate: (T) -> Boolean): DataStructureType
 
 }
diff --git a/src/test/java/de/mrapp/apriori/FilterTest.kt b/src/test/java/de/mrapp/apriori/FilterTest.kt
@@ -32,7 +32,7 @@ class FilterTest {
         itemSet.add(NamedItem("b"))
         itemSet.add(NamedItem("c"))
         val filter = Filter.forItemSets()
-        assertTrue(filter.test(itemSet))
+        assertTrue(filter.invoke(itemSet))
     }
 
     /**
@@ -46,11 +46,11 @@ class FilterTest {
         itemSet.add(NamedItem("c"))
         itemSet.support = 0.5
         val filter = Filter.forItemSets().bySupport(0.3, 0.8)
-        assertTrue(filter.test(itemSet))
+        assertTrue(filter.invoke(itemSet))
         itemSet.support = 0.2
-        assertFalse(filter.test(itemSet))
+        assertFalse(filter.invoke(itemSet))
         itemSet.support = 0.9
-        assertFalse(filter.test(itemSet))
+        assertFalse(filter.invoke(itemSet))
     }
 
     @Test(expected = IllegalArgumentException::class)
@@ -79,11 +79,11 @@ class FilterTest {
         itemSet.add(NamedItem("a"))
         itemSet.support = 0.5
         val filter = Filter.forItemSets().bySize(2, 2)
-        assertFalse(filter.test(itemSet))
+        assertFalse(filter.invoke(itemSet))
         itemSet.add(NamedItem("b"))
-        assertTrue(filter.test(itemSet))
+        assertTrue(filter.invoke(itemSet))
         itemSet.add(NamedItem("c"))
-        assertFalse(filter.test(itemSet))
+        assertFalse(filter.invoke(itemSet))
     }
 
     @Test(expected = IllegalArgumentException::class)
@@ -104,7 +104,7 @@ class FilterTest {
         head.add(NamedItem("c"))
         val associationRule = AssociationRule(body, head, 0.5)
         val filter = Filter.forAssociationRules()
-        assertTrue(filter.test(associationRule))
+        assertTrue(filter.invoke(associationRule))
     }
 
     @Test
@@ -115,11 +115,11 @@ class FilterTest {
         head.add(NamedItem("b"))
         var associationRule = AssociationRule(body, head, 0.5)
         val filter = Filter.forAssociationRules().byOperator(Support(), 0.4, 0.6)
-        assertTrue(filter.test(associationRule))
+        assertTrue(filter.invoke(associationRule))
         associationRule = AssociationRule(body, head, 0.3)
-        assertFalse(filter.test(associationRule))
+        assertFalse(filter.invoke(associationRule))
         associationRule = AssociationRule(body, head, 0.7)
-        assertFalse(filter.test(associationRule))
+        assertFalse(filter.invoke(associationRule))
     }
 
     @Test(expected = IllegalArgumentException::class)
@@ -140,11 +140,11 @@ class FilterTest {
         head.add(NamedItem("b"))
         val associationRule = AssociationRule(body, head, 0.5)
         val filter = Filter.forAssociationRules().bySize(3, 3)
-        assertFalse(filter.test(associationRule))
+        assertFalse(filter.invoke(associationRule))
         body.add(NamedItem("c"))
-        assertTrue(filter.test(associationRule))
+        assertTrue(filter.invoke(associationRule))
         body.add(NamedItem("d"))
-        assertFalse(filter.test(associationRule))
+        assertFalse(filter.invoke(associationRule))
     }
 
     @Test(expected = IllegalArgumentException::class)
@@ -165,11 +165,11 @@ class FilterTest {
         head.add(NamedItem("b"))
         val associationRule = AssociationRule(body, head, 0.5)
         val filter = Filter.forAssociationRules().byBodySize(2, 2)
-        assertFalse(filter.test(associationRule))
+        assertFalse(filter.invoke(associationRule))
         body.add(NamedItem("c"))
-        assertTrue(filter.test(associationRule))
+        assertTrue(filter.invoke(associationRule))
         body.add(NamedItem("d"))
-        assertFalse(filter.test(associationRule))
+        assertFalse(filter.invoke(associationRule))
     }
 
     @Test(expected = IllegalArgumentException::class)
@@ -190,11 +190,11 @@ class FilterTest {
         head.add(NamedItem("b"))
         val associationRule = AssociationRule(body, head, 0.5)
         val filter = Filter.forAssociationRules().byHeadSize(2, 2)
-        assertFalse(filter.test(associationRule))
+        assertFalse(filter.invoke(associationRule))
         head.add(NamedItem("c"))
-        assertTrue(filter.test(associationRule))
+        assertTrue(filter.invoke(associationRule))
         head.add(NamedItem("d"))
-        assertFalse(filter.test(associationRule))
+        assertFalse(filter.invoke(associationRule))
     }
 
     @Test(expected = IllegalArgumentException::class)