implement edas

Author: jbytecode

src/main/scala/edas.scala

@@ -0,0 +1,77 @@
+package org.expr.mcdm
+
+import scala.math.max 
+
+case class EdasResult(
+    PDAMatrix: Mat,
+    NDAMatrix: Mat,
+    weightedPDAMatrix: Mat,
+    weightedNDAMatrix: Mat,
+    SP: Vec,
+    SN: Vec,
+    NSP: Vec,
+    NSN: Vec,
+    scores: Vec,
+    orderings: VecInt,
+    bestIndex: Int,
+) extends MCDMResult
+
+def edas(
+    decmat: Mat,
+    weights: Vec,
+    directions: Array[Direction],
+    normalization: NormalizationFunction =
+      Normalization.DivideByColumnnsSumNormalization,
+    options: Map[String, Any] = Map.empty 
+): EdasResult =
+
+    val (row, col) = Matrix.size(decmat)
+
+    var PDAMatrix = Matrix.zeros(row, col)
+    var NDAMatrix = Matrix.zeros(row, col)
+
+    var AV = Matrix.zeros(col)
+
+
+    for i <- 0 until col do
+        AV(i) = Statistics.mean(Matrix.getcolat(decmat, i))
+        for j <- 0 until row do
+            if directions(i) == Direction.Maximize then
+                PDAMatrix(j)(i) = max(0.0, decmat(j)(i) - AV(i)) / AV(i)
+                NDAMatrix(j)(i) = max(0.0, AV(i) - decmat(j)(i)) / AV(i)
+            else
+                PDAMatrix(j)(i) = Math.max(0.0, AV(i) - decmat(j)(i)) / AV(i)
+                NDAMatrix(j)(i) = Math.max(0.0, decmat(j)(i) - AV(i)) / AV(i)
+           
+    
+
+
+    val weightedPDAMatrix = Matrix.weightizeColumns(PDAMatrix, weights)
+    val weightedNDAMatrix = Matrix.weightizeColumns(NDAMatrix, weights)
+
+
+    val SP = weightedPDAMatrix.map(row => row.sum)
+    val SN = weightedNDAMatrix.map(row => row.sum)
+
+
+    val NSP = SP.map(_ / SP.max)
+    val NSN = SN.map(x => 1.0 - x / SN.max)
+
+
+    val scores = NSP.zip(NSN).map((x, y) => (x + y) / 2.0)
+    val orderings = scores.zipWithIndex.sortBy(_._1).map(_._2)
+    val bestIndex = orderings.last
+
+    EdasResult(
+        PDAMatrix,
+        NDAMatrix,
+        weightedPDAMatrix,
+        weightedNDAMatrix,
+        SP,
+        SN,
+        NSP,
+        NSN,
+        scores,
+        orderings,
+        bestIndex
+    )

src/test/scala/testedas.scala

@@ -0,0 +1,39 @@
+import munit.Assertions as A
+
+import org.expr.mcdm.edas
+import org.expr.mcdm.Direction.{Maximize, Minimize}
+import org.expr.mcdm.Matrix
+
+class TestEdas extends munit.FunSuite {
+  test("Edas Example - 1") {
+
+    val decmat = Array(
+      Array(5000.0, 5, 5300, 450),
+      Array(4500.0, 5, 5000, 400),
+      Array(4500.0, 4, 4700, 400),
+      Array(4000.0, 4, 4200, 400),
+      Array(5000.0, 4, 7100, 500),
+      Array(5000.0, 5, 5400, 450),
+      Array(5500.0, 5, 6200, 500),
+      Array(5000.0, 4, 5800, 450)
+    )
+
+    val weights = Array(0.25, 0.25, 0.25, 0.25)
+
+    val fns = Array(Maximize, Maximize, Minimize, Minimize)
+
+    val result = edas(decmat, weights, fns)
+
+    val expected_scores = Array(0.759594, 0.886016, 0.697472, 0.739658,
+      0.059083, 0.731833, 0.641691, 0.385194)
+    
+    A.assert(Matrix.elementwise_equal(result.scores, expected_scores, 0.0001),
+      "Scores do not match the expected values"
+    )
+
+    A.assert(result.bestIndex == 1,
+      "Best index does not match the expected value"
+    )
+
+  }
+}