add column min-max regarding to a direction vector

Author: jbytecode

src/main/scala/matrix.scala

@@ -115,3 +115,14 @@ object Matrix:
             identity(k)(j) -= factor * identity(i)(j)
     identity
 
+  def colminmax(a: Mat, dirs: Array[Direction]): Vec =
+    val n = a(0).length
+    val result = Array.fill(n)(0.0)
+    for j <- 0 until n do
+      val col = getcolat(a, j)
+      val currentdir = dirs(j)
+      result(j) = currentdir match
+        case Direction.Minimize => col.min
+        case Direction.Maximize => col.max
+    result
+

src/main/scala/mcdm.scala

@@ -1,8 +1,11 @@
 package org.expr.mcdm
 
 type Mat = Array[Array[Double]]
+
 type Vec = Array[Double]
 
+type VecInt = Array[Int]
+
 type NormalizationFunction = (Mat, Vec, Array[Direction]) => Mat
 
 enum Direction:

src/main/scala/topsis.scala

@@ -1,21 +1,21 @@
 package org.expr.mcdm
 
 import org.expr.mcdm.MCDMResult
-import org.expr.mcdm.Direction
+import org.expr.mcdm.Direction._
 import org.expr.mcdm.Matrix
 import org.expr.mcdm.Vec
 import org.expr.mcdm.Mat
 import org.expr.mcdm.Statistics
 
 case class TopsisResult(
-    val normalizedMatrix: Array[Array[Double]],
-    val weightedNormalizedMatrix: Array[Array[Double]],
-    val ideal: Array[Double],
-    val antiIdeal: Array[Double],
-    val distanceToIdeal: Array[Double],
-    val distanceToAntiIdeal: Array[Double],
-    val scores: Array[Double],
-    val rankings: Array[Int],
+    val normalizedMatrix: Mat,
+    val weightedNormalizedMatrix: Mat,
+    val ideal: Vec,
+    val antiIdeal: Vec,
+    val distanceToIdeal: Vec,
+    val distanceToAntiIdeal: Vec,
+    val scores: Vec,
+    val rankings: VecInt,
     val bestIndex: Int
 ) extends MCDMResult
 
@@ -31,12 +31,12 @@ def topsis(
     val colmaxs = Matrix.colmaxs(weightedNormalizedMatrix)
     val colmins = Matrix.colmins(weightedNormalizedMatrix)
     val ideal = directions.zip(colmaxs.zip(colmins)).map {
-      case (Direction.Maximize, (max, _)) => max
-      case (Direction.Minimize, (_, min)) => min
+      case (Maximize, (max, _)) => max
+      case (Minimize, (_, min)) => min
     }
     val antiIdeal = directions.zip(colmaxs.zip(colmins)).map {
-      case (Direction.Maximize, (_, min)) => min
-      case (Direction.Minimize, (max, _)) => max
+      case (Maximize, (_, min)) => min
+      case (Minimize, (max, _)) => max
     }
     val distanceToIdeal = 
       Matrix.applyFunctionToRows(weightedNormalizedMatrix, (row: Vec) =>

src/test/scala/testmatrix.scala

@@ -1,6 +1,7 @@
 import munit.Assertions as A
 
 import org.expr.mcdm.Matrix
+import org.expr.mcdm.Direction
 
 class TestMatrix extends munit.FunSuite {
   test("zeros(10)") {
@@ -305,5 +306,35 @@ class TestMatrix extends munit.FunSuite {
     val inv = Matrix.inverse(mat)
     A.assert(Matrix.elementwise_equal(inv, expected, 1e-6))
   }
+  test("Column min max regarding to direction vector - 1"){
+    val mat = Array(
+      Array(1.0, 5.0, 6.0),
+      Array(-1.0, 10.0, 9.0),
+      Array(9.0, 17.0, 12.0)
+    )
+    val direction = Array(
+      Direction.Minimize, 
+      Direction.Maximize, 
+      Direction.Minimize)
+    val values = Matrix.colminmax(mat, direction)
+    val expected = Array(-1.0, 17.0, 6.0)
+    A.assert(Matrix.elementwise_equal(values, expected))
+  }
+  test("Column min max regarding to direction vector - 2"){
+    val mat = Array(
+      Array(1.0, 5.0, 6.0, 10.0, 10.0),
+      Array(-1.0, 10.0, 9.0, 11.0, 11.0),
+      Array(9.0, 17.0, 12.0, 12.0, 12.0)
+    )
+    val direction = Array(
+      Direction.Minimize, 
+      Direction.Maximize, 
+      Direction.Minimize,
+      Direction.Maximize,
+      Direction.Minimize)
+    val values = Matrix.colminmax(mat, direction)
+    val expected = Array(-1.0, 17.0, 6.0, 12.0, 10.0)
+    A.assert(Matrix.elementwise_equal(values, expected))
+  }
 
 }