implement Saw

Author: jbytecode

src/main/scala/normalization.scala

@@ -37,3 +37,18 @@ object Normalization:
       then (decmat(i)(j) - columnmins(j)) / (columnmaxs(j) - columnmins(j))
       else (columnmaxs(j) - decmat(i)(j)) / (columnmaxs(j) - columnmins(j))
     )
+
+  def DivideByColumnMaxMinNormalization(
+      decmat: Mat,
+      weights: Vec,
+      directions: Array[Direction]
+  ): Mat =
+    val (n, m) = Matrix.size(decmat)
+    val columnmins = Matrix.colmins(decmat)
+    val columnmaxs = Matrix.colmaxs(decmat)
+
+    Array.tabulate(n, m)((i, j) =>
+      if directions(j) == Direction.Maximize
+      then decmat(i)(j) / columnmaxs(j)
+      else columnmins(j) / decmat(i)(j)
+    )

src/main/scala/saw.scala

@@ -0,0 +1,38 @@
+package org.expr.mcdm
+
+import org.expr.mcdm.Direction
+
+case class SawResult(
+    normalizedDecisionMat: Mat,
+    weightedNormalizedDecMat: Mat,
+    scores: Vec,
+    orderings: VecInt,
+    bestIndex: Int
+) extends MCDMResult
+
+def saw(
+    mat: Mat, 
+    weights: Vec,
+    directions: Array[Direction], 
+    normalization: NormalizationFunction = Normalization.DivideByColumnMaxMinNormalization
+    ): SawResult = 
+        
+        val (n, p) = Matrix.size(mat)
+
+        val normalizedDecisionMat = normalization(mat, weights, directions)
+
+        val weightedNormalizedDecMat = Matrix.weightizeColumns(normalizedDecisionMat, weights)
+
+        val scores = Matrix.rowsums(weightedNormalizedDecMat)
+
+        val orderings = scores.zipWithIndex.sortBy(_._1).map(_._2)
+
+        val bestIndex = orderings.last
+        
+        SawResult(
+            normalizedDecisionMat,
+            weightedNormalizedDecMat,
+            scores,
+            orderings,
+            bestIndex
+        )

src/test/scala/testnormalization.scala

@@ -4,6 +4,7 @@ import scala.math as math
 import org.expr.mcdm.Matrix
 import org.expr.mcdm.Direction._
 import org.expr.mcdm.Normalization._
+import org.expr.mcdm.Normalization
 
 class TestNormalizations extends munit.FunSuite {
 
@@ -61,5 +62,23 @@ class TestNormalizations extends munit.FunSuite {
 
       A.assert(Matrix.elementwise_equal(normalizedMatrix, expected, 1e-5))
   }
+
+  test("Divide by column max min normalization"){
+    val mat = Array(
+       Array(0.0264859,  0.0565293,  0.960557,  0.765195,  0.135447),
+       Array(0.31746  ,  0.631628 ,  0.142819,  0.94584 ,  0.553917),
+       Array(0.166361 ,  0.197306 ,  0.725104,  0.334121,  0.202895))
+
+    val directions = Array(Maximize, Minimize, Maximize, Minimize, Maximize)
+
+    val result = Normalization.DivideByColumnMaxMinNormalization(mat, Array.emptyDoubleArray, directions)
+
+    val expected = Array(
+       Array(0.0834308,  1.0      ,  1.0     ,  0.436648,  0.244525),
+       Array(1.0      ,  0.0894977,  0.148684,  0.353253,  1.0),
+       Array(0.524038 ,  0.286505 ,  0.75488 ,  1.0     ,  0.366291))
+
+    A.assert(Matrix.elementwise_equal(result, expected, 1e-5))
+  }
 
 }

src/test/scala/testsaw.scala

@@ -0,0 +1,35 @@
+import munit.Assertions as A
+
+import org.expr.mcdm.Matrix
+import org.expr.mcdm.Direction
+import org.expr.mcdm.saw
+
+class TestSaw extends munit.FunSuite {
+    
+    test("Saw Example - 1"){
+        val decmat = Array(
+            Array(25.0, 21, 19, 22),
+            Array(65.0, 78, 53, 25),
+            Array(7.0 ,  6, 5 ,  2),
+            Array(20.0, 24, 33, 31)).transpose
+
+        val weights = Array(0.25, 0.25, 0.25, 0.25)
+
+        val directions = Array(
+            Direction.Maximize,
+            Direction.Maximize,
+            Direction.Minimize,
+            Direction.Maximize
+        )
+
+        val result = saw(decmat, weights, directions)
+
+        val expectedScores = Array(0.681277, 0.725151, 0.709871, 0.784976)
+
+        A.assert(Matrix.elementwise_equal(result.scores, expectedScores))
+
+        A.assertEquals(result.bestIndex, 3)
+    }
+
+}    
+