kmath-core/src/commonMain/kotlin/scientifik/kmath/expressions/Expression.kt

@@ -17,9 +17,8 @@ interface ExpressionContext<T> {
 }
 
 internal class VariableExpression<T>(val name: String, val default: T? = null) : Expression<T> {
-    override fun invoke(arguments: Map<String, T>): T {
-        return arguments[name] ?: default ?: error("The parameter not found: $name")
-    }
+    override fun invoke(arguments: Map<String, T>): T =
+            arguments[name] ?: default ?: error("Parameter not found: $name")
 }
 
 internal class ConstantExpression<T>(val value: T) : Expression<T> {

kmath-core/src/commonMain/kotlin/scientifik/kmath/histogram/PhantomHistogram.kt

@@ -52,9 +52,8 @@ class PhantomHistogram<T : Comparable<T>>(
     override val dimension: Int
         get() = data.dimension
 
-    override fun iterator(): Iterator<PhantomBin<T>> {
-        return bins.asSequence().map { entry -> PhantomBin(entry.key, data[entry.value]) }.iterator()
-    }
+    override fun iterator(): Iterator<PhantomBin<T>> =
+            bins.asSequence().map { entry -> PhantomBin(entry.key, data[entry.value]) }.iterator()
 
     override fun get(point: Point<out T>): PhantomBin<T>? {
         val template = bins.keys.find { it.contains(point) }

kmath-core/src/commonMain/kotlin/scientifik/kmath/linear/LUDecomposition.kt

@@ -90,7 +90,7 @@ abstract class LUDecomposition<T : Comparable<T>, F : Field<T>>(val matrix: Matr
         }
 
     /**
-     * In-place transformation for [MutableNDArray], using given transformation for each element
+     * In-place transformation for [MutableNDStructure], using given transformation for each element
      */
     operator fun <T> MutableNDStructure<T>.set(i: Int, j: Int, value: T) {
         this[intArrayOf(i, j)] = value
@@ -181,9 +181,7 @@ abstract class LUDecomposition<T : Comparable<T>, F : Field<T>>(val matrix: Matr
      * @return the pivot permutation vector
      * @see .getP
      */
-    fun getPivot(): IntArray {
-        return pivot.copyOf()
-    }
+    fun getPivot(): IntArray = pivot.copyOf()
 
 }
 

kmath-core/src/commonMain/kotlin/scientifik/kmath/linear/LinearAlgrebra.kt

@@ -29,8 +29,8 @@ fun List<Double>.toVector() = Vector.real(this.size) { this[it] }
 /**
  * Convert matrix to vector if it is possible
  */
-fun <T : Any, F : Ring<T>> Matrix<T, F>.toVector(): Vector<T, F> {
-    return if (this.numCols == 1) {
+fun <T : Any, F : Ring<T>> Matrix<T, F>.toVector(): Vector<T, F> =
+        if (this.numCols == 1) {
 //            if (this is ArrayMatrix) {
 //                //Reuse existing underlying array
 //                ArrayVector(ArrayVectorSpace(rows, context.field, context.ndFactory), array)
@@ -40,7 +40,6 @@ fun <T : Any, F : Ring<T>> Matrix<T, F>.toVector(): Vector<T, F> {
 //            }
             Vector.generic(numRows, context.ring) { get(it, 0) }
         } else error("Can't convert matrix with more than one column to vector")
-}
 
 fun <T : Any, R : Ring<T>> Vector<T, R>.toMatrix(): Matrix<T, R> {
 //    val context = StructureMatrixContext(size, 1, context.space)
@@ -57,9 +56,8 @@ fun <T : Any, R : Ring<T>> Vector<T, R>.toMatrix(): Matrix<T, R> {
 }
 
 object VectorL2Norm : Norm<Vector<out Number, *>, Double> {
-    override fun norm(arg: Vector<out Number, *>): Double {
-        return kotlin.math.sqrt(arg.asSequence().sumByDouble { it.toDouble() })
-    }
+    override fun norm(arg: Vector<out Number, *>): Double =
+            kotlin.math.sqrt(arg.asSequence().sumByDouble { it.toDouble() })
 }
 
 typealias RealVector = Vector<Double, RealField>

kmath-core/src/commonMain/kotlin/scientifik/kmath/misc/Grids.kt

@@ -8,8 +8,8 @@ package scientifik.kmath.misc
  *
  * If step is negative, the same goes from upper boundary downwards
  */
-fun ClosedFloatingPointRange<Double>.toSequence(step: Double): Sequence<Double> {
-    return when {
+fun ClosedFloatingPointRange<Double>.toSequence(step: Double): Sequence<Double> =
+        when {
             step == 0.0 -> error("Zero step in double progression")
             step > 0 -> sequence {
                 var current = start
@@ -26,12 +26,11 @@ fun ClosedFloatingPointRange<Double>.toSequence(step: Double): Sequence<Double>
                 }
             }
         }
-}
 
 /**
  * Convert double range to array of evenly spaced doubles, where the size of array equals [numPoints]
  */
 fun ClosedFloatingPointRange<Double>.toGrid(numPoints: Int): DoubleArray {
-    if (numPoints < 2) error("Can't buffered grid with less than two points")
+    if (numPoints < 2) error("Can't create generic grid with less than two points")
     return DoubleArray(numPoints) { i -> start + (endInclusive - start) / (numPoints - 1) * i }
 }

kmath-core/src/commonMain/kotlin/scientifik/kmath/operations/Algebra.kt

@@ -34,6 +34,7 @@ interface Space<T> {
     operator fun T.div(k: Number) = multiply(this, 1.0 / k.toDouble())
     operator fun Number.times(b: T) = b * this
     fun Iterable<T>.sum(): T = fold(zero) { left, right -> left + right }
+
     fun Sequence<T>.sum(): T = fold(zero) { left, right -> left + right }
 }