Merge pull request #1 from carbotaniuman/master

Add explicit types to function returns and remove reified Nat<T> from Mat

Author: Redrield

src/main/kotlin/frc/team4069/keigen/Matrix.kt

@@ -4,61 +4,60 @@ import org.ejml.dense.row.CommonOps_DDRM
 import org.ejml.dense.row.NormOps_DDRM
 import org.ejml.simple.SimpleMatrix
 
-open class Matrix<R: Num, C: Num>(private val rows: Nat<R>, private val cols: Nat<C>, internal val storage: SimpleMatrix) {
-    val numCols get() = cols.i
+open class Matrix<R: Num, C: Num> internal constructor(internal val storage: SimpleMatrix) {
+    val numCols get(): Int = storage.numCols()
+    val numRows get(): Int = storage.numRows()
 
-    val numRows get() = rows.i
-
-    operator fun get(i: Int, j: Int) = storage[i, j]
+    operator fun get(i: Int, j: Int): Double = storage[i, j]
 
     operator fun set(i: Int, j: Int, k: Double) {
         storage[i, j] = k
     }
 
-    fun diag() = Matrix(rows, cols, storage.diag())
-    fun maxInternal() = CommonOps_DDRM.elementMax(this.storage.ddrm)
-    fun minInternal() = CommonOps_DDRM.elementMin(this.storage.ddrm)
+    fun diag(): Matrix<R, C> = Matrix(storage.diag())
+    fun maxInternal(): Double = CommonOps_DDRM.elementMax(this.storage.ddrm)
+    fun minInternal(): Double = CommonOps_DDRM.elementMin(this.storage.ddrm)
     fun mean() = elementSum() / storage.numElements.toDouble()
 
     operator fun <C2: Num> times(other: Matrix<C, C2>): Matrix<R, C2>
-        = Matrix(rows, other.cols, this.storage.mult(other.storage))
+        = Matrix(this.storage.mult(other.storage))
 
     operator fun times(value: Double): Matrix<R, C>
-        = Matrix(rows, cols, this.storage.scale(value))
+        = Matrix(this.storage.scale(value))
 
     fun elementTimes(other: Matrix<R, C>): Matrix<R, C>
-        = Matrix(rows, cols, this.storage.elementMult(other.storage))
+        = Matrix(this.storage.elementMult(other.storage))
 
-    operator fun unaryMinus() = Matrix(rows, cols, storage.scale(-1.0))
+    operator fun unaryMinus(): Matrix<R, C> = Matrix(storage.scale(-1.0))
 
-    operator fun minus(value: Double) = Matrix(rows, cols, storage.minus(value))
+    operator fun minus(value: Double): Matrix<R, C> = Matrix(storage.minus(value))
 
-    operator fun minus(value: Matrix<R, C>) = Matrix(rows, cols, storage.minus(value.storage))
+    operator fun minus(value: Matrix<R, C>): Matrix<R, C> = Matrix(storage.minus(value.storage))
 
-    operator fun plus(value: Double) = Matrix(rows, cols, storage.plus(value))
+    operator fun plus(value: Double): Matrix<R, C> = Matrix(storage.plus(value))
 
-    operator fun plus(value: Matrix<R, C>) = Matrix(rows, cols, storage.plus(value.storage))
+    operator fun plus(value: Matrix<R, C>): Matrix<R, C> = Matrix(storage.plus(value.storage))
 
-    operator fun div(value: Int) = Matrix(rows, cols, storage.divide(value.toDouble()))
+    operator fun div(value: Int): Matrix<R, C> = Matrix(storage.divide(value.toDouble()))
 
-    operator fun div(value: Double) = Matrix(rows, cols, storage.divide(value))
+    operator fun div(value: Double): Matrix<R, C> = Matrix(storage.divide(value))
 
-    fun transpose(): Matrix<C, R> = Matrix(cols, rows, storage.transpose())
+    fun transpose(): Matrix<C, R> = Matrix(storage.transpose())
 
-    fun copy() = Matrix(cols, rows, storage.copy())
+    fun copy(): Matrix<R, C> = Matrix(storage.copy())
 
-    fun inv(): Matrix<R, C> = Matrix(rows, cols, storage.invert())
+    fun inv(): Matrix<R, C> = Matrix(storage.invert())
 
     fun det(): Double = storage.determinant()
 
-    fun normF() = storage.normF()
+    fun normF(): Double = storage.normF()
 
-    fun normIndP1() = NormOps_DDRM.inducedP1(this.storage.ddrm)
+    fun normIndP1(): Double = NormOps_DDRM.inducedP1(this.storage.ddrm)
 
-    fun elementSum() = this.storage.elementSum()
+    fun elementSum(): Double = this.storage.elementSum()
 
-    fun trace() = this.storage.trace()
+    fun trace(): Double = this.storage.trace()
 
-    fun epow(other: Double): Matrix<R, C> = Matrix(rows, cols, storage.elementPower(other))
-    fun epow(other: Int): Matrix<R, C> = Matrix(rows, cols, storage.elementPower(other.toDouble()))
+    fun epow(other: Double): Matrix<R, C> = Matrix(storage.elementPower(other))
+    fun epow(other: Int): Matrix<R, C> = Matrix(storage.elementPower(other.toDouble()))
 }

src/main/kotlin/frc/team4069/keigen/creatorDsl.kt

@@ -13,7 +13,7 @@ class MatBuilder<R : Num, C : Num>(val rows: Nat<R>, val cols: Nat<C>) {
         }
 
         val matData = data.toList().chunked(cols.i).map { it.toDoubleArray() }.toTypedArray()
-        return Matrix(rows, cols, SimpleMatrix(matData))
+        return Matrix(SimpleMatrix(matData))
     }
 
     fun fill(vararg data: Int): Matrix<R, C> {
@@ -22,7 +22,7 @@ class MatBuilder<R : Num, C : Num>(val rows: Nat<R>, val cols: Nat<C>) {
         }
 
         val matData = data.map { it.toDouble() }.chunked(cols.i).map { it.toDoubleArray() }.toTypedArray()
-        return Matrix(rows, cols, SimpleMatrix(matData))
+        return Matrix(SimpleMatrix(matData))
     }
 }
 
