implement rov

Author: jbytecode

src/main/scala/matrix.scala

@@ -37,10 +37,19 @@ object Matrix:
 
   def getrowat(a: Mat, i: Int): Vec = a(i)
 
+  def getrowsat(a: Mat, indices: Array[Int]): Mat =
+    indices.map(i => a(i))
+
+  def getcolsat(a: Mat, indices: Array[Int]): Mat = 
+    indices.map(i => a.transpose.apply(i)).transpose
+
   def getcolat(a: Mat, j: Int): Vec = a.map(row => row(j))
 
   def elementat(a: Mat, i: Int, j: Int): Double = a(i)(j)
 
+  def elementsat(a: Vec, indices: Array[Int]): Vec =
+    indices.map(i => a(i))
+
   def setrowat(a: Mat, i: Int, row: Vec): Mat = a.updated(i, row)
 
   def setcolat(a: Mat, j: Int, col: Vec): Mat =

src/main/scala/rov.scala

@@ -0,0 +1,61 @@
+package org.expr.mcdm
+
+import org.expr.mcdm.Direction.{Maximize, Minimize}
+
+case class RovResult(
+    normalizedMat: Mat,
+    uplus: Vec,
+    uminus: Vec,
+    scores: Vec
+) extends MCDMResult
+
+
+def rov(
+    decmat: Mat,
+    weights: Vec,
+    directions: Array[Direction],
+    normalization: NormalizationFunction =
+      Normalization.MaxMinRangeNormalization,
+    options: Map[String, Any] = Map.empty 
+): RovResult = 
+
+    val (n, p) = Matrix.size(decmat)
+
+    val normalizedMat = normalization(decmat, weights, directions)
+
+    val uplus = Matrix.zeros(n)
+
+    val uminus = Matrix.zeros(n)
+
+    val u = Matrix.zeros(n)
+
+    val maxindices = directions.zipWithIndex.filter(_._1 == Maximize).map(_._2)
+
+    val minindices = directions.zipWithIndex.filter(_._1 == Minimize).map(_._2)
+
+    if maxindices.nonEmpty then
+        for i <- 0 until n do 
+            uplus(i) = 
+                Matrix.sumproduct(
+                    Matrix.elementsat(Matrix.getrowat(normalizedMat, i), maxindices),
+                    Matrix.elementsat(weights, maxindices))
+
+    if minindices.nonEmpty then
+        for i <- 0 until n do 
+            uminus(i) = 
+                Matrix.sumproduct(
+                    Matrix.elementsat(Matrix.getrowat(normalizedMat, i), minindices),
+                    Matrix.elementsat(weights, minindices))
+
+
+    // U values are scores
+    for i <- 0 until n do 
+        u(i) = (uminus(i) + uplus(i)) / 2.0
+
+         
+    RovResult(
+        normalizedMat,
+        uplus,
+        uminus,
+        scores = u
+    )

src/test/scala/testrov.scala

@@ -0,0 +1,29 @@
+import munit.Assertions as A
+
+import org.expr.mcdm.rov
+import org.expr.mcdm.Direction.{Maximize, Minimize}
+import org.expr.mcdm.Matrix
+
+class TestRov extends munit.FunSuite {
+  test("Rov Example - 1") {
+    val mat = Array(
+      Array(0.035, 34.5, 847, 1.76, 0.335, 0.5, 0.59, 0.59),
+      Array(0.027, 36.8, 834, 1.68, 0.335, 0.665, 0.665, 0.665),
+      Array(0.037, 38.6, 808, 2.4, 0.59, 0.59, 0.41, 0.5),
+      Array(0.028, 32.6, 821, 1.59, 0.5, 0.59, 0.59, 0.41))
+
+    val w = Array(0.3306, 0.0718, 0.1808, 0.0718, 0.0459, 0.126, 0.126, 0.0472)
+
+    val fns = Array(Minimize, Minimize, Minimize, Minimize, Maximize, Minimize, Minimize, Maximize)
+
+    val expected_scores = Array(
+            0.1841453340595497,
+            0.26171444444444447,
+            0.21331577540106955,
+            0.34285244206773624)
+
+    val result1 = rov(mat, w, fns)
+
+    A.assert(Matrix.elementwise_equal(result1.scores, expected_scores, 1e-6), "Rov scores do not match expected values")
+  }
+}