From 382d2e9501f1a44682e8624ae6450439543a82ef Mon Sep 17 00:00:00 2001 From: Gabriel Tofvesson Date: Wed, 27 Mar 2019 21:05:03 +0100 Subject: [PATCH] Initial commit --- .idea/inspectionProfiles/Project_Default.xml | 10 ++ .idea/kotlinc.xml | 10 ++ .idea/libraries/KotlinJavaRuntime.xml | 15 ++ .idea/misc.xml | 6 + .idea/modules.xml | 8 + NFA2DFA.iml | 12 ++ src/FiniteAutomata.kt | 24 +++ src/dev/w1zzrd/automata/Automaton.kt | 166 +++++++++++++++++++ src/dev/w1zzrd/automata/Language.kt | 25 +++ src/dev/w1zzrd/automata/State.kt | 51 ++++++ 10 files changed, 327 insertions(+) create mode 100644 .idea/inspectionProfiles/Project_Default.xml create mode 100644 .idea/kotlinc.xml create mode 100644 .idea/libraries/KotlinJavaRuntime.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/modules.xml create mode 100644 NFA2DFA.iml create mode 100644 src/FiniteAutomata.kt create mode 100644 src/dev/w1zzrd/automata/Automaton.kt create mode 100644 src/dev/w1zzrd/automata/Language.kt create mode 100644 src/dev/w1zzrd/automata/State.kt diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..b08e5aa --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml new file mode 100644 index 0000000..3c50bd3 --- /dev/null +++ b/.idea/kotlinc.xml @@ -0,0 +1,10 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/libraries/KotlinJavaRuntime.xml b/.idea/libraries/KotlinJavaRuntime.xml new file mode 100644 index 0000000..9fbfb0d --- /dev/null +++ b/.idea/libraries/KotlinJavaRuntime.xml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..0319d5d --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..b4db3e9 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/NFA2DFA.iml b/NFA2DFA.iml new file mode 100644 index 0000000..245d342 --- /dev/null +++ b/NFA2DFA.iml @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/src/FiniteAutomata.kt b/src/FiniteAutomata.kt new file mode 100644 index 0000000..88ac673 --- /dev/null +++ b/src/FiniteAutomata.kt @@ -0,0 +1,24 @@ +import dev.w1zzrd.automata.* + +fun main(args: Array){ + val language = Language.makeLanguage(0, 1, 2) + val automaton = Automaton(language, false) + + val stateA = automaton.makeState("a") + val stateB = automaton.makeState("b") + val stateC = automaton.makeState("c") + val stateD = automaton.makeState("d", true) + + stateA.addConnective(arrayOf(0, 1), stateB) + stateA.addConnective(arrayOf(1, 2), stateC) + + stateB.addConnective(arrayOf(0, 2), stateD) + + stateC.addConnective(arrayOf(0, 1), stateD) + + stateD.addConnective(0, stateA) + + automaton.entryPoint = stateA + + val dfa = automaton.toDeterministicAutomaton(true) +} \ No newline at end of file diff --git a/src/dev/w1zzrd/automata/Automaton.kt b/src/dev/w1zzrd/automata/Automaton.kt new file mode 100644 index 0000000..9e9696d --- /dev/null +++ b/src/dev/w1zzrd/automata/Automaton.kt @@ -0,0 +1,166 @@ +package dev.w1zzrd.automata + +class Automaton(val language: Language, val deterministic: Boolean){ + private val states = ArrayList>() + private val factory = StateFactory(language, deterministic) + var entryPoint: State? = null + + fun addStates(vararg states: State){ + states.forEach { state -> + if(addState(state)) + language.elements.forEach { verb -> + addStates(*state.getConnective(verb).toTypedArray()) + } + } + } + + fun addState(state: State): Boolean{ + if(deterministic && !state.isDeterministic) + throw IllegalArgumentException("Deterministic automaton can only contain deterministic states!") + + if(!states.contains(state)){ + states.add(state) + return true + } + return false + } + + fun makeState(name: String, acceptState: Boolean = false): State { + val state = factory.make(name, acceptState) + if(!addState(state)) + throw IllegalArgumentException("Duplicate state detected!") + return state + } + + fun accepts(vararg string: T): Boolean { + if(!(language hasVerbs string)) + throw IllegalArgumentException("All verbs in string must be part of the language!") + + if(entryPoint == null) return false + + val traverser = StateTraverser(entryPoint!!) + traverser.traverse(*string) + + return traverser.accepted + } + + fun toDeterministicAutomaton(printTable: Boolean = false): Automaton { + if(deterministic) return this + if(entryPoint == null) + throw IllegalStateException("Entry point state must be defined!") + + // Maps a state-collection to the results of applying all values in the language to it (individually) + val tableEntries = HashMap>, HashMap>>>() + + // Check if a table entry is completely populated + fun HashMap>>.getUnpopulatedMapping() = language.elements.firstOrNull { !keys.contains(it) } + fun HashMap>, HashMap>>>.findUnpopulatedMapping(): Pair>, T>? { + var find: T? = null + val result = keys.firstOrNull { + find = this[it]!!.getUnpopulatedMapping() + find != null + } + return if(result == null) null else result to find!! + } + fun Iterable>.toReadableString(): String { + val builder = StringBuilder("{") + val stringComparator = Comparator.naturalOrder() + val sorted = sortedWith(Comparator{ state1, state2 -> stringComparator.compare(state1.name, state2.name) }) + if(sorted.isEmpty()) return "∅" + for(state in sorted) + builder.append(state.name).append(',') + if(sorted.isNotEmpty()) builder.setCharAt(builder.length - 1, '}') + else builder.append('}') + return builder.toString() + } + + val traverser = StateTraverser(entryPoint!!) + val startingState = traverser.currentState + + // Initialize table + tableEntries[startingState] = HashMap() + + var currentMapping: Pair>, T>? = null + while(tableEntries.run { + currentMapping = findUnpopulatedMapping() + currentMapping != null + }){ + traverser.currentState = currentMapping!!.first + traverser.traverse(currentMapping!!.second) + + if(tableEntries[currentMapping!!.first] == null) + tableEntries[currentMapping!!.first] = HashMap() + + tableEntries[currentMapping!!.first]!![currentMapping!!.second] = traverser.currentState + if(tableEntries.keys.firstOrNull { traverser.currentState.contentsEquals(it) } == null) + tableEntries[traverser.currentState] = HashMap() + } + + if(printTable) + for(key in tableEntries.keys){ + print( + (if(key.contentsEquals(startingState)) "→ " else " ") + + (if(key.isAcceptState()) "F" else " ") + + " " + + key.toReadableString() + + " : " + ) + for (verb in language.elements) + print(verb.toString() + "(" + tableEntries[key]!![verb]!!.toReadableString() + ") ") + println() + } + + val oldToNew = HashMap>, State>() + + val dfa = Automaton(language, true) + for(tableState in tableEntries.keys) + oldToNew[tableState] = dfa.makeState(tableState.toReadableString(), tableState.contentsEquals(startingState)) + + for(oldState in oldToNew.keys) + for(mapping in tableEntries[oldState]!!) + oldToNew[oldState]!!.addConnective(mapping.key, oldToNew[mapping.value]!!) + + dfa.entryPoint = oldToNew[startingState] + + return dfa + } + + private infix fun Collection.contentsEquals(other: Collection) = + size == other.size && + firstOrNull { other.firstOrNull { check -> check == it } == null } == null + + private fun MutableList>.isAcceptState() = firstOrNull { it.acceptState } != null + + private inner class StateTraverser(entryPoint: State) { + var currentState: MutableList> = ArrayList() + + val accepted: Boolean + get() = currentState.isAcceptState() + + init { + currentState.traverseEpsilon(entryPoint) + } + + fun traverse(vararg verbs: T){ + for(verb in verbs) + transformState(verb) + } + + private fun transformState(verb: T){ + val nextState = ArrayList>() + + for(state in currentState) + for(traverseState in state.getConnective(verb)) + nextState.traverseEpsilon(traverseState) + + currentState = nextState + } + + private fun MutableList>.traverseEpsilon(state: State){ + if(!contains(state)) add(state) + for(epsilonState in state.getEpsilon()) + if(!contains(epsilonState)) + traverseEpsilon(epsilonState) + } + } +} \ No newline at end of file diff --git a/src/dev/w1zzrd/automata/Language.kt b/src/dev/w1zzrd/automata/Language.kt new file mode 100644 index 0000000..5d57c31 --- /dev/null +++ b/src/dev/w1zzrd/automata/Language.kt @@ -0,0 +1,25 @@ +package dev.w1zzrd.automata + +import kotlin.collections.ArrayList + +class Language private constructor(private val language: List) { + + val elements: List + get() = ArrayList(language) + + infix fun hasVerb(verb: T) = language.contains(verb) + infix fun hasVerbs(string: Iterable) = string.firstOrNull { !(this hasVerb it) } == null + infix fun hasVerbs(string: Array) = string.firstOrNull { !(this hasVerb it) } == null + + companion object { + fun makeLanguage(vararg language: T): Language { + language.forEachIndexed { outerIndex, outerValue -> + language.forEachIndexed { innerIndex, innerValue -> + if(outerIndex != innerIndex && (outerValue?.equals(innerValue) == true || outerValue == innerValue)) + throw IllegalArgumentException("Elements in language must be unique!") + } + } + return Language(language.toList()) + } + } +} \ No newline at end of file diff --git a/src/dev/w1zzrd/automata/State.kt b/src/dev/w1zzrd/automata/State.kt new file mode 100644 index 0000000..1db85fe --- /dev/null +++ b/src/dev/w1zzrd/automata/State.kt @@ -0,0 +1,51 @@ +package dev.w1zzrd.automata + +class State( + val name: String, + val language: Language, + val isDeterministic: Boolean, + val acceptState: Boolean +){ + /** + * A transition table for a given set of elements from the language + */ + private val connective = HashMap>>() + + /** + * Direct epsilon-transitions possible from this state + */ + private val epsilon = ArrayList>() + + fun addConnective(verbs: Array, vararg state: State) = verbs.forEach { addConnective(it, *state) } + fun addConnective(verb: T, vararg state: State){ + if(isDeterministic && (state.size > 1 || connective[verb]?.contains(state[0]) == false)) + throw IllegalArgumentException("Deterministic states can only contain one-to-one connectives!") + + if(language hasVerb verb){ + if(connective[verb] == null) connective[verb] = mutableListOf(*state) + else connective[verb]!!.addAll(state) + } + else throw IllegalArgumentException("Verb must be in language!") + } + + fun addEpsilon(vararg state: State){ + if(isDeterministic) + throw IllegalStateException("Epsilon-transitions are not possible in DFA models!") + + epsilon.addAll(state) + } + + fun getConnective(verb: T) = + ArrayList(connective[verb] ?: listOf>()) + + fun getEpsilon() = ArrayList(epsilon) + + override fun equals(other: Any?) = other is State<*> && other.name == name + override fun hashCode(): Int { + return name.hashCode() + } +} + +class StateFactory(val language: Language, val deterministic: Boolean){ + fun make(name: String, acceptState: Boolean) = State(name, language, deterministic, acceptState) +} \ No newline at end of file