为向量序列和可迭代提供 sum() 扩展

Author: YdrMaster

src/main/kotlin/org/mechdancer/algebra/Utility.kt

@@ -23,41 +23,31 @@ fun Iterable<Boolean>.alwaysTrue() = all { it }
  * 最好先判断维数相同
  */
 infix fun Iterable<Double>.contentEquals(other: Iterable<Double>) =
-	zip(other, ::doubleEquals).alwaysTrue()
+    zip(other, ::doubleEquals).alwaysTrue()
 
 /**
  * 判断两个浮点列表相同
  * 最好先判断维数相同
  */
 infix fun DoubleArray.contentEquals(other: List<Double>) =
-	zip(other, ::doubleEquals).alwaysTrue()
+    zip(other, ::doubleEquals).alwaysTrue()
 
 /**
  * 计算许多元素的哈希值
  * 慎用！有递归风险！
  */
 fun hash(vararg elements: Any?) =
-	elements.fold(0) { code, it -> code.hashCode() * 31 + (it?.hashCode() ?: 0) }
+    elements.fold(0) { code, it -> code.hashCode() * 31 + (it?.hashCode() ?: 0) }
 
-/**
- * 判断一个可迭代集中所有元素存在相等关系
- */
 fun <T> Iterable<T>.isUnique() = toSet().size == 1
-
-/**
- * 判断一个可迭代集中所有元素存在某种相等关系
- */
-inline infix fun <T, U> Iterable<T>.uniqueOn(block: (T) -> U) = map(block).isUnique()
-
-/**
- * 总结一个可迭代集中所有元素的特征
- */
 fun <T> Iterable<T>.uniqueValue(): T? = toSet().singleOrNull()
+inline fun <T, U> Iterable<T>.uniqueOn(block: (T) -> U) = map(block).isUnique()
+inline fun <T, U> Iterable<T>.uniqueValue(block: (T) -> U): U? = map(block).uniqueValue()
 
-/**
- * 总结一个可迭代集中所有元素的某项特征
- */
-inline infix fun <T, U> Iterable<T>.uniqueValue(block: (T) -> U): U? = map(block).uniqueValue()
+fun <T> Sequence<T>.isUnique() = toSet().size == 1
+fun <T> Sequence<T>.uniqueValue(): T? = toSet().singleOrNull()
+fun <T, U> Sequence<T>.uniqueOn(block: (T) -> U) = map(block).isUnique()
+fun <T, U> Sequence<T>.uniqueValue(block: (T) -> U): U? = map(block).uniqueValue()
 
 internal inline fun <T, U> List<T>.zipFast(other: List<T>, block: (T, T) -> U) =
-	List(kotlin.math.min(size, other.size)) { block(this[it], other[it]) }
+    List(kotlin.math.min(size, other.size)) { block(this[it], other[it]) }

src/main/kotlin/org/mechdancer/algebra/function/vector/Access.kt

@@ -2,7 +2,7 @@ package org.mechdancer.algebra.function.vector
 
 import org.mechdancer.algebra.core.Vector
 
-//解绑定
+// 解绑定
 
 operator fun Vector.component1() = this[0]
 operator fun Vector.component2() = this[1]

src/main/kotlin/org/mechdancer/algebra/function/vector/Cauculate.kt

@@ -6,6 +6,7 @@ import org.mechdancer.algebra.implement.vector.*
 import org.mechdancer.algebra.uniqueValue
 import org.mechdancer.algebra.zipFast
 import kotlin.math.abs
+import kotlin.math.pow
 
 operator fun Vector.times(k: Number) = toList().map { it * k.toDouble() }.let(::ListVector)
 operator fun Vector.div(k: Number) = toList().map { it / k.toDouble() }.let(::ListVector)
@@ -72,26 +73,27 @@ fun Vector3D.normalize() =
     else
         div(length)
 
-/** 求向量表示的点集的“重心” */
-fun Collection<Vector>.centre() =
+fun Sequence<Vector>.sum() =
     uniqueValue(Vector::dim)
         ?.let(::listVectorOfZero)
         ?.let { fold(it) { sum, v -> sum + v } }
-        ?.div(size)
     ?: throw UnsupportedOperationException("vector dimensions are different")
 
