Merge pull request 'Replace FlagAttributes with BooleanAttributes for matrices to solve KS-626' (!530) from feature/boolean-flag-attributes into dev

Reviewed-on: https://git.sciprog.center/kscience/kmath/pulls/530
Reviewed-by: Gleb Minaev <glebminaev02@yandex.ru>

Author: altavir

build.gradle.kts

@@ -15,7 +15,7 @@ allprojects {
     }
 
     group = "space.kscience"
-    version = "0.4.3-dev-1"
+    version = "0.5.0-dev-1"
 }
 
 dependencies {
@@ -91,7 +91,7 @@ kscienceProject {
     @OptIn(ExperimentalAbiValidation::class)
     abiValidation {
         filters {
-            excluded{
+            excluded {
                 annotatedWith.add("space.kscience.kmath.UnstableKMathAPI")
             }
         }

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/LupDecomposition.kt

@@ -15,7 +15,9 @@ import space.kscience.kmath.PerformancePitfall
 import space.kscience.kmath.UnstableKMathAPI
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.operations.*
-import space.kscience.kmath.structures.*
+import space.kscience.kmath.structures.Float64
+import space.kscience.kmath.structures.IntBuffer
+import space.kscience.kmath.structures.asBuffer
 
 public interface LupDecomposition<T> {
     public val pivot: IntBuffer
@@ -47,7 +49,7 @@ public class GenericLupDecomposition<T>(
 
 
     override val l: Matrix<T>
-        get() = VirtualMatrix(lu.rowNum, lu.colNum, attributes = Attributes(LowerTriangular)) { i, j ->
+        get() = VirtualMatrix(lu.rowNum, lu.colNum, attributes = Attributes(LowerTriangular, true)) { i, j ->
             when {
                 j < i -> lu[i, j]
                 j == i -> elementAlgebra.one
@@ -56,7 +58,7 @@ public class GenericLupDecomposition<T>(
         }
 
     override val u: Matrix<T>
-        get() = VirtualMatrix(lu.rowNum, lu.colNum, attributes = Attributes(UpperTriangular)) { i, j ->
+        get() = VirtualMatrix(lu.rowNum, lu.colNum, attributes = Attributes(UpperTriangular,true)) { i, j ->
             if (j >= i) lu[i, j] else elementAlgebra.zero
         }
 

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixBuilder.kt

@@ -80,7 +80,7 @@ public fun <T, A : Ring<T>> MatrixBuilder<T, A>.diagonal(
     builder: A.(Int) -> T
 ): Matrix<T> = with(linearSpace.elementAlgebra) {
     require(colNum == rowNum) { "In order to build symmetric matrix, number of rows $rowNum should be equal to number of columns $colNum" }
-    return VirtualMatrix(rowNum, colNum, attributes = Attributes(IsDiagonal)) { i, j ->
+    return VirtualMatrix(rowNum, colNum, attributes = Attributes(IsDiagonal, true)) { i, j ->
         check(i in 0 until rowNum) { "$i out of bounds: 0..<$rowNum" }
         check(j in 0 until colNum) { "$j out of bounds: 0..<$colNum" }
         if (i == j) {
@@ -97,7 +97,8 @@ public fun <T, A : Ring<T>> MatrixBuilder<T, A>.diagonal(
 @UnstableKMathAPI
 public fun <T> MatrixBuilder<T, Ring<T>>.diagonal(vararg elements: T): Matrix<T> {
     require(colNum == rowNum) { "In order to build symmetric matrix, number of rows $rowNum should be equal to number of columns $colNum" }
-    return return VirtualMatrix(rowNum, colNum, attributes = Attributes(IsDiagonal)) { i, j ->
+
+    return VirtualMatrix(rowNum, colNum, attributes = Attributes(IsDiagonal,true)) { i, j ->
         check(i in 0 until rowNum) { "$i out of bounds: 0..<$rowNum" }
         check(j in 0 until colNum) { "$j out of bounds: 0..<$colNum" }
         if (i == j) {

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/MatrixWrapper.kt

@@ -36,23 +36,35 @@ public val <T : Any> Matrix<T>.origin: Matrix<T>
 /**
  * Add a single feature to a [Matrix]
  */
-public fun <T, A : Attribute<T>> Matrix<T>.withAttribute(
-    attribute: A,
+public fun <T> Matrix<T>.withAttribute(
+    attribute: Attribute<T>,
     attrValue: T,
 ): MatrixWrapper<T> = if (this is MatrixWrapper) {
     MatrixWrapper(origin, attributes.withAttribute(attribute, attrValue))
 } else {
     MatrixWrapper(this, Attributes(attribute, attrValue))
 }
 
-public fun <T, A : Attribute<Unit>> Matrix<T>.withAttribute(
-    attribute: A,
+public fun <T> Matrix<T>.withAttribute(
+    attribute: Attribute<Unit>,
 ): MatrixWrapper<T> = if (this is MatrixWrapper) {
     MatrixWrapper(origin, attributes.withFlag(attribute))
 } else {
     MatrixWrapper(this, Attributes(attribute, Unit))
 }
 
+/**
+ * Add boolean attribute with default value `true`
+ */
+public fun <T> Matrix<T>.withAttribute(
+    attribute: Attribute<Boolean>,
+    value: Boolean = true
+): MatrixWrapper<T> = if (this is MatrixWrapper) {
+    MatrixWrapper(origin, attributes.withAttribute(attribute, value))
+} else {
+    MatrixWrapper(this, Attributes(attribute, value))
+}
+
 /**
  * Modify matrix attributes
  */

kmath-core/src/commonMain/kotlin/space/kscience/kmath/linear/matrixAttributes.kt

@@ -23,11 +23,14 @@ public interface MatrixScope<T> : WithType<T>
  */
 public interface MatrixAttribute<T> : StructureAttribute<T>
 
+public typealias BooleanAttribute = Attribute<Boolean>
+
+
 /**
  * Matrices with this feature are symmetric, meaning `matrix[i,j] == matrix[j,i]`
  */
-public interface Symmetric : MatrixAttribute<Unit>, FlagAttribute{
-    public companion object: Symmetric
+public interface Symmetric : MatrixAttribute<Boolean> {
+    public companion object : Symmetric
 }
 
 /**
@@ -72,12 +75,12 @@ public val <T> MatrixScope<T>.Determinant: Determinant<T> get() = Determinant(ty
 /**
  * Matrices with this feature are lower triangular ones.
  */
-public object LowerTriangular : MatrixAttribute<Unit>, FlagAttribute
+public object LowerTriangular : MatrixAttribute<Boolean>
 
 /**
  * Matrices with this feature are upper triangular ones.
  */
-public object UpperTriangular : MatrixAttribute<Unit>, FlagAttribute
+public object UpperTriangular : MatrixAttribute<Boolean>
 
 /**
  * Matrices with this feature support LU factorization: *a = [l] &middot; [u]* where *a* is the owning matrix.
@@ -102,7 +105,7 @@ public val <T> MatrixScope<T>.LU: LuDecompositionAttribute<T> get() = LuDecompos
  * Matrices with this feature are orthogonal ones: *a &middot; a<sup>T</sup> = u* where *a* is the owning matrix, *u*
  * is the unit matrix ([IsUnit]).
  */
-public object OrthogonalAttribute : MatrixAttribute<Unit>, FlagAttribute
+public object OrthogonalAttribute : MatrixAttribute<Boolean>
 
 
 public interface QRDecomposition<out T> {