[orx-gradient-descent] convert to MPP

orx-gradient-descent/src/jvmTest/kotlin/TestDot.kt

@@ -0,0 +1,28 @@
+package org.openrndr.extra.gradientdescent
+import org.amshove.kluent.`should be equal to`
+import org.spekframework.spek2.Spek
+import org.spekframework.spek2.style.specification.describe
+
+object TestDot : Spek({
+    describe("some vectors") {
+        val a = doubleArrayOf(10.0)
+        val b = doubleArrayOf(4.0)
+
+        dot(a,b) `should be equal to` 40.0
+
+    }
+    describe("a matrix and a vector") {
+        val a = arrayOf(doubleArrayOf(10.0))
+        val b = doubleArrayOf(1.0)
+        val d = dot(a,b)
+        d[0] `should be equal to` 10.0
+    }
+
+    describe("a matrix and a vector") {
+        val a = arrayOf(doubleArrayOf(1.0))
+        val b = doubleArrayOf(19.99999999995339)
+        val d = dot(a,b)
+        d[0] `should be equal to` 19.99999999995339
+    }
+
+})

orx-gradient-descent/src/jvmTest/kotlin/TestGradient.kt

@@ -0,0 +1,43 @@
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should equal`
+import org.openrndr.extra.gradientdescent.gradient
+import org.spekframework.spek2.Spek
+import org.spekframework.spek2.style.specification.describe
+
+object TestGradient : Spek({
+    describe("a simple 1d function") {
+        fun parabola(x: DoubleArray): Double {
+            return x[0] * x[0]
+        }
+        it("its gradient at x=0 is 0.0") {
+            val g0 = gradient(doubleArrayOf(0.0), ::parabola)
+            g0.size `should equal` 1
+            g0[0] `should be equal to` 0.0
+        }
+        it("its gradient at x=1 is ~2.0") {
+            val g1 = gradient(doubleArrayOf(1.0), ::parabola)
+        }
+        it("its gradient at x=-1 is ~-2.0") {
+            val g1 = gradient(doubleArrayOf(-1.0), ::parabola)
+        }
+    }
+
+    describe("a simple 2d function") {
+        fun parabola(x: DoubleArray): Double {
+            return x[0] * x[0] + x[1] * x[1]
+        }
+
+        it("its gradient at x=0 is 0.0") {
+            val g0 = gradient(doubleArrayOf(0.0, 0.0), ::parabola)
+            g0.size `should equal` 2
+            g0[0] `should be equal to` 0.0
+        }
+
+        it("its gradient at x=1 is ~2.0") {
+            val g1 = gradient(doubleArrayOf(1.0, 1.0), ::parabola)
+        }
+        it("its gradient at x=-1 is ~-2.0") {
+            val g1 = gradient(doubleArrayOf(-1.0, -1.0), ::parabola)
+        }
+    }
+})

orx-gradient-descent/src/jvmTest/kotlin/TestMinimize.kt

@@ -0,0 +1,14 @@
+import org.openrndr.extra.gradientdescent.minimize
+import org.spekframework.spek2.Spek
+import org.spekframework.spek2.style.specification.describe
+
+object TestMinimize : Spek({
+    describe("a simple 1d function") {
+        fun parabola(x: DoubleArray): Double {
+            return (x[0]+1) * (x[0]+1)
+        }
+        it("it can be minimized") {
+            val result = minimize(doubleArrayOf(10.0), f = ::parabola)
+        }
+    }
+})

orx-gradient-descent/src/jvmTest/kotlin/TestMinimizeModel.kt

@@ -0,0 +1,34 @@
+import org.amshove.kluent.shouldBeNear
+import org.openrndr.extra.gradientdescent.minimizeModel
+import org.openrndr.math.Vector2
+import org.spekframework.spek2.Spek
+import org.spekframework.spek2.style.specification.describe
+
+object TestMinimizeModel : Spek({
+    describe("a model") {
+        val m = object {
+            var x = 0.0
+            var y = 0.0
+        }
+        it("can be minimized") {
+            minimizeModel(m) { m->
+                (m.x - 4.0) * (m.x - 4.0) + (m.y - 3.0) * (m.y - 3.0)
+            }
+            m.x.shouldBeNear(4.0, 0.01)
+            m.y.shouldBeNear(3.0, 0.01)
+        }
+    }
+
+    describe("a model with a Vector2 property") {
+        val m = object {
+            var position = Vector2.ZERO
+        }
+        it("can be minimized") {
+            minimizeModel(m) { m->
+                (m.position.x - 4.0) * (m.position.x - 4.0) + (m.position.y - 3.0) * (m.position.y - 3.0)
+            }
+            m.position.x.shouldBeNear(4.0, 0.01)
+            m.position.y.shouldBeNear(3.0, 0.01)
+        }
+    }
+})