woggioni/klevtree
1
0
Fork 0
Code Actions Packages Activity

refactor

Browse Source
This commit is contained in:
Walter Oggioni
2021-09-26 12:24:37 +02:00
parent 38b5416752
commit 61f5853ab9
17 changed files with 247 additions and 256 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/main/java9/module-info.java Normal file
View File

@@ -0,0 +1,4 @@
module net.woggioni.klevtree {
requires net.woggioni.jwo;
exports net.woggioni.klevtree;
}

39
src/main/kotlin/net/woggioni/klevtree/CharTrie.kt
View File

@@ -3,37 +3,32 @@ package net.woggioni.klevtree
import net.woggioni.klevtree.node.CharNode
import net.woggioni.klevtree.node.TrieNode
interface ICharTrie<PAYLOAD> : Trie<CharNode<PAYLOAD>, Char, PAYLOAD> {
class CaseInsensitiveKeyChecker : Trie.Keychecker<Char> {
open class CharTrie<PAYLOAD> : Trie<CharNode<PAYLOAD>, Char, PAYLOAD>() {
private class CaseInsensitiveKeyChecker : Keychecker<Char> {
override fun check(key1: Char?, key2: Char?) = key1 == key2
}
class CaseSensitiveKeyChecker : Trie.Keychecker<Char> {
override fun check(key1: Char?, key2: Char?) = key1?.toLowerCase() == key2?.toLowerCase()
private class CaseSensitiveKeyChecker : Keychecker<Char> {
override fun check(key1: Char?, key2: Char?) = key1?.lowercaseChar() == key2?.lowercaseChar()
}
var caseSensitive : Boolean
override val root: TrieNode<Char, PAYLOAD> = CharNode(null)
override val tails = mutableListOf<TrieNode<Char, PAYLOAD>>()
override var keyChecker: Keychecker<Char> = CaseSensitiveKeyChecker()
var caseSensitive : Boolean = true
set(value) {
if(value) {
keyChecker = CaseSensitiveKeyChecker()
} else {
keyChecker = CaseInsensitiveKeyChecker()
}
field = value
}
fun add(word : String) = super.add(word.asIterable())
fun search(word : String) : TrieNode<Char, PAYLOAD>? = search(word.asIterable().toList())
fun remove(word : String) = remove(word.asIterable().toList())
}
class CharTrie<PAYLOAD> : ICharTrie<PAYLOAD> {
override val root: TrieNode<Char, PAYLOAD> = CharNode(null)
override val tails = mutableListOf<TrieNode<Char, PAYLOAD>>()
override var keyChecker: Trie.Keychecker<Char> = ICharTrie.CaseSensitiveKeyChecker()
override var caseSensitive : Boolean = true
set(value) {
if(value) {
keyChecker = ICharTrie.CaseSensitiveKeyChecker()
} else {
keyChecker = ICharTrie.CaseInsensitiveKeyChecker()
}
field = value
}
}

65
src/main/kotlin/net/woggioni/klevtree/DistanceCalculator.kt Normal file
View File

@@ -0,0 +1,65 @@
package net.woggioni.klevtree
import net.woggioni.jwo.TreeNodeVisitor
sealed class DistanceCalculator {
abstract fun compute(keyChecker : Trie.Keychecker<Char>,
stack: List<TreeNodeVisitor.StackContext<LevNode, Unit>>,
wordkey: String,
worstCase : Int) : TreeNodeVisitor.VisitOutcome
object LevenshteinDistanceCalculator : DistanceCalculator() {
override fun compute(keyChecker : Trie.Keychecker<Char>,
stack: List<TreeNodeVisitor.StackContext<LevNode, Unit>>,
wordkey: String,
worstCase: Int) : TreeNodeVisitor.VisitOutcome {
val previousStackElement = stack[stack.size - 2]
val currentStackElement = stack.last()
val previousRow : IntArray = previousStackElement.node.payload!!
val currentRow : IntArray = currentStackElement.node.payload!!
for (i in 1..wordkey.length) {
if(keyChecker.check(wordkey[i - 1], currentStackElement.node.key)) {
currentRow[i] = previousRow[i - 1]
} else {
currentRow[i] = Math.min(Math.min(currentRow[i - 1], previousRow[i -1]), previousRow[i]) + 1
}
}
return if(worstCase >= 0 && worstCase <= currentRow.minOrNull()!!) {
TreeNodeVisitor.VisitOutcome.SKIP
} else {
TreeNodeVisitor.VisitOutcome.CONTINUE
}
}
}
object DamerauLevenshteinDistanceCalculator : DistanceCalculator() {
override fun compute(keyChecker : Trie.Keychecker<Char>,
stack: List<TreeNodeVisitor.StackContext<LevNode, Unit>>,
wordkey: String,
worstCase : Int) : TreeNodeVisitor.VisitOutcome {
val pse = stack[stack.size - 2]
val cse = stack.last()
val prow : IntArray = pse.node.payload!!
val crow : IntArray = cse.node.payload!!
for (i in 1..wordkey.length) {
if (keyChecker.check(wordkey[i - 1], cse.node.key)) {
crow[i] = prow[i - 1]
} else {
crow[i] = Math.min(Math.min(crow[i - 1], prow[i - 1]), prow[i]) + 1
}
if (stack.size > 2 && i > 1 && keyChecker.check(wordkey[i - 2], cse.node.key)
&& keyChecker.check(wordkey[i - 1], pse.node.key)) {
val ppse = stack[stack.size - 3]
val pprow: IntArray = ppse.node.payload!!
crow[i] = Math.min(crow[i], pprow[i - 2] + 1)
}
}
return if(worstCase >= 0 && worstCase <= prow.minOrNull()!!) {
TreeNodeVisitor.VisitOutcome.SKIP
} else {
TreeNodeVisitor.VisitOutcome.CONTINUE
}
}
}
}

108
src/main/kotlin/net/woggioni/klevtree/LevTrie.kt
View File

@@ -1,75 +1,17 @@
package net.woggioni.klevtree
import net.woggioni.jwo.tree.StackContext
import net.woggioni.jwo.tree.TreeNodeVisitor
import net.woggioni.jwo.tree.TreeWalker
import net.woggioni.jwo.TreeNodeVisitor
import net.woggioni.jwo.TreeWalker
import net.woggioni.klevtree.node.CharNode
import net.woggioni.klevtree.node.TrieNode
typealias LevNode = TrieNode<Char, IntArray>
internal typealias LevNode = TrieNode<Char, IntArray>
interface ILevTrie : ICharTrie<IntArray> {
class LevTrie : CharTrie<IntArray>() {
interface DistanceCalculator {
fun compute(keyChecker : Trie.Keychecker<Char>,
stack: List<StackContext<LevNode, Unit>>,
wordkey: String,
worstCase : Int) : TreeNodeVisitor.VisitOutcome
}
override val root: TrieNode<Char, IntArray> = CharNode(null)
object LevenshteinDistanceCalculator : DistanceCalculator {
override fun compute(keyChecker : Trie.Keychecker<Char>,
stack: List<StackContext<LevNode, Unit>>,
wordkey: String,
worstCase: Int) : TreeNodeVisitor.VisitOutcome {
val previousStackElement = stack[stack.size - 2]
val currentStackElement = stack.last()
val previousRow : IntArray = previousStackElement.node.payload!!
val currentRow : IntArray = currentStackElement.node.payload!!
for (i in 1..wordkey.length) {
if(keyChecker.check(wordkey[i - 1], currentStackElement.node.key)) {
currentRow[i] = previousRow[i - 1]
} else {
currentRow[i] = Math.min(Math.min(currentRow[i - 1], previousRow[i -1]), previousRow[i]) + 1
}
}
return if(worstCase >= 0 && worstCase <= currentRow.min()!!) {
TreeNodeVisitor.VisitOutcome.SKIP
} else {
TreeNodeVisitor.VisitOutcome.CONTINUE
}
}
}
object DamerauLevenshteinDistanceCalculator : DistanceCalculator {
override fun compute(keyChecker : Trie.Keychecker<Char>,
stack: List<StackContext<LevNode, Unit>>,
wordkey: String,
worstCase : Int) : TreeNodeVisitor.VisitOutcome {
val pse = stack[stack.size - 2]
val cse = stack.last()
val prow : IntArray = pse.node.payload!!
val crow : IntArray = cse.node.payload!!
for (i in 1..wordkey.length) {
if (keyChecker.check(wordkey[i - 1], cse.node.key)) {
crow[i] = prow[i - 1]
} else {
crow[i] = Math.min(Math.min(crow[i - 1], prow[i - 1]), prow[i]) + 1
}
if (stack.size > 2 && i > 1 && keyChecker.check(wordkey[i - 2], cse.node.key)
&& keyChecker.check(wordkey[i - 1], pse.node.key)) {
val ppse = stack[stack.size - 3]
val pprow: IntArray = ppse.node.payload!!
crow[i] = Math.min(crow[i], pprow[i - 2] + 1)
}
}
return if(worstCase >= 0 && worstCase <= prow.min()!!) {
TreeNodeVisitor.VisitOutcome.SKIP
} else {
TreeNodeVisitor.VisitOutcome.CONTINUE
}
}
}
override val tails = mutableListOf<TrieNode<Char, IntArray>>()
enum class Algorithm {
/**
@@ -82,20 +24,19 @@ interface ILevTrie : ICharTrie<IntArray> {
DAMERAU_LEVENSHTEIN
}
var distanceCalculator : DistanceCalculator
private var distanceCalculator : DistanceCalculator = DistanceCalculator.LevenshteinDistanceCalculator
var algorithm : Algorithm
get() {
return when(distanceCalculator) {
LevenshteinDistanceCalculator -> Algorithm.LEVENSHTEIN
DamerauLevenshteinDistanceCalculator -> Algorithm.DAMERAU_LEVENSHTEIN
else -> Algorithm.LEVENSHTEIN
DistanceCalculator.LevenshteinDistanceCalculator -> Algorithm.LEVENSHTEIN
DistanceCalculator.DamerauLevenshteinDistanceCalculator -> Algorithm.DAMERAU_LEVENSHTEIN
}
}
set(value) {
when(value) {
Algorithm.LEVENSHTEIN -> distanceCalculator = LevenshteinDistanceCalculator
Algorithm.DAMERAU_LEVENSHTEIN -> distanceCalculator = DamerauLevenshteinDistanceCalculator
distanceCalculator = when(value) {
Algorithm.LEVENSHTEIN -> DistanceCalculator.LevenshteinDistanceCalculator
Algorithm.DAMERAU_LEVENSHTEIN -> DistanceCalculator.DamerauLevenshteinDistanceCalculator
}
}
@@ -103,7 +44,7 @@ interface ILevTrie : ICharTrie<IntArray> {
val result = sortedSetOf<Pair<String, Int>>(compareBy({ it.second }, { it.first }))
val requiredSize = word.length + 1
val visitor = object: TreeNodeVisitor<LevNode, Unit> {
override fun visitPre(stack: List<StackContext<LevNode, Unit>>): TreeNodeVisitor.VisitOutcome {
override fun visitPre(stack: List<TreeNodeVisitor.StackContext<LevNode, Unit>>): TreeNodeVisitor.VisitOutcome {
val currentStackElement = stack.last()
val currentNode = currentStackElement.node
if(currentNode.payload == null ||
@@ -136,29 +77,8 @@ interface ILevTrie : ICharTrie<IntArray> {
}
}
}
val walker = TreeWalker<LevNode, Unit>(visitor)
val walker = TreeWalker(visitor)
walker.walk(root)
return result.toList()
}
}
class LevTrie : ILevTrie {
override val root: TrieNode<Char, IntArray> = CharNode(null)
override val tails = mutableListOf<TrieNode<Char, IntArray>>()
override var keyChecker: Trie.Keychecker<Char> = ICharTrie.CaseSensitiveKeyChecker()
override var caseSensitive : Boolean = true
set(value) {
if(value) {
keyChecker = ICharTrie.CaseSensitiveKeyChecker()
} else {
keyChecker = ICharTrie.CaseInsensitiveKeyChecker()
}
field = value
}
override var distanceCalculator : ILevTrie.DistanceCalculator = ILevTrie.LevenshteinDistanceCalculator
}

17
src/main/kotlin/net/woggioni/klevtree/Trie.kt
View File

@@ -1,21 +1,20 @@
package net.woggioni.klevtree
import net.woggioni.jwo.tree.StackContext
import net.woggioni.jwo.tree.TreeNodeVisitor
import net.woggioni.jwo.tree.TreeWalker
import net.woggioni.jwo.TreeNodeVisitor
import net.woggioni.jwo.TreeWalker
import net.woggioni.klevtree.node.TrieNode
interface Trie<T : TrieNode<KEY, PAYLOAD>, KEY, PAYLOAD> {
abstract class Trie<T : TrieNode<KEY, PAYLOAD>, KEY, PAYLOAD> {
interface Keychecker<KEY> {
fun check(key1 : KEY?, key2 : KEY?) : Boolean
}
var keyChecker : Keychecker<KEY>
protected abstract var keyChecker : Keychecker<KEY>
val root : TrieNode<KEY, PAYLOAD>
protected abstract val root : TrieNode<KEY, PAYLOAD>
val tails : MutableList<TrieNode<KEY, PAYLOAD>>
protected abstract val tails : MutableList<TrieNode<KEY, PAYLOAD>>
val words : Iterable<List<KEY>>
get() {
val res = object : Iterator<List<KEY>> {
@@ -126,7 +125,7 @@ interface Trie<T : TrieNode<KEY, PAYLOAD>, KEY, PAYLOAD> {
fun search(path : List<KEY>) : TrieNode<KEY, PAYLOAD>? {
var result : TrieNode<KEY, PAYLOAD>? = null
val visitor = object: TreeNodeVisitor<TrieNode<KEY, PAYLOAD>, Unit> {
override fun visitPre(stack: List<StackContext<TrieNode<KEY, PAYLOAD>, Unit>>): TreeNodeVisitor.VisitOutcome {
override fun visitPre(stack: List<TreeNodeVisitor.StackContext<TrieNode<KEY, PAYLOAD>, Unit>>): TreeNodeVisitor.VisitOutcome {
return if(stack.size == 1) {
TreeNodeVisitor.VisitOutcome.CONTINUE
} else {
@@ -147,7 +146,7 @@ interface Trie<T : TrieNode<KEY, PAYLOAD>, KEY, PAYLOAD> {
}
}
}
val walker = TreeWalker<TrieNode<KEY, PAYLOAD>, Unit>(visitor)
val walker = TreeWalker(visitor)
walker.walk(root)
return result
}

39
src/main/kotlin/net/woggioni/klevtree/WordTrie.kt
View File

@@ -3,38 +3,33 @@ package net.woggioni.klevtree
import net.woggioni.klevtree.node.StringNode
import net.woggioni.klevtree.node.TrieNode
interface IWordTrie<PAYLOAD> : Trie<StringNode<PAYLOAD>, String, PAYLOAD> {
open class WordTrie<PAYLOAD> : Trie<StringNode<PAYLOAD>, String, PAYLOAD>() {
class CaseInsensitiveKeyChecker : Trie.Keychecker<String> {
override val root: TrieNode<String, PAYLOAD> = StringNode(null)
override val tails = mutableListOf<TrieNode<String, PAYLOAD>>()
override var keyChecker: Keychecker<String> = CaseSensitiveKeyChecker()
private class CaseInsensitiveKeyChecker : Keychecker<String> {
override fun check(key1: String?, key2: String?) = key1 == key2
}
class CaseSensitiveKeyChecker : Trie.Keychecker<String> {
override fun check(key1: String?, key2: String?) = key1?.toLowerCase() == key2?.toLowerCase()
private class CaseSensitiveKeyChecker : Keychecker<String> {
override fun check(key1: String?, key2: String?) = key1?.lowercase() == key2?.lowercase()
}
var caseSensitive : Boolean
var caseSensitive : Boolean = true
set(value) {
if(value) {
keyChecker = CaseSensitiveKeyChecker()
} else {
keyChecker = CaseInsensitiveKeyChecker()
}
field = value
}
fun add(word : String, delimiter : String) = super.add(word.split(delimiter))
fun search(word : String, delimiter : String) : TrieNode<String, PAYLOAD>? {
return search(word.split(delimiter))
}
}
class WordTrie<PAYLOAD> : IWordTrie<PAYLOAD> {
override val root: TrieNode<String, PAYLOAD> = StringNode(null)
override val tails = mutableListOf<TrieNode<String, PAYLOAD>>()
override var keyChecker: Trie.Keychecker<String> = IWordTrie.CaseSensitiveKeyChecker()
override var caseSensitive : Boolean = true
set(value) {
if(value) {
keyChecker = IWordTrie.CaseSensitiveKeyChecker()
} else {
keyChecker = IWordTrie.CaseInsensitiveKeyChecker()
}
field = value
}
}

20
src/main/kotlin/net/woggioni/klevtree/node/nodes.kt
View File

@@ -1,8 +1,9 @@
package net.woggioni.klevtree.node
import net.woggioni.jwo.tree.TreeNode
import net.woggioni.jwo.TreeNodeVisitor
open class TrieNode<T, PAYLOAD>(val key : T?) : TreeNode<TrieNode<T, PAYLOAD>> {
open class TrieNode<T, PAYLOAD>(val key : T?) : TreeNodeVisitor.TreeNode<TrieNode<T, PAYLOAD>> {
var parent : TrieNode<T, PAYLOAD>? = null
var child : TrieNode<T, PAYLOAD>? = null
var next : TrieNode<T, PAYLOAD>? = null
@@ -36,21 +37,6 @@ open class TrieNode<T, PAYLOAD>(val key : T?) : TreeNode<TrieNode<T, PAYLOAD>> {
}
return chars.asReversed()
}
// fun root(node: TrieNode<Char>) : String {
// var node : TrieNode<Char>? = node
// val chars = mutableListOf<Char>()
// while(node != null) {
// val key = node.key
// if(key != Character.MIN_VALUE) {
// chars.add(node.key)
// }
// node = node.parent
// }
// val sb = StringBuilder()
// for(c in chars.asReversed()) sb.append(c)
// return sb.toString()
// }
}
class CharNode<PAYLOAD>(key : Char?) : TrieNode<Char, PAYLOAD>(key)

51
src/test/kotlin/net/woggioni/klevtree/LevtreeTest.kt
View File

@@ -1,8 +1,7 @@
package net.woggioni.klevtree
import org.junit.Assert
import org.junit.Test
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
class LevtreeTest {
@@ -10,27 +9,27 @@ class LevtreeTest {
fun trivialTest() {
val tree = LevTrie()
tree.caseSensitive = false
tree.algorithm = ILevTrie.Algorithm.DAMERAU_LEVENSHTEIN
tree.algorithm = LevTrie.Algorithm.DAMERAU_LEVENSHTEIN
val word = "dailies"
run {
val pair = tree.add(word)
Assert.assertTrue(pair.first)
Assertions.assertTrue(pair.first)
val node = tree.search(word)
Assert.assertNotNull(node)
Assert.assertEquals(
Assertions.assertNotNull(node)
Assertions.assertEquals(
word,
node!!.linealDescendant().fold(StringBuilder(), StringBuilder::append).toString()
)
val result = tree.fuzzySearch(word, 5)
Assert.assertEquals(1, result.size)
Assert.assertEquals(word to 0, result[0])
Assertions.assertEquals(1, result.size)
Assertions.assertEquals(word to 0, result[0])
}
run {
tree.remove(word)
val node = tree.search(word)
Assert.assertNull(node)
Assertions.assertNull(node)
val result = tree.fuzzySearch(word, 5)
Assert.assertEquals(0, result.size)
Assertions.assertEquals(0, result.size)
}
}
@@ -60,25 +59,25 @@ class LevtreeTest {
fun levenshteinDistanceTest() {
val tree = initLevTrie()
tree.caseSensitive = false
tree.algorithm = ILevTrie.Algorithm.LEVENSHTEIN
tree.algorithm = LevTrie.Algorithm.LEVENSHTEIN
run {
val word = "fired"
val result = tree.fuzzySearch(word, 4)
Assert.assertEquals(4, result.size)
Assert.assertEquals("tired" to 1, result[0])
Assertions.assertEquals(4, result.size)
Assertions.assertEquals("tired" to 1, result[0])
}
run {
val word = "tierd"
val result = tree.fuzzySearch(word, 4)
Assert.assertEquals(4, result.size)
Assert.assertEquals("tired" to 2, result[0])
Assertions.assertEquals(4, result.size)
Assertions.assertEquals("tired" to 2, result[0])
}
run {
val word = "tierd"
tree.remove("tired")
val result = tree.fuzzySearch(word, 4)
Assert.assertEquals(4, result.size)
Assert.assertEquals("trail" to 4, result[0])
Assertions.assertEquals(4, result.size)
Assertions.assertEquals("trail" to 4, result[0])
}
}
@@ -86,26 +85,26 @@ class LevtreeTest {
fun damerauLevenshteinDistanceTest() {
val tree = initLevTrie()
tree.caseSensitive = false
tree.algorithm = ILevTrie.Algorithm.DAMERAU_LEVENSHTEIN
tree.algorithm = LevTrie.Algorithm.DAMERAU_LEVENSHTEIN
run {
val word = "fired"
val result = tree.fuzzySearch(word, 4)
Assert.assertEquals(4, result.size)
Assert.assertEquals("tired" to 1, result[0])
Assertions.assertEquals(4, result.size)
Assertions.assertEquals("tired" to 1, result[0])
}
run {
val word = "capitvate"
val result = tree.fuzzySearch(word, 4)
Assert.assertEquals(4, result.size)
Assert.assertEquals("captivate" to 1, result[0])
Assert.assertEquals("captivity" to 3, result[1])
Assertions.assertEquals(4, result.size)
Assertions.assertEquals("captivate" to 1, result[0])
Assertions.assertEquals("captivity" to 3, result[1])
}
run {
tree.remove("captivate")
val word = "capitvate"
val result = tree.fuzzySearch(word, 4)
Assert.assertEquals(4, result.size)
Assert.assertEquals("captivity" to 3, result[0])
Assertions.assertEquals(4, result.size)
Assertions.assertEquals("captivity" to 3, result[0])
}
}
}