Made a nice clean implementation of the Polynomial thing

.idea/gradle.xml

@@ -1,8 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
+        <option name="delegatedBuild" value="true" />
+        <option name="testRunner" value="GRADLE" />
         <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
         <option name="gradleHome" value="C:/Gradle/gradle-4.0.1" />

build.gradle.kts

@@ -16,10 +16,16 @@ dependencies {
     implementation(kotlin("stdlib-jdk8"))
 }
 
-application {
-    mainClassName = "com.anthonycicchetti.cs5004.assignment4.Main"
-}
-
 tasks.withType<KotlinCompile> {
     kotlinOptions.jvmTarget = "1.8"
+}
+
+tasks.register<JavaExec>("Assignment4") {
+    classpath = sourceSets.main.get().runtimeClasspath
+    main = "com.anthonycicchetti.cs5004.assignment4.Main"
+}
+
+tasks.register<JavaExec>("Assignment3") {
+    classpath = sourceSets.main.get().runtimeClasspath
+    main = "com.anthonycicchetti.cs5004.assignment3.Main"
 }

src/main/kotlin/com/anthonycicchetti/cs5004/assignment4/CleanRoom.kt

@@ -0,0 +1,84 @@
+package com.anthonycicchetti.cs5004.assignment4
+
+import kotlin.math.pow
+import kotlin.text.StringBuilder
+
+class CleanRoom {
+    data class Coefficient(val value: Int) {
+        infix operator fun plus(other: Coefficient): Coefficient {
+            return Coefficient(this.value + other.value)
+        }
+
+        override fun toString(): String {
+            return "$value"
+        }
+    }
+
+    data class Exponent(val value: Int) {
+        override fun toString(): String {
+            return "$value"
+        }
+    }
+
+
+    class Polynomial() {
+        constructor(inputString: String) : this() {
+            inputString.split(" ").forEach {
+                this.addTerm(it.substringBefore("x^").toInt(), it.substringAfter("x^").toInt())
+            }
+        }
+
+        private val backingStore: MutableMap<Exponent, Coefficient> = mutableMapOf()
+
+        fun addTerm(coefficient: Int, power: Int): Unit {
+            backingStore[Exponent(power)] =
+                backingStore.getOrDefault(
+                    Exponent(power),
+                    Coefficient(0)
+                ) + Coefficient(coefficient)
+        }
+
+        fun removeTerm(power: Int) {
+            if (backingStore.containsKey(Exponent(power))) {
+                backingStore.remove(Exponent(power))
+            }
+        }
+
+        fun getDegree(): Int {
+            return backingStore.maxBy { it.key.value }?.key?.value ?: 0
+        }
+
+        fun getCoefficient(power: Int): Int {
+            return backingStore.getOrDefault(
+                Exponent(power),
+                Coefficient(0)
+            ).value
+        }
+
+        fun evaluate(xEquals: Double): Double {
+            var sum = 0.0
+            backingStore.forEach {
+                sum += it.value.value * xEquals.pow(it.key.value)
+            }
+            return sum
+        }
+
+        override fun toString(): String {
+            val sb = StringBuilder()
+
+            backingStore.toSortedMap(Comparator { o1, o2 -> o2.value - o1.value })
+                .forEach {
+                    sb.append(it.toUsefulString())
+                }
+
+            return sb.toString()
+        }
+    }
+}
+
+fun Map.Entry<CleanRoom.Exponent, CleanRoom.Coefficient>.toUsefulString(): String {
+    if (key.value == 0) {
+        return " + ${value.value}"
+    }
+    return " ${(if (value.value > 0) "+" else "") + value.value}x^${key.value}"
+}

src/main/kotlin/com/anthonycicchetti/cs5004/assignment4/Main.kt

@@ -3,7 +3,24 @@ package com.anthonycicchetti.cs5004.assignment4
 object Main {
     @JvmStatic
     fun main(args: Array<String>) {
-        println("test")
+        with(CleanRoom.Polynomial()) {
+            println(this)
+            this.addTerm(-5, 1)
+            println(this)
+            this.addTerm(4, 2)
+            println(this)
+            this.addTerm(2, 0)
+            println(this)
+            this.removeTerm(0)
+            println(this)
+
+            println("Degree = ${this.getDegree()}")
+            println("Coefficient of 2 = ${this.getCoefficient(2)}")
+            println("Coefficient of 3 = ${this.getCoefficient(3)}")
+            println("Value when x = 1 == ${this.evaluate(1.0)}")
+            println("Value when x = 1.5 == ${this.evaluate(1.5)}")
+        }
+
         return
     }
 }

src/main/kotlin/com/anthonycicchetti/cs5004/assignment4/PolynomialImpl.kt

@@ -1,14 +1,8 @@
 package com.anthonycicchetti.cs5004.assignment4
 
-import com.anthonycicchetti.cs5004.assignment4.util.EmptyNode
 import com.anthonycicchetti.cs5004.assignment4.util.LinkedList
 
