initial commit

public/js/ahp.js

@@ -0,0 +1,86 @@
+// PAIRS: indices into VARS array [0=안정성, 1=수익_가능성, 2=자금_효율성, 3=사업_계획_완성도, 4=사회적_가치]
+const AHP_PAIRS = [
+  [0,1],[0,2],[0,3],[0,4],
+  [1,2],[1,3],[1,4],
+  [2,3],[2,4],
+  [3,4]
+];
+
+function buildMatrix(pairwiseResults) {
+  const n = 5;
+  const matrix = Array.from({length: n}, () => Array(n).fill(1));
+  AHP_PAIRS.forEach(([i, j], idx) => {
+    const val = pairwiseResults[idx];
+    if (val >= 1) {
+      matrix[i][j] = val;
+      matrix[j][i] = 1 / val;
+    } else {
+      matrix[j][i] = Math.abs(val);
+      matrix[i][j] = 1 / Math.abs(val);
+    }
+  });
+  return matrix;
+}
+
+function powerMethod(matrix, maxIter = 1000, threshold = 1e-6) {
+  const n = matrix.length;
+  let v = Array(n).fill(1 / n);
+  for (let iter = 0; iter < maxIter; iter++) {
+    const Av = Array(n).fill(0);
+    for (let i = 0; i < n; i++)
+      for (let j = 0; j < n; j++)
+        Av[i] += matrix[i][j] * v[j];
+    const sum = Av.reduce((a, b) => a + b, 0);
+    const vNew = Av.map(x => x / sum);
+    const maxDiff = Math.max(...vNew.map((x, k) => Math.abs(x - v[k])));
+    v = vNew;
+    if (maxDiff < threshold) break;
+  }
+  return v;
+}
+
+function calcConsistency(matrix, weights) {
+  const n = matrix.length;
+  const RI = [0, 0, 0.58, 0.90, 1.12, 1.24, 1.32, 1.41, 1.45];
+  const Aw = Array(n).fill(0);
+  for (let i = 0; i < n; i++)
+    for (let j = 0; j < n; j++)
+      Aw[i] += matrix[i][j] * weights[j];
+  const lambdaMax = Aw.reduce((s, v, i) => s + v / weights[i], 0) / n;
+  const CI = (lambdaMax - n) / (n - 1);
+  const CR = CI / RI[n];
+  return { lambdaMax, CI, CR };
+}
+
+function calcModelScore(caseData, weights) {
+  return VARS.reduce((sum, varKey, i) => sum + caseData[varKey] * weights[i], 0);
+}
+
+// Slider positions -4 to +4 map to AHP odd values 1,3,5,7,9
+// pos=0 → 1 (equal)
+// pos<0 → left more important, AHP value = 2*|pos|+1  (1,3,5,7,9)
+// pos>0 → right more important, stored as negative:  -(2*pos+1)
+function sliderToStored(sliderPos) {
+  if (sliderPos === 0) return 1;
+  if (sliderPos < 0) return 2 * Math.abs(sliderPos) + 1;
+  return -(2 * sliderPos + 1);
+}
+
+function storedToSlider(val) {
+  if (val === 1) return 0;
+  if (val > 1) return -((val - 1) / 2);   // left was important
+  return (Math.abs(val) - 1) / 2;          // right was important
+}
+
+function ahpValueToScale(absVal) {
+  // absVal is 2-9
+  const levels = { 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9' };
+  return absVal;
+}
+
+function runAHP(pairwiseRaw) {
+  const matrix = buildMatrix(pairwiseRaw);
+  const weights = powerMethod(matrix);
+  const { lambdaMax, CI, CR } = calcConsistency(matrix, weights);
+  return { weights, lambdaMax, CI, CR, matrix };
+}