graphs more cleanup

Author: jafu888

desktop/interpolationEngines/src/main/kotlin/curves/MonoSpline.kt

@@ -15,25 +15,19 @@
  */
 package curves
 
+import kotlin.math.hypot
+
 /**
  * This performs a spline interpolation in multiple dimensions
  *
  */
 class MonoSpline(time: FloatArray, y: List<FloatArray>) {
     private val timePoints: FloatArray
-    var mY: ArrayList<FloatArray>
+    private var mY: ArrayList<FloatArray>
     private var mTangent: ArrayList<FloatArray>
     private val mExtrapolate = true
     private var mSlopeTemp: FloatArray
 
-    fun makeFloatArray(a: Int, b: Int): ArrayList<FloatArray> {
-        val ret = ArrayList<FloatArray>() //new Float[a][b];
-        for (i in 0 until a) {
-            ret.add(FloatArray(b))
-        }
-        return ret
-    }
-
     init {
         val n = time.size
         val dim = y[0].size
@@ -60,7 +54,7 @@ class MonoSpline(time: FloatArray, y: List<FloatArray>) {
                 } else {
                     val a = tangent[i][j] / slope[i][j]
                     val b = tangent[i + 1][j] / slope[i][j]
-                    val h = Math.hypot(a.toDouble(), b.toDouble()).toFloat()
+                    val h = hypot(a , b)
                     if (h > 9.0) {
                         val t = 3.0f / h
                         tangent[i][j] = t * a * slope[i][j]
@@ -74,6 +68,14 @@ class MonoSpline(time: FloatArray, y: List<FloatArray>) {
         mTangent = tangent
     }
 
+    private fun makeFloatArray(a: Int, b: Int): ArrayList<FloatArray> {
+        val ret = ArrayList<FloatArray>() //new Float[a][b];
+        for (i in 0 until a) {
+            ret.add(FloatArray(b))
+        }
+        return ret
+    }
+
     private fun copyData(y: List<FloatArray>): ArrayList<FloatArray> {
         val ret = ArrayList<FloatArray>()
         for (array in y) {

desktop/interpolationEngines/src/main/kotlin/curves/Spline.kt

@@ -15,9 +15,11 @@
  */
 package curves
 
+import kotlin.math.sqrt
+
 /**
  * Provides spline interpolation code.
- * Currently not used but it is anticipated that we will be using it in the
+ * Currently not used, but it is anticipated that we will be using it in the
  * KeyMotion
  *
  *
@@ -27,134 +29,124 @@ class Spline
  * Spline in N dimensions
  *
  * @param points [mPoints][dimensionality]
- */(points: List<DoubleArray>) {
-    var mPoints = 0
-    var mCurve: ArrayList<Array<Cubic?>>? = null
-    var mDimensionality = 0
-    lateinit var mCurveLength: DoubleArray
-    var mTotalLength = 0.0
-    var mCtl: ArrayList<DoubleArray>? = null
+ */(points: List<FloatArray>) {
+    private var mPoints = 0
+    private lateinit var mCurve: ArrayList<Array<Cubic>>
+    private var mDimensionality = 0
+    private lateinit var mCurveLength: FloatArray
+    private var mTotalLength = 0.0f
+    private lateinit var mCtl: ArrayList<FloatArray>
 
     init {
         setup(points)
     }
 
-    // @TODO: add description
-    fun setup(points: List<DoubleArray>) {
+
+    private fun setup(points: List<FloatArray>) {
         mDimensionality = points[0].size
         mPoints = points.size
         mCtl = ArrayList()
         mCurve = ArrayList()
         for (d in 0 until mDimensionality) {
-            val tmp = DoubleArray(mPoints)
-            mCtl!!.add(tmp)
+            val tmp = FloatArray(mPoints)
+            mCtl.add(tmp)
             for (p in 0 until mPoints) {
                 tmp[p] = points[p][d]
             }
         }
         for (d in 0 until mDimensionality) {
-            mCurve!!.add(calcNaturalCubic(mCtl!![d].size, mCtl!![d]))
+            mCurve.add(calcNaturalCubic(mCtl!![d].size, mCtl[d]))
         }
-        mCurveLength = DoubleArray(mPoints - 1)
-        mTotalLength = 0.0
+        mCurveLength = FloatArray(mPoints - 1)
+        mTotalLength = 0.0f
         val temp = arrayOfNulls<Cubic>(mDimensionality)
         for (p in mCurveLength.indices) {
             for (d in 0 until mDimensionality) {
-                temp[d] = mCurve!![d][p]
+                temp[d] = mCurve[d][p]
             }
             mCurveLength[p] = approxLength(temp)
             mTotalLength += mCurveLength[p]
         }
     }
 
-    // @TODO: add description
-    fun getVelocity(p: Double, v: DoubleArray) {
+    /**
+     * get the velocity
+     */
+    fun getVelocity(p: Float, v: FloatArray) {
         var pos = p * mTotalLength
         var k = 0
         while (k < mCurveLength.size - 1 && mCurveLength[k] < pos) {
             pos -= mCurveLength[k]
             k++
         }
         for (i in v.indices) {
-            v[i] = mCurve!![i][k]!!.vel(pos / mCurveLength[k])
+            v[i] = mCurve[i][k]!!.vel(pos / mCurveLength[k])
         }
     }
 
-    // @TODO: add description
-    fun getPos(p: Double, x: DoubleArray) {
-        var pos = p * mTotalLength
-        var k = 0
-        while (k < mCurveLength.size - 1 && mCurveLength[k] < pos) {
-            pos -= mCurveLength[k]
-            k++
-        }
-        for (i in x.indices) {
-            x[i] = mCurve!![i][k]!!.eval(pos / mCurveLength[k])
-        }
-    }
 
     // @TODO: add description
-    fun getPos(p: Double, x: FloatArray) {
+    fun getPos(p: Float, x: FloatArray) {
         var pos = p * mTotalLength
         var k = 0
         while (k < mCurveLength.size - 1 && mCurveLength[k] < pos) {
             pos -= mCurveLength[k]
             k++
         }
         for (i in x.indices) {
-            x[i] = mCurve!![i][k]!!.eval(pos / mCurveLength[k]).toFloat()
+            x[i] = mCurve[i][k]!!.eval(pos / mCurveLength[k])
         }
     }
 
     // @TODO: add description
-    fun getPos(p: Double, splineNumber: Int): Double {
+    fun getPos(p: Float, splineNumber: Int): Float {
         var pos = p * mTotalLength
         var k = 0
         while (k < mCurveLength.size - 1 && mCurveLength[k] < pos) {
             pos -= mCurveLength[k]
             k++
         }
-        return mCurve!![splineNumber][k]!!.eval(pos / mCurveLength[k])
+        return mCurve[splineNumber][k]!!.eval(pos / mCurveLength[k])
     }
 
     // @TODO: add description
-    fun approxLength(curve: Array<Cubic?>): Double {
-        var sum = 0.0
+    fun approxLength(curve: Array<Cubic?>): Float {
+        var sum = 0.0f
         val n = curve.size
-        val old = DoubleArray(n)
-        var i = 0.0
+        val old = FloatArray(n)
+        var i = 0.0f
         while (i < 1) {
-            var s = 0.0
+            var s = 0.0f
             for (j in 0 until n) {
                 var tmp = old[j]
                 old[j] = curve[j]!!.eval(i)
                 tmp -= old[j]
                 s += tmp * tmp
             }
             if (i > 0) {
-                sum += Math.sqrt(s)
+                sum += sqrt(s)
             }
-            i += .1
+            i += .1f
         }
-        var s = 0.0
+        var s = 0.0f
         for (j in 0 until n) {
             var tmp = old[j]
-            old[j] = curve[j]!!.eval(1.0)
+            old[j] = curve[j]!!.eval(1.0f)
             tmp -= old[j]
             s += tmp * tmp
         }
-        sum += Math.sqrt(s)
+        sum += sqrt(s)
         return sum
     }
 
-    class Cubic(var mA: Double, var mB: Double, var mC: Double, var mD: Double) {
+    class Cubic(var mA: Float, var mB: Float, var mC: Float, var mD: Float) {
         // @TODO: add description
-        fun eval(u: Double): Double {
+        fun eval(u: Float): Float {
             return ((mD * u + mC) * u + mB) * u + mA
         }
 
         // @TODO: add description
-        fun vel(v: Double): Double {
+        fun vel(v: Float): Float {
             //  (((mD * u) + mC) * u + mB) * u + mA
             //  =  "mA + u*mB + u*u*mC+u*u*u*mD" a cubic expression
             // diff with respect to u = mB + u*mC/2+ u*u*mD/3
@@ -163,35 +155,32 @@ class Spline
         }
     }
 
-    companion object {
-        fun calcNaturalCubic(n: Int, x: DoubleArray): Array<Cubic?> {
-            var n = n
-            val gamma = DoubleArray(n)
-            val delta = DoubleArray(n)
-            val d = DoubleArray(n)
-            n -= 1
-            gamma[0] = (1.0f / 2.0f).toDouble()
-            for (i in 1 until n) {
-                gamma[i] = 1 / (4 - gamma[i - 1])
-            }
-            gamma[n] = 1 / (2 - gamma[n - 1])
-            delta[0] = 3 * (x[1] - x[0]) * gamma[0]
-            for (i in 1 until n) {
-                delta[i] = (3 * (x[i + 1] - x[i - 1]) - delta[i - 1]) * gamma[i]
-            }
-            delta[n] = (3 * (x[n] - x[n - 1]) - delta[n - 1]) * gamma[n]
-            d[n] = delta[n]
-            for (i in n - 1 downTo 0) {
-                d[i] = delta[i] - gamma[i] * d[i + 1]
-            }
-            val c = arrayOfNulls<Cubic>(n)
-            for (i in 0 until n) {
-                c[i] = Cubic(
-                    x[i].toFloat().toDouble(), d[i], 3 * (x[i + 1] - x[i]) - (2
-                            * d[i]) - d[i + 1], 2 * (x[i] - x[i + 1]) + d[i] + d[i + 1]
-                )
-            }
-            return c
+
+    private fun calcNaturalCubic(cubic: Int, x: FloatArray): Array<Cubic> {
+        var n = cubic
+        val gamma = FloatArray(n)
+        val delta = FloatArray(n)
+        val d = FloatArray(n)
+        n -= 1
+        gamma[0] = (1.0f / 2.0f)
+        for (i in 1 until n) {
+            gamma[i] = 1 / (4 - gamma[i - 1])
+        }
+        gamma[n] = 1 / (2 - gamma[n - 1])
+        delta[0] = 3 * (x[1] - x[0]) * gamma[0]
+        for (i in 1 until n) {
+            delta[i] = (3 * (x[i + 1] - x[i - 1]) - delta[i - 1]) * gamma[i]
+        }
+        delta[n] = (3 * (x[n] - x[n - 1]) - delta[n - 1]) * gamma[n]
+        d[n] = delta[n]
+        for (i in n - 1 downTo 0) {
+            d[i] = delta[i] - gamma[i] * d[i + 1]
+        }
+        return Array(n) {i->
+             Cubic(
+                x[i], d[i], 3 * (x[i + 1] - x[i]) - (2
+                        * d[i]) - d[i + 1], 2 * (x[i] - x[i + 1]) + d[i] + d[i + 1]
+            )
         }
     }
-}
+}