From fbe7988bd03156f5dd59b023deb0772e041cacda Mon Sep 17 00:00:00 2001 From: Peter Klimai Date: Tue, 3 Sep 2019 20:35:50 +0300 Subject: [PATCH] Some refactoring, add test file --- .../kmath/real/DoubleMatrixOperations.kt | 137 +++++++++++------- .../scientific.kmath.real/RealMatrixTest.kt | 16 ++ kmath-for-real/src/jvmMain/kotlin/.gitkeep | 0 3 files changed, 99 insertions(+), 54 deletions(-) create mode 100644 kmath-for-real/src/commonTest/kotlin/scientific.kmath.real/RealMatrixTest.kt create mode 100644 kmath-for-real/src/jvmMain/kotlin/.gitkeep diff --git a/kmath-for-real/src/commonMain/kotlin/scientifik/kmath/real/DoubleMatrixOperations.kt b/kmath-for-real/src/commonMain/kotlin/scientifik/kmath/real/DoubleMatrixOperations.kt index 54e711a7b..d9c6b5eab 100644 --- a/kmath-for-real/src/commonMain/kotlin/scientifik/kmath/real/DoubleMatrixOperations.kt +++ b/kmath-for-real/src/commonMain/kotlin/scientifik/kmath/real/DoubleMatrixOperations.kt @@ -9,109 +9,138 @@ import scientifik.kmath.structures.Matrix import scientifik.kmath.structures.asSequence import kotlin.math.pow -// Initial implementation of these functions is taken from: -// https://github.com/thomasnield/numky/blob/master/src/main/kotlin/org/nield/numky/linear/DoubleOperators.kt +/* + * Functions for convenient "numpy-like" operations with Double matrices. + * + * Initial implementation of these functions is taken from: + * https://github.com/thomasnield/numky/blob/master/src/main/kotlin/org/nield/numky/linear/DoubleOperators.kt + * + */ -fun realMatrix(rowNum: Int, colNum: Int, initializer: (i: Int, j: Int) -> Double) = MatrixContext.real.produce(rowNum, colNum, initializer) +/* + * Functions that help create a real (Double) matrix + */ + +fun realMatrix(rowNum: Int, colNum: Int, initializer: (i: Int, j: Int) -> Double) = + MatrixContext.real.produce(rowNum, colNum, initializer) fun Sequence.toMatrix() = toList().let { - MatrixContext.real.produce(it.size,it[0].size) { row, col -> it[row][col] } + MatrixContext.real.produce(it.size, it[0].size) { row, col -> it[row][col] } } -operator fun Matrix.times(double: Double) = MatrixContext.real.produce(rowNum, colNum) { row, col -> - this@times[row, col] * double +fun Matrix.repeatStackVertical(n: Int) = VirtualMatrix(rowNum*n, colNum) { + row, col -> get(if (row == 0) 0 else row % rowNum, col) } -fun Matrix.square() = MatrixContext.real.produce(rowNum, colNum) { row, col -> - this@square[row,col].pow(2) +/* + * Operations for matrix and real number + */ + +operator fun Matrix.times(double: Double) = MatrixContext.real.produce(rowNum, colNum) { + row, col -> this[row, col] * double } -operator fun Matrix.plus(double: Double) = MatrixContext.real.produce(rowNum, colNum) { row, col -> - this@plus[row,col] + double +operator fun Matrix.plus(double: Double) = MatrixContext.real.produce(rowNum, colNum) { + row, col -> this[row, col] + double } -operator fun Matrix.minus(double: Double) = MatrixContext.real.produce(rowNum, colNum) { row, col -> - this@minus[row,col] - double +operator fun Matrix.minus(double: Double) = MatrixContext.real.produce(rowNum, colNum) { + row, col -> this[row, col] - double } -operator fun Matrix.div(double: Double) = MatrixContext.real.produce(rowNum, colNum) { row, col -> - this@div[row,col] / double +operator fun Matrix.div(double: Double) = MatrixContext.real.produce(rowNum, colNum) { + row, col -> this[row, col] / double } -operator fun Double.times(matrix: Matrix) = MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { row, col -> - matrix[row,col] * this +operator fun Double.times(matrix: Matrix) = MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { + row, col -> this * matrix[row, col] } -operator fun Double.plus(matrix: Matrix) = MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { row, col -> - matrix[row,col] + this +operator fun Double.plus(matrix: Matrix) = MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { + row, col -> this * matrix[row, col] } -operator fun Double.minus(matrix: Matrix) = MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { row, col -> - matrix[row,col] - this +operator fun Double.minus(matrix: Matrix) = MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { + row, col -> this - matrix[row, col] } -operator fun Double.div(matrix: Matrix) = MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { row, col -> - matrix[row,col] / this +// TODO: does this operation make sense? Should it be 'this/matrix[row, col]'? +//operator fun Double.div(matrix: Matrix) = MatrixContext.real.produce(matrix.rowNum, matrix.colNum) { +// row, col -> matrix[row, col] / this +//} + +/* + * Per-element (!) square and power operations + */ + +fun Matrix.square() = MatrixContext.real.produce(rowNum, colNum) { + row, col -> this[row, col].pow(2) } -operator fun Matrix.times(other: Matrix) = MatrixContext.real.produce(rowNum, colNum) { row, col -> - this@times[row,col] * other[row,col] +fun Matrix.pow(n: Int) = MatrixContext.real.produce(rowNum, colNum) { + i, j -> this[i, j].pow(n) } -operator fun Matrix.minus(other: Matrix) = MatrixContext.real.produce(rowNum, colNum) { row, col -> - this@minus[row,col] - other[row,col] +/* + * Operations on two matrices (per-element!) + */ + +operator fun Matrix.times(other: Matrix) = MatrixContext.real.produce(rowNum, colNum) { + row, col -> this[row, col] * other[row, col] } -operator fun Matrix.plus(other: Matrix) = MatrixContext.real.add(this,other) +operator fun Matrix.plus(other: Matrix) = MatrixContext.real.add(this, other) -fun Matrix.repeatStackVertical(n: Int) = VirtualMatrix(rowNum*n, colNum) { row, col -> - get(if (row == 0) 0 else row % rowNum, col) +operator fun Matrix.minus(other: Matrix) = MatrixContext.real.produce(rowNum, colNum) { + row, col -> this[row,col] - other[row,col] } -inline fun Matrix.appendColumn(crossinline mapper: (Buffer) -> Double) = - MatrixContext.real.produce(rowNum,colNum+1) { row,col -> +/* + * Operations on columns + */ + +inline fun Matrix.appendColumn(crossinline mapper: (Buffer) -> Double) = + MatrixContext.real.produce(rowNum,colNum+1) { + row, col -> if (col < colNum) - this[row,col] + this[row, col] else mapper(rows[row]) - } + } + +fun Matrix.extractColumns(columnRange: IntRange) = MatrixContext.real.produce(rowNum, columnRange.count()) { + row, col -> this[row, columnRange.first + col] +} fun Matrix.extractColumn(columnIndex: Int) = extractColumns(columnIndex..columnIndex) -fun Matrix.extractColumns(columnRange: IntRange) = MatrixContext.real.produce(rowNum, columnRange.count()) { row, col -> - this@extractColumns[row, columnRange.start + col] -} - -fun Matrix.sumByColumn() = MatrixContext.real.produce(1, colNum) { i, j -> +fun Matrix.sumByColumn() = MatrixContext.real.produce(1, colNum) { _, j -> val column = columns[j] with(elementContext) { sum(column.asSequence()) } } -fun Matrix.minByColumn() = MatrixContext.real.produce(1, colNum) { i, j -> - val column = columns[j] - column.asSequence().min()?:throw Exception("Cannot produce min on empty column") +fun Matrix.minByColumn() = MatrixContext.real.produce(1, colNum) { + _, j -> columns[j].asSequence().min() ?: throw Exception("Cannot produce min on empty column") } -fun Matrix.maxByColumn() = MatrixContext.real.produce(1, colNum) { i, j -> - val column = columns[j] - column.asSequence().max()?:throw Exception("Cannot produce min on empty column") +fun Matrix.maxByColumn() = MatrixContext.real.produce(1, colNum) { + _, j -> columns[j].asSequence().max() ?: throw Exception("Cannot produce min on empty column") } -fun Matrix.averageByColumn() = MatrixContext.real.produce(1, colNum) { i, j -> - val column = columns[j] - column.asSequence().average() +fun Matrix.averageByColumn() = MatrixContext.real.produce(1, colNum) { + _, j -> columns[j].asSequence().average() } -fun Matrix.sum() = this.elements().map { (_,value) -> value }.sum() +/* + * Operations processing all elements + */ -fun Matrix.min() = this.elements().map { (_,value) -> value }.min() +fun Matrix.sum() = elements().map { (_, value) -> value }.sum() -fun Matrix.max() = this.elements().map { (_,value) -> value }.max() +fun Matrix.min() = elements().map { (_, value) -> value }.min() -fun Matrix.average() = this.elements().map { (_,value) -> value }.average() +fun Matrix.max() = elements().map { (_, value) -> value }.max() -fun Matrix.pow(n: Int) = MatrixContext.real.produce(rowNum, colNum) { i, j -> - this@pow[i,j].pow(n) -} \ No newline at end of file +fun Matrix.average() = elements().map { (_, value) -> value }.average() diff --git a/kmath-for-real/src/commonTest/kotlin/scientific.kmath.real/RealMatrixTest.kt b/kmath-for-real/src/commonTest/kotlin/scientific.kmath.real/RealMatrixTest.kt new file mode 100644 index 000000000..808794442 --- /dev/null +++ b/kmath-for-real/src/commonTest/kotlin/scientific.kmath.real/RealMatrixTest.kt @@ -0,0 +1,16 @@ +package scientific.kmath.real + +import scientifik.kmath.real.average +import scientifik.kmath.real.realMatrix +import scientifik.kmath.real.sum +import kotlin.test.Test +import kotlin.test.assertEquals + +class RealMatrixTest { + @Test + fun testSum() { + val m = realMatrix(10, 10) { i, j -> (i + j).toDouble() } + assertEquals(m.sum(), 900.0) + assertEquals(m.average(), 9.0) + } +} diff --git a/kmath-for-real/src/jvmMain/kotlin/.gitkeep b/kmath-for-real/src/jvmMain/kotlin/.gitkeep new file mode 100644 index 000000000..e69de29bb