-class PolynomialImpl() : Polynomial {
+class PolynomialImpl() : Polynomial, LinkedList<Polynomial>() {
-    private var list : LinkedList<Polynomial>
-    init {
-        list = EmptyNode()
-    }
-
     constructor(poly: String) : this() {
         val polySplit = poly.split(" ")
         for (i in polySplit) {
@@ -22,11 +16,15 @@ class PolynomialImpl() : Polynomial {
      * It should throw an IllegalArgumentException if a negative power is passed to it.
      */
     override fun addTerm(coefficient: Int, power: Int) {
-        if (list.containsPower(power)) {
+        if (this.containsPower(power)) {
 
         }
     }
 
+    private fun containsPower(power: Int): Boolean {
+        TODO()
+    }
+
     override fun removeTerm(power: Int) {
         TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
     }

src/main/kotlin/com/anthonycicchetti/cs5004/assignment4/util/LinkedList.kt

@@ -1,33 +1,104 @@
 package com.anthonycicchetti.cs5004.assignment4.util
 
-import com.anthonycicchetti.cs5004.assignment4.Polynomial
+import java.lang.IllegalArgumentException
-import java.lang.ref.Reference
-import kotlin.math.max
 
-interface LinkedList<T: Polynomial> {
+interface ILinkedList<T> {
-    fun degree(): Int
+    fun addFront(entry: T): Unit
-    fun containsPower(power: Int): Boolean
+    fun addBack(entry: T): Unit
-
+    fun addAtIndex(entry: T, index: Int): Unit
-    fun rest(): LinkedList<T>?
+    fun getSize(): Int
+    fun remove(entry: T): T
+    fun getAtIndex(index: Int): T
 }
 
-class EmptyNode<T: Polynomial> : LinkedList<T> {
+open class LinkedList<T>(): ILinkedList<T> {
-    override fun degree() = 0
+    private interface ILinkedListNode<T> {
-    override fun containsPower(power: Int) = false
+        fun count(): Int
-
+        fun addFront(entry: T): ILinkedListNode<T>
-    override fun rest() = null
+        fun addBack(entry: T): ILinkedListNode<T>
-}
+        fun addAtIndex(entry: T, index: Int): ILinkedListNode<T>
-
+        fun remove(entry: T): ILinkedListNode<T>
-class ActualNode<T: Polynomial>(var coefficient: Int, var degree: Int, val rest: LinkedList<T>) : LinkedList<T> {
+        fun getAtIndex(index: Int): T
-    override fun degree() = max(this.degree, rest().degree())
+    }
-    override fun containsPower(power: Int): Boolean {
+
-        if (power == degree) {
+    private class EmptyLinkedListNode<T>(): ILinkedListNode<T> {
-            return true
+        override fun count(): Int = 0
-        } else if (rest.containsPower(power)) {
+
-            return true
+        override fun addFront(entry: T): ILinkedListNode<T> = LinkedListNode(entry, this)
-        }
+
-        return false
+        override fun addBack(entry: T): ILinkedListNode<T> = addFront(entry)
+
+        override fun addAtIndex(entry: T, index: Int): ILinkedListNode<T> = if (index == 0) addFront(entry) else throw IllegalArgumentException("Index must be 0")
+
+        override fun remove(entry: T): ILinkedListNode<T> = this
+
+        override fun getAtIndex(index: Int): T = throw IllegalArgumentException("Wrong index")
+
+    }
+    
+    private class LinkedListNode<T>(val data: T, var rest: ILinkedListNode<T>): ILinkedListNode<T> {
+        override fun count(): Int = 1 + rest.count()
+
+        override fun addFront(entry: T) = LinkedListNode(entry, this)
+
+        override fun addBack(entry: T): ILinkedListNode<T> {
+            this.rest = this.rest.addBack(entry)
+            return this
+        }
+
+        override fun addAtIndex(entry: T, index: Int): ILinkedListNode<T> {
+            return if (index == 0) {
+                addFront(entry)
+            } else {
+                this.rest = this.rest.addAtIndex(entry, index - 1)
+                this
+            }
+        }
+
+        override fun remove(entry: T): ILinkedListNode<T> {
+            return if (this.data == entry) {
+                this.rest
+            } else {
+                this.rest = this.rest.remove(entry)
+                this
+            }
+        }
+
+        override fun getAtIndex(index: Int): T {
+            return if (index == 0) {
+                this.data
+            } else {
+                this.rest.getAtIndex(index - 1)
+            }
+        }
+    }
+    private var head: ILinkedListNode<T> = EmptyLinkedListNode<T>()
+
+    override fun addFront(entry: T) {
+        head = head.addFront(entry)
+    }
+
+    override fun addBack(entry: T) {
+        head = head.addBack(entry)
+    }
+
+    override fun addAtIndex(entry: T, index: Int) {
+        head = head.addAtIndex(entry, index)
+    }
+
+    override fun getSize(): Int {
+        return head.count()
+    }
+
+    override fun remove(entry: T): T {
+        head = head.remove(entry)
+        return entry
+    }
+
+    override fun getAtIndex(index: Int): T {
+        if ((index >= 0) && (index < this.getSize())) {
+            return head.getAtIndex(index)
+        } else throw IllegalArgumentException("Invalid Index")
     }
 
-    override fun rest(): LinkedList<T> = rest
 }