@@ -32,14 +32,14 @@ class VecBuilder<D : Num>(val dim: Nat<D>) {
             throw IllegalArgumentException("Invalid number of elements for ${dim.i}-dimensional vector. got ${data.size} elements")
         }
 
-        return Matrix(dim, `1`, SimpleMatrix(dim.i, 1, false, data))
+        return Matrix(SimpleMatrix(dim.i, 1, false, data))
     }
 
     fun fill(vararg data: Int): Vector<D> {
         if (data.size != dim.i) {
             throw IllegalArgumentException("Invalid number of elements for ${dim.i}-dimensional vector. got ${data.size} elements")
         }
 
-        return Matrix(dim, `1`, SimpleMatrix(dim.i, 1, false, data.map { it.toDouble() }.toDoubleArray()))
+        return Matrix(SimpleMatrix(dim.i, 1, false, data.map { it.toDouble() }.toDoubleArray()))
     }
 }

src/main/kotlin/frc/team4069/keigen/creators.kt

@@ -3,20 +3,19 @@ package frc.team4069.keigen
 import org.ejml.dense.row.CommonOps_DDRM
 import org.ejml.simple.SimpleMatrix
 
-fun <R: Num, C: Num> zeros(rows: Nat<R>, cols: Nat<C>) = Matrix(rows, cols, SimpleMatrix(rows.i, cols.i))
-fun <D: Num> zeros(size: Nat<D>) = Matrix(size, `1`, SimpleMatrix(size.i, 1))
+fun <R: Num, C: Num> zeros(rows: Nat<R>, cols: Nat<C>): Matrix<R, C> = Matrix(SimpleMatrix(rows.i, cols.i))
+fun <D: Num> zeros(size: Nat<D>): Matrix<D, `1`> = Matrix(SimpleMatrix(size.i, 1))
 
-fun <D: Num> eye(size: Nat<D>) = Matrix(size, size, SimpleMatrix.identity(size.i))
+fun <D: Num> eye(size: Nat<D>): Matrix<D, D> = Matrix(SimpleMatrix.identity(size.i))
 
 fun <R: Num, C: Num> ones(rows: Nat<R>, cols: Nat<C>): Matrix<R, C> {
     val out = SimpleMatrix(rows.i, cols.i)
     CommonOps_DDRM.fill(out.ddrm, 1.0)
-    return Matrix(rows, cols, out)
+    return Matrix(out)
 }
 fun <D: Num> ones(size: Nat<D>): Matrix<D, `1`> {
     val out = SimpleMatrix(size.i, 1)
     CommonOps_DDRM.fill(out.ddrm, 1.0)
-
-    return Matrix(size, `1`, out)
+    return Matrix(out)
 }
 

src/test/kotlin/frc/team4069/keigen/MatrixTest.kt

@@ -43,4 +43,12 @@ class MatrixTest {
 
         Assert.assertTrue(MatrixFeatures_DDRM.isEquals(targetVec.storage.ddrm, res.storage.ddrm))
     }
+
+    @Test
+    fun testMatNumColRow() {
+        val m = mat(`2`, `3`).fill(1, 2, 3, 4, 5, 6)
+
+        Assert.assertEquals(m.numRows, 2)
+        Assert.assertEquals(m.numCols, 3)
+    }
 }