ecclesia/dist/election/attribution/scoreFactory.cjs

Framework for political and electoral simulations

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/election/attribution/scoreFactory.ts
var scoreFactory_exports = {};
__export(scoreFactory_exports, {
  averageScore: () => averageScore,
  medianScore: () => medianScore
});
module.exports = __toCommonJS(scoreFactory_exports);
var import_python = require("@gouvernathor/python");
var import_collections = require("@gouvernathor/python/collections");
var import_statistics = require("@gouvernathor/python/statistics");

// src/election/ballots.ts
var Scores;
((Scores2) => {
  function get(key) {
    const value = this.get(key);
    if (value === void 0) {
      return Array(this.ngrades).fill(0);
    }
    return value;
  }
  function fromEntries(elements) {
    if (elements.length === 0) {
      throw new Error("Use the fromGrades method to create an empty Scores instance");
    }
    const ths = new Map(elements);
    ths.ngrades = elements[0][1].length;
    ths.get = get.bind(ths);
    return ths;
  }
  Scores2.fromEntries = fromEntries;
  function fromGrades(ngrades) {
    const ths = /* @__PURE__ */ new Map();
    ths.ngrades = ngrades;
    ths.get = get.bind(ths);
    return ths;
  }
  Scores2.fromGrades = fromGrades;
})(Scores || (Scores = {}));

// src/election/attribution/scoreFactory.ts
function averageScore({ nSeats }) {
  const attrib = (votes, rest = {}) => {
    const counts = new import_collections.DefaultMap(() => []);
    for (const [party, grades] of votes) {
      for (const [grade, qty] of (0, import_python.enumerate)(grades)) {
        counts.get(party).push(...Array(qty).fill(grade));
      }
    }
    return new import_collections.Counter([[(0, import_python.max)(counts.keys(), (party) => (0, import_statistics.fmean)(counts.get(party))), nSeats]]);
  };
  attrib.nSeats = nSeats;
  return attrib;
}
function medianScore({ nSeats, contingency }) {
  if (contingency === void 0) {
    contingency = averageScore({ nSeats });
  }
  const attrib = (votes, rest = {}) => {
    const counts = new import_collections.DefaultMap(() => []);
    for (const [party, grades] of votes) {
      for (const [grade, qty] of (0, import_python.enumerate)(grades)) {
        counts.get(party).push(...Array(qty).fill(grade));
      }
    }
    const medians = new Map([...counts.entries()].map(([party, partigrades]) => [party, (0, import_statistics.median)(partigrades)]));
    const winScore = Math.max(...medians.values());
    const [winner, ...winners] = [...medians.keys()].filter((p) => medians.get(p) === winScore);
    if (winners.length === 0) {
      return new import_collections.Counter([[winner, nSeats]]);
    }
    winners.unshift(winner);
    const trimmedResults = Scores.fromEntries(winners.map((party) => [party, counts.get(party)]));
    return contingency(trimmedResults, rest);
  };
  attrib.nSeats = nSeats;
  return attrib;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  averageScore,
  medianScore
});
//# sourceMappingURL=scoreFactory.cjs.map