Feat/ahp

package.json

@@ -22,6 +22,7 @@
     "express": "^5.1.0",
     "express-validator": "^7.2.1",
     "jsonwebtoken": "^9.0.2",
+    "mathjs": "^15.1.0",
     "minio": "^8.0.6",
     "multer": "^2.0.2",
     "pg": "^8.16.3",

server.js

@@ -11,6 +11,7 @@ import messageRoutes from './src/routes/messages.js';
 import branchRoutes from './src/routes/branch.js';
 import thirdPartiesRoutes from './src/routes/thirdparties.js';
 import cashRequestRoutes from './src/routes/cashRequestRoutes.js';
+import ahpRoutes from './src/routes/ahpRoutes.js';
 import authRoutes from './src/routes/auth.js';
 
 const app = express();
@@ -32,6 +33,7 @@ app.use('/api/v1/users', userRoutes);
 app.use('/api/v1/messages', messageRoutes);
 app.use('/api/v1/branches', branchRoutes);
 app.use('/api/v1/thirdparties', thirdPartiesRoutes);
+app.use('/api/v1/ahp', ahpRoutes);
 
 // Basic route
 app.get('/api/', (req, res) => {

src/controllers/ahpController.js

@@ -0,0 +1,28 @@
+import { computeDataDrivenAHP } from "../utils/pairwiseMatrix.js";
+
+export const dataDrivenAHP = (req, res) => {
+  const { criteriaNames, alternativeNames, dataMatrix, benefitFlags } = req.body || {};
+
+  if (!req.body) {
+    return res.status(400).json({ error: 'Request body is required. Please send JSON with dataMatrix, criteriaNames, alternativeNames, and benefitFlags.' });
+  }
+
+  if (!Array.isArray(dataMatrix)) {
+    return res.status(400).json({ error: 'dataMatrix must be an array.' });
+  }
+
+  try {
+    console.log("Start running AHP computation");
+
+    const ahpResults = computeDataDrivenAHP({
+      dataMatrix,
+      criteriaNames,
+      alternativeNames,
+      benefitFlags
+    });
+
+    res.status(200).json(ahpResults);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+}

src/routes/ahpRoutes.js

@@ -0,0 +1,8 @@
+import express from 'express';
+import { dataDrivenAHP } from '../controllers/ahpController.js';
+
+const router = express.Router();
+
+router.post('/', dataDrivenAHP)
+
+export default router;

src/utils/ahs.js

@@ -0,0 +1,116 @@
+import { create, all } from "mathjs";
+import matrixValidation from "./validateMatrix.js";
+import weightVectorGeometricMean from "./computePriorityVector.js";
+import { consistencyRatio } from "./computeConsistancyRatio.js";
+
+const math = create(all, {});
+
+/**
+ * Compute AHP results.
+ * @param {number[][]} criteriaMatrix  n x n
+ * @param {Object.<string, number[][]>} alternativeMatrices  for each criterion key: m x m
+ * @param {string[]} criteriaNames     length n
+ * @param {string[]} alternativeNames  length m
+ * @returns structured results
+ */
+
+export function computeAHS(
+  criteriaMatrix,
+  alternativeMatrices,
+  criteriaNames,
+  alternativeNames
+) {
+
+  // --- validate criteria matrix ---
+  matrixValidation(criteriaMatrix, 'criteriaMatrix');
+  const n = criteriaMatrix.length;
+
+  // --- validate criteria names matrix ---
+  if (!Array.isArray(criteriaNames) || criteriaNames.length !== n) {
+    throw new Error("criteriaNames length must match criteriaMatrix size.");
+  }
+
+  // --- weights for criteria (GM method) + CR ---
+  const criteriaWeights = weightVectorGeometricMean(criteriaMatrix);
+  const criteriaCR = consistencyRatio(criteriaMatrix, criteriaWeights);
+
+  // --- for each criterion, compute alt weights + CR ---
+  const altLocalWeightsByCriterion = {}; // key -> vector length m
+  const altCRByCriterion = {};           // key -> number
+  let m = null;
+
+  for (let k = 0; k < n; k++) {
+    const key = criteriaNames[k];
+    const M = alternativeMatrices[key];
+
+    if (!M) {
+      throw new Error(`Missing alternative matrix for criterion: ${key}`);
+    }
+
+    matrixValidation(M, `alternativeMatrices["${key}"]`);
+
+    if (m === null) m = M.length;
+    if (M.length !== m) {
+      throw new Error("All alternative matrices must be the same size (m x m)");
+    }
+
+    const w = weightVectorGeometricMean(M);
+    const cr = consistencyRatio(M, w);
+
+    altLocalWeightsByCriterion[key] = w;
+    altCRByCriterion[key] = cr;
+
+  }
+
+  if (!Array.isArray(alternativeNames) || alternativeNames.length !== m) {
+    throw new Error("alternativeNames length must match alternative matrix size");
+  }
+
+
+  // --- aggregate global scores: sum_k (criteriaWeight[k] * altWeight_k[i]) ---
+  const globalScores = new Array(m).fill(0);
+  for (let i = 0; i < m; i++) {
+    let s = 0;
+    for (let k = 0; k < n; k++) {
+      const key = criteriaNames[k];
+      s += criteriaWeights[k] * altLocalWeightsByCriterion[key][i];
+    }
+    globalScores[i] = s;
+  }
+
+  // --- ranking indices sorted desc ---
+  const idx = globalScores.map((v, i) => i)
+    .sort((i, j) => globalScores[j] - globalScores[i]);
+
+  const ranking = idx.map((i) => ({
+    name: alternativeNames[i],
+    score: Number(globalScores[i].toFixed(6))
+  }));
+
+  return {
+    criteria: criteriaNames.map((name, i) => ({
+      name,
+      weight: Number(criteriaWeights[i].toFixed(6))
+    })),
+    criteriaCR: Number(criteriaCR.toFixed(6)),
+    alternatives: alternativeNames,
+    localWeights: Object.fromEntries(
+      Object.entries(altLocalWeightsByCriterion).map(([k, w]) => [
+        k,
+        w.map((x) => Number(x.toFixed(6)))
+      ])
+    ),
+    localCR: Object.fromEntries(
+      Object.entries(altCRByCriterion).map(([k, cr]) => [k, Number(cr.toFixed(6))])
+    ),
+    globalScores: alternativeNames.map((name, i) => ({
+      name,
+      score: Number(globalScores[i].toFixed(6))
+    })),
+    ranking
+  };
+
+}
+
+
+

src/utils/computeConsistancyRatio.js

@@ -0,0 +1,30 @@
+import { create, all } from "mathjs";
+
+const math = create(all, {});
+
+const RI = {
+  1: 0.00, 2: 0.00, 3: 0.58, 4: 0.90, 5: 1.12,
+  6: 1.24, 7: 1.32, 8: 1.41, 9: 1.45, 10: 1.49,
+  11: 1.51, 12: 1.48, 13: 1.56, 14: 1.57, 15: 1.59
+};
+
+
+/** Consistency Ratio for a pairwise matrix M with weights w */
+export function lambdaMax(M, w) {
+  const Aw = math.multiply(M, w); // vector
+  let sum = 0;
+  for (let i = 0; i < w.length; i++) {
+    sum += (Aw[i] / w[i]);
+  }
+  return sum / w.length;
+}
+
+/** Consistency Ratio for a pairwise matrix M with weights w */
+export function consistencyRatio(M, w) {
+  const n = M.length;
+  if (n <= 2) return 0; // CR undefined but effectively 0
+  const lam = lambdaMax(M, w);
+  const CI = (lam - n) / (n - 1);
+  const ri = RI[n] ?? RI[15]; // cap if very large n
+  return ri === 0 ? 0 : CI / ri;
+}