Initial commit

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,10 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="WeakerAccess" enabled="false" level="WARNING" enabled_by_default="false">
+      <option name="SUGGEST_PACKAGE_LOCAL_FOR_MEMBERS" value="true" />
+      <option name="SUGGEST_PACKAGE_LOCAL_FOR_TOP_CLASSES" value="true" />
+      <option name="SUGGEST_PRIVATE_FOR_INNERS" value="false" />
+    </inspection_tool>
+  </profile>
+</component>

.idea/kotlinc.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Kotlin2JvmCompilerArguments">
+    <option name="jvmTarget" value="1.8" />
+  </component>
+  <component name="KotlinCommonCompilerArguments">
+    <option name="apiVersion" value="1.2" />
+    <option name="languageVersion" value="1.2" />
+  </component>
+</project>

.idea/libraries/KotlinJavaRuntime.xml

@@ -0,0 +1,15 @@
+<component name="libraryTable">
+  <library name="KotlinJavaRuntime">
+    <CLASSES>
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-reflect.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-test.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES>
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-stdlib-sources.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-reflect-sources.jar!/" />
+      <root url="jar://$KOTLIN_BUNDLED$/lib/kotlin-test-sources.jar!/" />
+    </SOURCES>
+  </library>
+</component>

.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="11" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/NFA2DFA.iml" filepath="$PROJECT_DIR$/NFA2DFA.iml" />
+    </modules>
+  </component>
+</project>

NFA2DFA.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
+  </component>
+</module>

src/FiniteAutomata.kt

@@ -0,0 +1,24 @@
+import dev.w1zzrd.automata.*
+
+fun main(args: Array<String>){
+    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)
+}

src/dev/w1zzrd/automata/Automaton.kt

@@ -0,0 +1,166 @@
+package dev.w1zzrd.automata
+
+class Automaton<T>(val language: Language<T>, val deterministic: Boolean){
+    private val states = ArrayList<State<T>>()
+    private val factory = StateFactory(language, deterministic)
+    var entryPoint: State<T>? = null
+
+    fun addStates(vararg states: State<T>){
+        states.forEach { state ->
+            if(addState(state))
+                language.elements.forEach { verb ->
+                    addStates(*state.getConnective(verb).toTypedArray())
+                }
+        }
+    }
+
+    fun addState(state: State<T>): 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<T> {
+        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<T> {
+        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<MutableList<State<T>>, HashMap<T, MutableList<State<T>>>>()
+
+        // Check if a table entry is completely populated
+        fun HashMap<T, MutableList<State<T>>>.getUnpopulatedMapping() = language.elements.firstOrNull { !keys.contains(it) }
+        fun HashMap<MutableList<State<T>>, HashMap<T, MutableList<State<T>>>>.findUnpopulatedMapping(): Pair<MutableList<State<T>>, 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<State<T>>.toReadableString(): String {
+            val builder = StringBuilder("{")
+            val stringComparator = Comparator.naturalOrder<String>()
+            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<MutableList<State<T>>, 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<MutableList<State<T>>, State<T>>()
+
+        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 <V> Collection<V>.contentsEquals(other: Collection<V>) =
+            size == other.size &&
+            firstOrNull { other.firstOrNull { check -> check == it } == null } == null
+
+    private fun MutableList<State<T>>.isAcceptState() = firstOrNull { it.acceptState } != null
+
+    private inner class StateTraverser(entryPoint: State<T>) {
+        var currentState: MutableList<State<T>> = 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<State<T>>()
+
+            for(state in currentState)
+                for(traverseState in state.getConnective(verb))
+                    nextState.traverseEpsilon(traverseState)
+
+            currentState = nextState
+        }
+
+        private fun MutableList<State<T>>.traverseEpsilon(state: State<T>){
+            if(!contains(state)) add(state)
+            for(epsilonState in state.getEpsilon())
+                if(!contains(epsilonState))
+                    traverseEpsilon(epsilonState)
+        }
+    }
+}

src/dev/w1zzrd/automata/Language.kt

@@ -0,0 +1,25 @@
+package dev.w1zzrd.automata
+
+import kotlin.collections.ArrayList
+
+class Language<T> private constructor(private val language: List<T>) {
+
+    val elements: List<T>
+        get() = ArrayList(language)
+
+    infix fun hasVerb(verb: T) = language.contains(verb)
+    infix fun hasVerbs(string: Iterable<T>) = string.firstOrNull { !(this hasVerb it) } == null
+    infix fun hasVerbs(string: Array<out T>) = string.firstOrNull { !(this hasVerb it) } == null
+
+    companion object {
+        fun <T> makeLanguage(vararg language: T): Language<T> {
+            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())
+        }
+    }
+}

src/dev/w1zzrd/automata/State.kt

@@ -0,0 +1,51 @@
+package dev.w1zzrd.automata
+
+class State<T>(
+        val name: String,
+        val language: Language<T>,
+        val isDeterministic: Boolean,
+        val acceptState: Boolean
+){
+    /**
+     * A transition table for a given set of elements from the language
+     */
+    private val connective = HashMap<T, MutableList<State<T>>>()
+
+    /**
+     * Direct epsilon-transitions possible from this state
+     */
+    private val epsilon = ArrayList<State<T>>()
+
+    fun addConnective(verbs: Array<T>, vararg state: State<T>) = verbs.forEach { addConnective(it, *state) }
+    fun addConnective(verb: T, vararg state: State<T>){
+        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<T>){
+        if(isDeterministic)
+            throw IllegalStateException("Epsilon-transitions are not possible in DFA models!")
+
+        epsilon.addAll(state)
+    }
+
+    fun getConnective(verb: T) =
+            ArrayList(connective[verb] ?: listOf<State<T>>())
+
+    fun getEpsilon() = ArrayList(epsilon)
+
+    override fun equals(other: Any?) = other is State<*> && other.name == name
+    override fun hashCode(): Int {
+        return name.hashCode()
+    }
+}
+
+class StateFactory<T>(val language: Language<T>, val deterministic: Boolean){
+    fun make(name: String, acceptState: Boolean) = State(name, language, deterministic, acceptState)
+}