-/** 求二维向量表示的点集的“重心” */
-fun Collection<Vector2D>.centre() =
-    Vector2D(
-        map(Vector2D::x).average(),
-        map(Vector2D::y).average()
-    )
+fun Sequence<Vector2D>.sum() =
+    fold(vector2DOfZero()) { sum, v -> sum + v }
+
+fun Sequence<Vector3D>.sum() =
+    fold(vector3DOfZero()) { sum, v -> sum + v }
+
+fun Iterable<Vector>.sum() = asSequence().sum()
+fun Iterable<Vector2D>.sum() = asSequence().sum()
+fun Iterable<Vector3D>.sum() = asSequence().sum()
 
 /** [n]范数 */
 fun Vector.norm(n: Int = 2) =
     when (n) {
-        -1   -> toList().map(::abs).max()
-        1    -> toList().sumByDouble(::abs)
-        2    -> length
-        else -> throw UnsupportedOperationException("please invoke length(-1) for infinite length")
+        -1, Int.MAX_VALUE -> toList().map(::abs).max()
+        1                 -> toList().sumByDouble(::abs)
+        2                 -> length
+        else              -> toList().sumByDouble { it.pow(n) }.pow(1.0 / n)
     } ?: .0

src/main/kotlin/org/mechdancer/algebra/function/vector/Copy.kt

@@ -2,29 +2,6 @@ package org.mechdancer.algebra.function.vector
 
 import org.mechdancer.algebra.core.Vector
 import org.mechdancer.algebra.implement.vector.ListVector
-import org.mechdancer.algebra.implement.vector.Vector2D
-import org.mechdancer.algebra.implement.vector.Vector3D
-
-/**
- * Copy a 2-dimension vector
- * 复制一个二维向量
- *
- * @param x the 1st dimension
- * @param y the 2nd dimension
- */
-fun Vector2D.copy(x: Number? = null, y: Number? = null) =
-    Vector2D(x?.toDouble() ?: this.x, y?.toDouble() ?: this.y)
-
-/**
- * Copy a 3-dimension vector
- * 复制一个二维向量
- *
- * @param x the 1st dimension
- * @param y the 2nd dimension
- * @param z the 3rd dimension
- */
-fun Vector3D.copy(x: Number? = null, y: Number? = null, z: Number? = null) =
-    Vector3D(x?.toDouble() ?: this.x, y?.toDouble() ?: this.y, z?.toDouble() ?: this.z)
 
 /**
  * Copy a vector and change value of the first 3 dimension by their name

src/main/kotlin/org/mechdancer/geometry/transformation/Calculate.kt

@@ -5,9 +5,9 @@ import org.mechdancer.algebra.core.Vector
 import org.mechdancer.algebra.function.equation.solve
 import org.mechdancer.algebra.function.matrix.times
 import org.mechdancer.algebra.function.vector.DistanceType
-import org.mechdancer.algebra.function.vector.centre
 import org.mechdancer.algebra.function.vector.div
 import org.mechdancer.algebra.function.vector.minus
+import org.mechdancer.algebra.function.vector.sum
 import org.mechdancer.algebra.implement.equation.builder.EquationSetBuilder
 import org.mechdancer.algebra.implement.matrix.builder.foldToRows
 import org.mechdancer.algebra.implement.matrix.builder.matrix
@@ -48,8 +48,8 @@ fun PointMap.toTransformation(): MatrixTransformation? {
               ?: throw IllegalArgumentException("points not in same dim")
     val temp = DoubleArray(dim * dim)
 
-    val ct = targets.centre()
-    val cs = sources.centre()
+    val ct = targets.sum() / size
+    val cs = sources.sum() / size
 
     return takeIf { size > dim }
         ?.flatMap { (target, source) ->
@@ -80,8 +80,8 @@ private fun Point2DMap.toTransformation(
     buildMatrix: (Vector) -> Matrix
 ): MatrixTransformation? {
     if (size < 2) return null
-    val ct = keys.centre()
-    val cs = values.centre()
+    val ct = keys.sum() / size
+    val cs = values.sum() / size
 
     return EquationSetBuilder()
         .also { builder ->