@dra2020/district-analytics 4.0.0 → 4.1.0

package/dist/cli.js

@@ -89432,7 +89432,7 @@ function reduceCSplits(CxD, districtTotals) {
         for (let i = 1; i < nD; i++) {
             let split_total = CxDreducedC[i][j];
             if (split_total > 0) {
-                if (areRoughlyEqual(split_total, districtTotals[i - 1])) {
+                if (U.areRoughlyEqual(split_total, districtTotals[i - 1], S.EQUAL_TOLERANCE)) {
                     CxDreducedC[0][j] += split_total;
                     CxDreducedC[i][j] = 0;
                 }
@@ -89455,7 +89455,7 @@ function reduceDSplits(CxD, countyTotals) {
         for (let j = 1; j < nC; j++) {
             let split_total = CxDreducedD[i][j];
             if (split_total > 0) {
-                if (areRoughlyEqual(split_total, countyTotals[j - 1])) {
+                if (U.areRoughlyEqual(split_total, countyTotals[j - 1], S.EQUAL_TOLERANCE)) {
                     CxDreducedD[i][0] += split_total;
                     CxDreducedD[i][j] = 0;
                 }
@@ -89519,13 +89519,6 @@ function calcDistrictFractions(CxD, districtTotals) {
     return g;
 }
 exports.calcDistrictFractions = calcDistrictFractions;
-// Deal with decimal census "counts" due to disagg/re-agg
-function areRoughlyEqual(x, y) {
-    let delta = Math.abs(x - y);
-    let result = (delta < S.EQUAL_TOLERANCE) ? true : false;
-    return result;
-}
-exports.areRoughlyEqual = areRoughlyEqual;
 function splitScore(splits) {
     let e;
     if (splits.length > 0) {
@@ -89800,7 +89793,7 @@ exports.scorePolsbyPopper = scorePolsbyPopper;
 /*! exports provided: partisan, minority, traditionalPrinciples, default */
 /***/ (function(module) {
 
-module.exports = JSON.parse("{\"partisan\":{\"bias\":{\"range\":[0,0.2],\"weight\":[50,80]},\"impact\":{\"weight\":[50,0],\"threshold\":4},\"competitiveness\":{\"overall\":{\"range\":[0,0.67],\"weight\":25},\"marginal\":{\"range\":[0,0.85],\"weight\":75},\"range\":[0.45,0.55],\"distribution\":[0.25,0.75],\"weight\":[0,20]},\"weight\":[100,80]},\"minority\":{\"range\":[0.37,0.5],\"distribution\":[0.25,0.75],\"shift\":0.12,\"bonus\":20},\"traditionalPrinciples\":{\"compactness\":{\"reock\":{\"range\":[0.25,0.5],\"weight\":50},\"polsby\":{\"range\":[0.1,0.5],\"weight\":50},\"weight\":[0,50]},\"splitting\":{\"county\":{\"range\":[1,1.71],\"allowableSplitsMultiplier\":1.5,\"weight\":50},\"district\":{\"range\":[1,1.5],\"weight\":50},\"weight\":[0,50]},\"popdev\":{\"range\":[[0.0075,0.002],[0.1,-1]],\"weight\":[0,0]},\"weight\":[0,20]}}");
+module.exports = JSON.parse("{\"partisan\":{\"bias\":{\"range\":[0,0.2],\"weight\":[50,80]},\"impact\":{\"weight\":[50,0],\"threshold\":4},\"competitiveness\":{\"overall\":{\"range\":[0,0.67],\"weight\":25},\"marginal\":{\"range\":[0,0.85],\"weight\":75},\"range\":[0.45,0.55],\"distribution\":[0.25,0.75],\"weight\":[0,20]},\"bonus\":2,\"weight\":[100,80]},\"minority\":{\"range\":[0.37,0.5],\"distribution\":[0.25,0.75],\"shift\":0.12,\"bonus\":20},\"traditionalPrinciples\":{\"compactness\":{\"reock\":{\"range\":[0.25,0.5],\"weight\":50},\"polsby\":{\"range\":[0.1,0.5],\"weight\":50},\"weight\":[0,50]},\"splitting\":{\"county\":{\"range\":[1,1.71],\"allowableSplitsMultiplier\":1.5,\"weight\":50},\"district\":{\"range\":[1,1.5],\"weight\":50},\"weight\":[0,50]},\"popdev\":{\"range\":[[0.0075,0.002],[0.1,-1]],\"weight\":[0,0]},\"weight\":[0,20]}}");
 
 /***/ }),
 
@@ -89842,6 +89835,11 @@ function impactWeight(context, overridesJSON) {
     return iW;
 }
 exports.impactWeight = impactWeight;
+function winnerBonus(overridesJSON) {
+    const bonus = config_json_1.default.partisan.bonus;
+    return bonus;
+}
+exports.winnerBonus = winnerBonus;
 // The maximum # of unearned seats that scores positively
 function unearnedThreshold(overridesJSON) {
     const threshold = config_json_1.default.partisan.impact.threshold;
@@ -90156,12 +90154,13 @@ function evalMinorityOpportunity(p, bLog = false) {
         }
     }
     // Sum the # of level 1 (37–50%) and level 2 (> 50%) opportunity districts - ignore total minority
-    let l1 = 0;
-    let l2 = 0;
-    bucketsByDemo.slice(1).forEach(function (buckets) {
-        l1 += buckets[0 /* Level1 */];
-        l2 += buckets[1 /* Level2 */];
-    });
+    // let l1: number = 0;
+    // let l2: number = 0;
+    // bucketsByDemo.slice(1).forEach(function (buckets: number[]): void
+    // {
+    //   l1 += buckets[T.OpportunityBucket.Level1];
+    //   l2 += buckets[T.OpportunityBucket.Level2]
+    // });
     // Sum the # of opportunity districts - ignore total minority
     const oD = U.sumArray(opptyByDemo.slice(1));
     // Sum the # of proportion districts - ignore total minority
@@ -90173,8 +90172,8 @@ function evalMinorityOpportunity(p, bLog = false) {
             averageDVf: averageDVf,
             bucketsByDemographic: bucketsByDemo
         },
-        nOpportunity1: l1,
-        nOpportunity2: l2,
+        // nOpportunity1: l1,
+        // nOpportunity2: l2,
         nProportional: pD,
         opportunityDistricts: oD,
         score: score
@@ -90193,17 +90192,22 @@ function calcDistrictsByDemo(MfArray, N) {
     return districtsByDemo;
 }
 exports.calcDistrictsByDemo = calcDistrictsByDemo;
+// NOTE - Shift minority proportions up, so 37% minority scores like 49% share,
+//   but use the uncompressed seat probability distribution. This makes a 37% 
+//   district have a 40% chance of winning, a 42% district have an 84% chance,
+//   and a 50% district have a 99% chance. Below 37% has no chance.
+//
 function estMinorityOpportunity(Mf) {
+    // NOTE - Switch to compress the probability distribution
+    const bCompress = false;
+    const dist = bCompress ? C.minorityOpportunityDistribution() : [0.0, 1.0];
+    const range = C.minorityOpportunityRange();
     const _normalizer = new normalize_1.Normalizer(Mf);
-    // NOTE - Shift proportions, so 37% minority scores like 49% partisan
     const shift = C.minorityShift();
     _normalizer.wipNum += shift;
-    const range = C.minorityOpportunityDistribution();
-    const distBeg = range[C.BEG];
-    const distEnd = range[C.END];
-    _normalizer.clip(distBeg, distEnd);
-    _normalizer.unitize(distBeg, distEnd);
-    const oppty = partisan_1.estSeatProbability(_normalizer.wipNum, range);
+    _normalizer.clip(dist[C.BEG], dist[C.END]);
+    _normalizer.unitize(dist[C.BEG], dist[C.END]);
+    const oppty = (Mf < range[C.BEG]) ? 0.0 : partisan_1.estSeatProbability(_normalizer.wipNum, dist);
     return oppty;
 }
 exports.estMinorityOpportunity = estMinorityOpportunity;
@@ -90350,20 +90354,36 @@ const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts")
 // NOTE - I'm passing T.VfArray's into everything. District indices = array indices.
 // NOTE - I do not (cannot) assume that the values are sorted.
 // SCORE BIAS & COMPETITIVENESS
-/* SCORECARD FIELDS
+/* SCORECARD FIELDS:
 
-* ^S# [bestS] = the Democratic seats closest to proportional
-* ^S% [bestSf] = the corresponding Democratic seat share
+* ^S# [propS] = the Democratic seats closest to proportional
+* ^S% [propSf] = the corresponding Democratic seat share
 * S! [fptpS] = the estimated number of Democratic seats using first past the post
-* S# [probableS] = the estimated Democratic seats, using seat probabilities
-* S% [probableSf] = the estimated Democratic seat share fraction, calculated as S# / N
+* S# [estS] = the estimated Democratic seats, using seat probabilities
+* S% [estSf] = the estimated Democratic seat share fraction, calculated as S# / N
+
+* Bs50 [s50V] = Seat bias as a fraction of N
+* Bv50 [v50S] = Votes bias as a fraction
+* decl [decl] = Declination
+* gSym [gSym] = Global symmetry
+
+* EG [EG] = Efficiency gap as a fraction
+* sVg [BsGf] = Seats bias @ <V> (geometric)
+* prop [prop] = Disproportionality
+* MM [mMs] = Mean – median difference using statewide Vf
+* TO [tOf] = Turnout bias
+* MM' [mMd] = Mean – median difference using average district v
+* LO [LO] = Lopsided outcomes
+
 * B% [bias]= the bias calculated as S% – ^S%
 * B$ [bias.score] = the bias score normalized [0–100]
 
 * UE# [unearnedS] = the number of unearned seats (R = positive; D = negative)
 * I$ [impact.score] -- the unearned seats normalized [0–100] as impact
 
-* R# [r] = the responsiveness at V%
+* R [bigR] = Overall responsiveness
+* r [littleR] = The point responsiveness at V%
+* MIR [MIR] = Minimal inverse responsiveness
 * rD [rD] = the estimated # of responsive districts (using probabilities)
 * rD% [rDf] = the estimated # of responsive districts, as a fraction of N
 
@@ -90379,23 +90399,42 @@ const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts")
 * >P$ [score2] = the combined partisan score used to compare plans *within* a state, along with traditional districting principles
 
 */
-function scorePartisan(Vf, VfArray, bAll = false, bConstrained = true) {
+function scorePartisan(Vf, VfArray, options) {
+    const bAlternateMetrics = options.alternates;
+    const bConstrained = options.constrained;
+    const shift = options.shift;
     const N = VfArray.length;
-    const bestS = bestSeats(N, Vf);
-    const bestSf = bestSeatShare(bestS, N);
-    const fptpS = bAll ? estFPTPSeats(VfArray) : undefined;
+    const propS = propSeats(N, Vf);
+    const propSf = propSeatShare(propS, N);
+    const fptpS = bAlternateMetrics ? estFPTPSeats(VfArray) : undefined;
     const range = bConstrained ? C.competitiveDistribution() : undefined;
-    const probableS = estprobableSeats(VfArray, range);
-    const probableSf = estprobableSeatShare(probableS, N);
-    const bias = estbias(probableSf, bestSf);
-    const biasScore = scorebias(bias, Vf, probableSf, N);
-    const unearnedS = estunearnedSeats(bestS, probableS);
-    const impactScore = scoreImpact(unearnedS);
-    const bInferSV = (bAll || (!bConstrained));
-    const inferredSVpoints = bInferSV ? inferSVpoints(Vf, VfArray, range) : undefined;
-    const R = bInferSV ? estResponsiveness(Vf, inferredSVpoints) : undefined;
-    const rD = bInferSV ? estResponsiveDistricts(VfArray) : undefined;
-    const rDf = bInferSV ? estResponsiveDistrictsShare(rD, N) : undefined;
+    const estS = estSeats(VfArray, range);
+    const estSf = estSeatShare(estS, N);
+    const bias = estBias(estSf, propSf);
+    const biasScore = scorebias(bias, Vf, estSf);
+    const unearnedS = estUnearnedSeats(propS, estS);
+    const impactScore = scoreImpact(unearnedS, Vf, N);
+    // Calculate additional alternate metrics for reference
+    // NOTE - Use the uncompressed seat probability function
+    const inferredSVpoints = bAlternateMetrics ? inferSVpoints(Vf, VfArray, shift) : undefined;
+    const TOf = bAlternateMetrics ? calcTurnoutBias(Vf, VfArray) : undefined;
+    const Bs50 = bAlternateMetrics ? estPartisanBias(inferredSVpoints, N) : undefined;
+    const Bs50f = (!(Bs50 === undefined)) ? U.trim(Bs50 / N) : undefined;
+    const Bv50f = bAlternateMetrics ? estVotesBias(inferredSVpoints, N) : undefined;
+    const decl = bAlternateMetrics ? calcDeclination(VfArray) : undefined;
+    const gSym = bAlternateMetrics ? calcGlobalSymmetry(inferredSVpoints, Bs50f) : undefined;
+    const EG = bAlternateMetrics ? calcEfficiencyGap(Vf, estSf) : undefined;
+    const BsGf = bAlternateMetrics ? estGeometricSeatsBias(Vf, inferredSVpoints) : undefined;
+    const prop = bAlternateMetrics ? calcDisproportionality(Vf, estSf) : undefined;
+    const mMs = bAlternateMetrics ? estMeanMedianDifference(VfArray, Vf) : undefined;
+    const mMd = bAlternateMetrics ? estMeanMedianDifference(VfArray) : undefined;
+    const LO = bAlternateMetrics ? calcLopsidedOutcomes(VfArray) : undefined;
+    // Calculate alternate responsiveness metrics for reference
+    const bigR = bAlternateMetrics ? calcBigR(Vf, estSf) : undefined;
+    const littleR = bAlternateMetrics ? estResponsiveness(Vf, inferredSVpoints) : undefined;
+    const MIR = bAlternateMetrics ? calcMinimalInverseResponsiveness(Vf, littleR) : undefined;
+    const rD = (!bConstrained || bAlternateMetrics) ? estResponsiveDistricts(VfArray) : undefined;
+    const rDf = bAlternateMetrics ? estResponsiveDistrictsShare(rD, N) : undefined;
     const Cn = countCompetitiveDistricts(VfArray);
     const cD = bConstrained ? estCompetitiveDistricts(VfArray) : rD;
     const cDf = estCompetitiveDistrictsShare(cD, N);
@@ -90403,12 +90442,11 @@ function scorePartisan(Vf, VfArray, bAll = false, bConstrained = true) {
     const Md = estMarginalCompetitiveDistricts(Mrange, VfArray);
     const Mdf = estMarginalCompetitiveShare(Md, Mrange);
     const competitivenessScore = scoreCompetitiveness(Mdf, cDf);
-    const biasScoring = {
-        bestS: bestS,
-        bestSf: bestSf,
-        fptpS: fptpS,
-        probableS: probableS,
-        probableSf: probableSf,
+    let biasScoring = {
+        propS: propS,
+        propSf: propSf,
+        estS: estS,
+        estSf: estSf,
         bias: bias,
         score: biasScore
     };
@@ -90417,9 +90455,6 @@ function scorePartisan(Vf, VfArray, bAll = false, bConstrained = true) {
         score: impactScore
     };
     let competitiveScoring = {
-        r: R,
-        rD: rD,
-        rDf: rDf,
         c: Cn,
         cD: cD,
         cDf: cDf,
@@ -90428,8 +90463,22 @@ function scorePartisan(Vf, VfArray, bAll = false, bConstrained = true) {
         mDf: Mdf,
         score: competitivenessScore
     };
-    if (bAll) {
-        competitiveScoring.r = R;
+    if (bAlternateMetrics) {
+        biasScoring.tOf = TOf;
+        biasScoring.fptpS = fptpS;
+        biasScoring.s50V = Bs50f;
+        biasScoring.v50S = Bv50f;
+        biasScoring.decl = decl;
+        biasScoring.gSym = gSym;
+        biasScoring.eG = EG;
+        biasScoring.sVg = BsGf;
+        biasScoring.prop = prop;
+        biasScoring.mMs = mMs;
+        biasScoring.mMd = mMd;
+        biasScoring.lO = LO;
+        competitiveScoring.bigR = bigR;
+        competitiveScoring.littleR = littleR;
+        competitiveScoring.mIR = MIR;
         competitiveScoring.rD = rD;
         competitiveScoring.rDf = rDf;
     }
@@ -90458,35 +90507,49 @@ function weightPartisan(bS, iS, cS, context) {
     return score;
 }
 exports.weightPartisan = weightPartisan;
-function printPartisanScorecardHeader() {
-    console.log('XX, Name, N, 1/N%, V%, ^S#, ^S%, S!, S#, S%, B%, B$, UE#, I$, R#, Rd, Rd%, C#, Cd, Cd%, beg, end, Md, Md%, C$, <P$, >P$');
-}
-exports.printPartisanScorecardHeader = printPartisanScorecardHeader;
-function printPartisanScorecardRow(xx, name, N, Vf, s) {
-    console.log('%s, %s, %i, %f, %f, %i, %f, %i, %f, %f, %f, %i, %f, %i, %f, %f, %f, %i, %f, %f, %i, %i, %f, %f, %i, %i, %i', xx, name, N, U.trim(1 / N), Vf, s.bias.bestS, s.bias.bestSf, s.bias.fptpS, s.bias.probableS, s.bias.probableSf, s.bias.bias, s.bias.score, s.impact.unearnedS, s.impact.score, s.competitiveness.r, s.competitiveness.rD, s.competitiveness.rDf, s.competitiveness.c, s.competitiveness.cD, s.competitiveness.cDf, s.competitiveness.mRange[C.BEG], s.competitiveness.mRange[C.END], s.competitiveness.mD, s.competitiveness.mDf, s.competitiveness.score, s.score, s.score2);
+function extraBonus(Vf) {
+    const okExtra = (0.5 - Vf) * (C.winnerBonus() - 1.0);
+    return U.trim(okExtra);
 }
-exports.printPartisanScorecardRow = printPartisanScorecardRow;
-function scorebias(rawbias, Vf, Sf, N) {
+exports.extraBonus = extraBonus;
+function scorebias(rawBias, Vf, Sf) {
     if (isAntimajoritarian(Vf, Sf)) {
         return 0;
     }
     else {
-        const _normalizer = new normalize_1.Normalizer(rawbias);
+        // Adjust bias to incorporate an acceptable winner's bonus based on Vf
+        const extra = extraBonus(Vf);
+        const adjusted = adjustBias(Vf, rawBias, extra);
+        // Then normalize
+        const _normalizer = new normalize_1.Normalizer(adjusted);
         const worst = C.biasRange()[C.BEG];
         const best = C.biasRange()[C.END];
+        _normalizer.positive();
         _normalizer.clip(worst, best);
         _normalizer.unitize(worst, best);
         _normalizer.invert();
-        // _normalizer.decay();
         _normalizer.rescale();
         const score = _normalizer.normalizedNum;
         return score;
     }
 }
 exports.scorebias = scorebias;
+// Adjust bias to account for a winner's bonus
+function adjustBias(Vf, bias, extra) {
+    if (Vf > 0.5)
+        return Math.min(bias - extra, 0);
+    else
+        return Math.max(bias - extra, 0);
+}
+exports.adjustBias = adjustBias;
 // Normalize unearned seats
-function scoreImpact(rawUE) {
-    const _normalizer = new normalize_1.Normalizer(rawUE);
+function scoreImpact(rawUE, Vf, N) {
+    // Adjust impact to incorporate an acceptable winner's bonus based on Vf
+    const extra = extraBonus(Vf);
+    const adjustedBias = adjustBias(Vf, rawUE / N, extra);
+    const adjustedImpact = adjustedBias * N;
+    // Then normalize
+    const _normalizer = new normalize_1.Normalizer(adjustedImpact);
     const worst = C.unearnedThreshold();
     const best = 0.0;
     _normalizer.positive();
@@ -90538,11 +90601,11 @@ const { erf } = __webpack_require__(/*! mathjs */ "./node_modules/mathjs/main/es
 // Estimate the probability of a seat win for district, given a Vf
 function estSeatProbability(Vf, range) {
     if (range) {
+        // If a range is provided, it defines end points of a compressed probability
+        // distribution. These *aren't* the points where races start or stop being
+        // contested, just the end points of a distribution that yields the desired
+        // probabilities in the typical competitive range [45-55%].
         const _normalizer = new normalize_1.Normalizer(Vf);
-        // The end points of a compressed probability distribution
-        // NOTE - These aren't the points where races start or stop being contested,
-        //   just the end points of a distribution that yields the desired behavior
-        //   in the typical competitive range [45-55%].
         const distBeg = range[C.BEG];
         const distEnd = range[C.END];
         _normalizer.clip(distBeg, distEnd);
@@ -90550,6 +90613,7 @@ function estSeatProbability(Vf, range) {
         return seatProbabilityFn(_normalizer.wipNum);
     }
     else {
+        // Otherwise, use the full probability distribution.
         return seatProbabilityFn(Vf);
     }
 }
@@ -90564,19 +90628,27 @@ function estDistrictResponsiveness(Vf) {
     return U.trim(1.0 - 4.0 * Math.pow((estSeatProbability(Vf) - 0.5), 2));
 }
 exports.estDistrictResponsiveness = estDistrictResponsiveness;
-function inferSVpoints(Vf, VfArray, range) {
+function inferSVpoints(Vf, VfArray, shift, range) {
     const nDistricts = VfArray.length;
     let SVpoints = [];
     for (let shiftedVf of shiftRange()) {
-        const shiftedVPI = shiftDistricts(Vf, VfArray, shiftedVf);
-        const shiftedSf = estprobableSeats(shiftedVPI, range) / nDistricts;
+        const shiftedVPI = shiftDistricts(Vf, VfArray, shiftedVf, shift);
+        const shiftedSf = estSeats(shiftedVPI, range) / nDistricts;
         SVpoints.push({ v: shiftedVf, s: shiftedSf });
+        // TODO - Why can't I trim these? Why does that only break the Hypotheticals?!?
+        // SVpoints.push({v: U.trim(Number(shiftedVf)), s: shiftedSf});
     }
     return SVpoints;
 }
 exports.inferSVpoints = inferSVpoints;
-// Shift districts *proportionally*
-function shiftDistricts(Vf, VfArray, shiftedVf) {
+function shiftDistricts(Vf, VfArray, shiftedVf, shift) {
+    if (shift == 0 /* Proportional */)
+        return shiftProportionally(Vf, VfArray, shiftedVf);
+    else
+        return shiftUniformly(Vf, VfArray, shiftedVf);
+}
+// Shift districts proportionally
+function shiftProportionally(Vf, VfArray, shiftedVf) {
     let shiftedVfArray;
     if (shiftedVf < Vf) {
         // Shift down: D's to R's
@@ -90594,40 +90666,48 @@ function shiftDistricts(Vf, VfArray, shiftedVf) {
     }
     return shiftedVfArray;
 }
-// Generate v's from 0.25 to 0.75 in 0.005 (1/2%) increments
+// Shift districts uniformly
+function shiftUniformly(Vf, VfArray, shiftedVf) {
+    const shift = shiftedVf - Vf;
+    const shiftedVfArray = VfArray.map((v => v + shift));
+    return shiftedVfArray;
+}
+// Generate a range of v's in 1/2% increments
 function shiftRange() {
-    const range = [];
-    const lower = 25 / 100;
-    const upper = 75 / 100;
+    const range = [0.25, 0.75];
+    const axisRange = [];
     const step = (1 / 100) / 2;
-    for (let v = lower; v <= upper + S.EPSILON; v += step) {
-        range.push(v);
+    for (let v = range[0]; v <= range[1] + S.EPSILON; v += step) {
+        axisRange.push(v);
     }
-    return range;
+    return axisRange;
 }
-// ESTIMATE BIAS ("FAIR")
+// ESTIMATE BIAS
+//
+// NOTE: By convention, '+' = R bias; '-' = D bias.
+//
 // ^S# - The # of Democratic seats closest to proportional @ statewide Vf
 // The "expected number of seats" from http://bit.ly/2Fcuf4q
-function bestSeats(N, Vf) {
+function propSeats(N, Vf) {
     return Math.round((N * Vf) - S.EPSILON);
 }
-exports.bestSeats = bestSeats;
+exports.propSeats = propSeats;
 // ^S% - The corresponding Democratic seat share 
-function bestSeatShare(bestS, N) {
+function propSeatShare(bestS, N) {
     return U.trim(bestS / N);
 }
-exports.bestSeatShare = bestSeatShare;
-// S# - The estimated # of Democratic seats @ statewide Vf, using seat probabilities
-function estprobableSeats(VfArray, range) {
+exports.propSeatShare = propSeatShare;
+// S# - The estimated # of Democratic seats, using seat probabilities
+function estSeats(VfArray, range) {
     // Python: sum([est_seat_probability(vpi) for vpi in vpi_by_district])
     return U.trim(U.sumArray(VfArray.map(v => estSeatProbability(v, range))));
 }
-exports.estprobableSeats = estprobableSeats;
-// S% - The estimated Democratic seat share fraction @ statewide Vf
-function estprobableSeatShare(probableS, N) {
-    return U.trim(probableS / N);
+exports.estSeats = estSeats;
+// S% - The estimated Democratic seat share fraction
+function estSeatShare(estS, N) {
+    return U.trim(estS / N);
 }
-exports.estprobableSeatShare = estprobableSeatShare;
+exports.estSeatShare = estSeatShare;
 // F# - The estimated number of Democratic seats using first past the post
 function estFPTPSeats(VfArray) {
     // Python: sum([1.0 for vpi in vpi_by_district if (vpi > 0.5)])
@@ -90641,34 +90721,33 @@ function estFPTPSeats(VfArray) {
     }));
 }
 exports.estFPTPSeats = estFPTPSeats;
-// B% - Tthe bias calculated as S% – ^S%
-function estbias(estSeatShare, bestSeatShare) {
-    return U.trim(Math.abs(estSeatShare - bestSeatShare));
+// B% - The bias calculated as ^S% — S%
+function estBias(estSf, propSf) {
+    return U.trim(propSf - estSf);
 }
-exports.estbias = estbias;
+exports.estBias = estBias;
 // UE# - The estimated # of unearned seats
 // UE_# from http://bit.ly/2Fcuf4q
-function estunearnedSeats(best, probable) {
-    // NOTE - + values = unearned R seats; – values = unearned D seats
-    return U.trim(best - probable);
+function estUnearnedSeats(proportional, probable) {
+    return U.trim(proportional - probable);
 }
-exports.estunearnedSeats = estunearnedSeats;
+exports.estUnearnedSeats = estUnearnedSeats;
 // ESTIMATE RESPONSIVENESS ("COMPETITIVE")
 // R# - Estimate responsiveness at the statewide vote share
 function estResponsiveness(Vf, inferredSVpoints) {
-    // Python:
-    // V1, S1 = lower_bracket(sv_curve_pts, statewide_vote_share, VOTE_SHARE)
-    // V2, S2 = upper_bracket(sv_curve_pts, statewide_vote_share, VOTE_SHARE)
-    // R = ((S2 - S1) / total_seats) / (V2 - V1)
-    // Note - Seat values are already fractions [0.0–1.0] here.
-    const lowerPt = findLowerBracket(Vf, inferredSVpoints);
-    const upperPt = findUpperBracket(Vf, inferredSVpoints);
-    const R = ((upperPt.s - lowerPt.s) / (upperPt.v - lowerPt.v));
-    return U.trim(R);
+    let R = undefined;
+    // NOTE - Seat values are already fractions [0.0–1.0] here.
+    const lowerPt = findBracketingLowerVf(Vf, inferredSVpoints);
+    const upperPt = findBracketingUpperVf(Vf, inferredSVpoints);
+    if (!(U.areRoughlyEqual((upperPt.v - lowerPt.v), 0, S.EPSILON))) {
+        R = ((upperPt.s - lowerPt.s) / (upperPt.v - lowerPt.v));
+        R = U.trim(R);
+    }
+    return R;
 }
 exports.estResponsiveness = estResponsiveness;
 // Find the S(V) point that brackets a Vf value on the lower end
-function findLowerBracket(Vf, inferredSVpoints) {
+function findBracketingLowerVf(Vf, inferredSVpoints) {
     let lowerPt = inferredSVpoints[0];
     let smallerPoints = [];
     for (let pt of inferredSVpoints) {
@@ -90684,7 +90763,7 @@ function findLowerBracket(Vf, inferredSVpoints) {
     return lowerPt;
 }
 // Find the S(V) point that brackets a Vf value on the upper end
-function findUpperBracket(Vf, inferredSVpoints) {
+function findBracketingUpperVf(Vf, inferredSVpoints) {
     let upperPt = inferredSVpoints[-1];
     for (let pt of inferredSVpoints) {
         if (pt.v >= Vf) {
@@ -90695,6 +90774,35 @@ function findUpperBracket(Vf, inferredSVpoints) {
     }
     return upperPt;
 }
+// The corresponding functions via the Sf y-axis (vs. Vf x-axis)
+// Find the S(V) point that brackets a Sf value on the lower end
+function findBracketingLowerSf(Sf, inferredSVpoints) {
+    let lowerPt = inferredSVpoints[0];
+    let smallerPoints = [];
+    for (let pt of inferredSVpoints) {
+        if (pt.s <= Sf) {
+            smallerPoints.push(pt);
+        }
+        else {
+            break;
+        }
+    }
+    // The last smaller point
+    lowerPt = smallerPoints.slice(-1)[0];
+    return lowerPt;
+}
+// Find the S(V) point that brackets a Sf value on the upper end
+function findBracketingUpperSf(Sf, inferredSVpoints) {
+    let upperPt = inferredSVpoints[-1];
+    for (let pt of inferredSVpoints) {
+        if (pt.s >= Sf) {
+            // The first bigger point
+            upperPt = { v: pt.v, s: pt.s };
+            break;
+        }
+    }
+    return upperPt;
+}
 // rD -  Estimate the number of responsive districts, given a set of Vf's
 function estResponsiveDistricts(VfArray) {
     // Python: sum([est_district_responsiveness(vpi) for vpi in vpi_by_district])
@@ -90764,7 +90872,7 @@ function estMarginalCompetitiveShare(Md, Mrange) {
 }
 exports.estMarginalCompetitiveShare = estMarginalCompetitiveShare;
 function findMarginalDistricts(Vf, VfArray, N) {
-    const bestS = bestSeats(N, Vf);
+    const bestS = propSeats(N, Vf);
     const fptpS = estFPTPSeats(VfArray);
     // Find the marginal districts IDs (indexed 1–N)
     let minId;
@@ -90785,6 +90893,328 @@ function findMarginalDistricts(Vf, VfArray, N) {
     return [minId, maxId];
 }
 exports.findMarginalDistricts = findMarginalDistricts;
+// ADVANCED/ALTERNATE METRICS FOR REFERENCE
+function calcTurnoutBias(statewideVf, VfArray) {
+    const districtAvg = U.avgArray(VfArray);
+    const turnoutBias = statewideVf - districtAvg;
+    return U.trim(turnoutBias);
+}
+exports.calcTurnoutBias = calcTurnoutBias;
+// PARTISAN BIAS - I'm using John Nagle's simple seat bias below, which is what
+//    PlanScore is doing:
+//
+//   "Partisan bias is the difference between each party’s seat share and 50 %
+//    in a hypothetical, perfectly tied election.For example, if a party would
+//    win 55 % of a plan’s districts if it received 50 % of the statewide vote,
+//    then the plan would have a bias of 5 % in this party’s favor.To calculate
+//    partisan bias, the observed vote share in each district is shifted by the
+//    amount necessary to simulate a tied statewide election.Each party’s seat
+//    share in this hypothetical election is then determined. The difference
+//    between each party’s seat share and 50 % is partisan bias."
+// 
+//    This is *not* King's & others' geometric partisan bias metric per se.
+//    That is below.
+function estPartisanBias(inferredSVpoints, nDistricts) {
+    return estSeatBias(inferredSVpoints, nDistricts);
+}
+exports.estPartisanBias = estPartisanBias;
+// SEATS BIAS -- John Nagle's simple seat bias @ 50% (alpha), a fractional # of seats.
+function estSeatBias(inferredSVpoints, nDistricts) {
+    const half = 0.5;
+    const tolerance = 0.001;
+    let dSeats = 0;
+    for (let pt of inferredSVpoints) {
+        if (U.areRoughlyEqual(pt.v, half, tolerance)) {
+            dSeats = pt.s * nDistricts;
+            break;
+        }
+    }
+    const rSeats = nDistricts - dSeats;
+    const Bs = (rSeats - dSeats) / 2.0;
+    // NOTE - That is the same as (N/2) - S(0.5).
+    // const BsAlt = (nDistricts / 2.0) - dSeats;
+    return U.trim(Bs);
+}
+exports.estSeatBias = estSeatBias;
+// VOTES BIAS -- John Nagle's simple vote bias @ 50% (alpha2), a percentage.
+function estVotesBias(inferredSVpoints, nDistricts) {
+    let extraVf = 0.0;
+    // Interpolate the extra Vf required @ Sf = 0.5
+    const lowerPt = findBracketingLowerSf(0.5, inferredSVpoints);
+    const upperPt = findBracketingUpperSf(0.5, inferredSVpoints);
+    if ((upperPt.s - lowerPt.s) != 0) {
+        const ratio = (upperPt.v - lowerPt.v) / (upperPt.s - lowerPt.s);
+        const deltaS = 0.5 - lowerPt.s;
+        extraVf = lowerPt.v + (ratio * deltaS) - 0.5;
+    }
+    extraVf = U.trim(extraVf);
+    return extraVf;
+}
+exports.estVotesBias = estVotesBias;
+// GEOMETRIC SEATS BIAS (@ V = statewide vote share)
+function estGeometricSeatsBias(Vf, inferredSVpoints) {
+    const bgsSVpoints = inferGeometricSeatsBiasPoints(inferredSVpoints);
+    // Interpolate the seat fraction @ Vf
+    const lowerPt = findBracketingLowerVf(Vf, bgsSVpoints);
+    const upperPt = findBracketingUpperVf(Vf, bgsSVpoints);
+    const ratio = (upperPt.s - lowerPt.s) / (upperPt.v - lowerPt.v);
+    const deltaV = Vf - lowerPt.v;
+    const deltaS = ratio * deltaV;
+    const BsGf = lowerPt.s + deltaS;
+    return U.trim(BsGf);
+}
+exports.estGeometricSeatsBias = estGeometricSeatsBias;
+function inferGeometricSeatsBiasPoints(inferredSVpoints) {
+    const nPoints = inferredSVpoints.length;
+    const inverseSVpoints = invertSVPoints(inferredSVpoints);
+    let bgsSVpoints = [];
+    for (let i = 0; i < nPoints; i++) {
+        const Vf = inferredSVpoints[i].v;
+        const sD = inferredSVpoints[i].s;
+        const sR = inverseSVpoints[i].s;
+        const BsGf = 0.5 * (sR - sD);
+        bgsSVpoints.push({ v: Vf, s: BsGf });
+    }
+    return bgsSVpoints;
+}
+exports.inferGeometricSeatsBiasPoints = inferGeometricSeatsBiasPoints;
+function invertSVPoints(inferredSVpoints) {
+    let invertedSVpoints = [];
+    for (let pt of inferredSVpoints) {
+        const Vd = pt.v;
+        const Sd = pt.s;
+        const Vr = U.trim(1.0 - Vd);
+        const Sr = 1.0 - Sd;
+        invertedSVpoints.push({ v: Vr, s: Sr });
+    }
+    invertedSVpoints.sort(function (a, b) {
+        return a.v - b.v;
+    });
+    return invertedSVpoints;
+}
+exports.invertSVPoints = invertSVPoints;
+// EFFICIENCY GAP -- note the formulation used. Also, to accommodate turnout bias,
+//   we would need to have D & R votes, not just shares.
+function calcEfficiencyGap(Vf, Sf, shareType = 0 /* Democratic */) {
+    let efficiencyGap;
+    if (shareType == 1 /* Republican */) {
+        // NOTE - This is the  common formulation:
+        //
+        //   EG = (Sf – 0.5)  – (2 × (Vf – 0.5))
+        //
+        //   in which it is implied that '-' = R bias; '+' = D bias.
+        efficiencyGap = U.trim((Sf - 0.5) - (2.0 * (Vf - 0.5)));
+    }
+    else {
+        // NOTE - This is the alternate formulation in which '+' = R bias; '-' = D bias,
+        //   which is consistent with all our other metrics.
+        efficiencyGap = U.trim((2.0 * (Vf - 0.5)) - (Sf - 0.5));
+    }
+    return U.trim(efficiencyGap);
+}
+exports.calcEfficiencyGap = calcEfficiencyGap;
+// MEAN–MEDIAN DIFFERENCE
+// 
+// From PlanScore.org: "The mean-median difference is a party’s median vote share
+//   minus its mean vote share, across all of a plan’s districts. For example, if
+//   a party has a median vote share of 45 % and a mean vote share of 50 %, then
+//   the plan has a mean - median difference of 5 % against this party. When the
+//   mean and the median diverge significantly, the district distribution is skewed
+//   in favor of one party and against its opponent. Conversely, when the mean and
+//   the median are close, the district distribution is more symmetric."
+//
+// From Princeton Gerrymandering Project: "The mean-median difference is calculated
+//   by subtracting the average vote share of either party across all districts from
+//   the median vote share of the same party across all districts. A negative mean - 
+//   median difference indicates that the examined party has an advantage; a positive
+//   difference indicates that the examined party is disadvantaged."
+//
+// So:
+// * With D VPI, '+' = R bias; '-' = D bias <<< We're using this convention.
+// * With R VPI, '-' = R bias; '+' = D bias.
+function estMeanMedianDifference(VfArray, Vf) {
+    const meanVf = Vf ? Vf : U.avgArray(VfArray);
+    const medianVf = U.medianArray(VfArray);
+    // NOTE - Switched order to get the signs correct
+    const difference = meanVf - medianVf;
+    // const difference: number = medianVf - meanVf;
+    return U.trim(difference);
+}
+exports.estMeanMedianDifference = estMeanMedianDifference;
+// HELPERS FOR DECLINATION & LOPSIDED OUTCOMES
+// Key r(v) points, defined in Fig. 19:
+// * VfArray are Democratic seat shares (by convention).
+// * But the x-axis of r(v) graphs us Republican seat share.
+// * So, you have to invert the D/R axis for Vb; and
+// * Invert the D/R probabilities for Va.
+function keyRVpoints(VfArray) {
+    const nDistricts = VfArray.length;
+    const estS = estSeats(VfArray);
+    const Sb = estSeatShare(estS, nDistricts);
+    // TODO - Understand why the corresponding V to Sb is always @ 0.5.
+    //   John Nagle: "This is the dividing vote for party A vs party B wins defined
+    //   by Warrington.My modification just puts fractions of districts to the each side."
+    const Rb = Sb / 2;
+    const Ra = (1 + Sb) / 2;
+    const Vb = 1.0 - (U.sumArray(VfArray.map(v => estSeatProbability(v) * v))) / estS;
+    const Va = (U.sumArray(VfArray.map(v => estSeatProbability(1 - v) * (1 - v)))) / (nDistricts - estS);
+    const keyPoints = {
+        Sb: Sb,
+        Ra: Ra,
+        Rb: Rb,
+        Va: Va,
+        Vb: Vb
+    };
+    return keyPoints;
+}
+exports.keyRVpoints = keyRVpoints;
+function isASweep(Sf, nDistricts) {
+    const oneDistrict = 1 / nDistricts;
+    const bSweep = ((Sf > (1 - oneDistrict)) || (Sf < oneDistrict)) ? true : false;
+    return bSweep;
+}
+exports.isASweep = isASweep;
+function radiansToDegrees(radians) {
+    const degrees = radians * (180 / Math.PI);
+    return degrees;
+}
+exports.radiansToDegrees = radiansToDegrees;
+// DECLINATION
+// 
+// Declination is calculated using the key r(v) points, defined in Fig. 19.
+// Note that district vote shares are D shares, so party A = Rep & B = Dem.
+function calcDeclination(VfArray) {
+    const { Sb, Ra, Rb, Va, Vb } = keyRVpoints(VfArray);
+    const bSweep = isASweep(Sb, VfArray.length);
+    const bTooFewDistricts = (VfArray.length < 5) ? true : false;
+    const bVaAt50 = (U.areRoughlyEqual((Va - 0.5), 0.0, S.EPSILON)) ? true : false;
+    const bVbAt50 = (U.areRoughlyEqual((0.5 - Vb), 0.0, S.EPSILON)) ? true : false;
+    let decl;
+    if (bSweep || bTooFewDistricts || bVaAt50 || bVbAt50) {
+        decl = undefined;
+    }
+    else {
+        const lTan = (Sb - Rb) / (0.5 - Vb);
+        const rTan = (Ra - Sb) / (Va - 0.5);
+        const lAngle = radiansToDegrees(Math.atan(lTan));
+        const rAngle = radiansToDegrees(Math.atan(rTan));
+        decl = rAngle - lAngle;
+        decl = U.trim(decl);
+    }
+    return decl;
+}
+exports.calcDeclination = calcDeclination;
+// LOPSIDED OUTCOMES
+//
+// This is a measure of packing bias is:
+//
+//   LO = (1⁄2 - vB) - (vA – 1⁄2)     Eq. 5.4.1 on P. 26
+//
+// "The ideal for this measure is that the excess vote share for districts
+//  won by party A averaged over those districts equals the excess vote share
+//  for districts won by party B averaged over those districts.
+//  A positive value of LO indicates greater packing of party B voters and,
+//  therefore, indicates a bias in favor of party A."
+function calcLopsidedOutcomes(VfArray) {
+    const { Sb, Ra, Rb, Va, Vb } = keyRVpoints(VfArray);
+    const bSweep = isASweep(Sb, VfArray.length);
+    let LO;
+    if (bSweep) {
+        LO = undefined;
+    }
+    else {
+        LO = (0.5 - Vb) - (Va - 0.5);
+        LO = U.trim(LO);
+    }
+    return LO;
+}
+exports.calcLopsidedOutcomes = calcLopsidedOutcomes;
+// TODO - Add unit tests <<< Depends on S(V)
+// GLOBAL SYMMETRY - Fig. 17 in Section 5.1
+function calcGlobalSymmetry(inferredSVpoints, S50V) {
+    const invertedSVpoints = invertSVPoints(inferredSVpoints);
+    let gSym = 0.0;
+    for (let i in inferredSVpoints) {
+        gSym += Math.abs(inferredSVpoints[i].s - invertedSVpoints[i].s) / 2;
+    }
+    const sign = (S50V < 0) ? -1 : 1;
+    gSym *= sign;
+    return U.trim(gSym);
+}
+exports.calcGlobalSymmetry = calcGlobalSymmetry;
+// RAW DISPROPORTIONALITY
+//
+// gamma = Sf – Vf     : Eq.C.1.1 on P. 42
+function calcDisproportionality(Vf, Sf) {
+    const gamma = Vf - Sf;
+    // const gamma = Sf - Vf;
+    return U.trim(gamma);
+}
+exports.calcDisproportionality = calcDisproportionality;
+// TODO - Add unit tests <<< Depends on S(V)
+// BIG 'R': Defined in Footnote 22 on P. 10
+function calcBigR(Vf, Sf) {
+    let bigR = undefined;
+    if (!(U.areRoughlyEqual(Vf, 0.5, S.EPSILON))) {
+        bigR = (Sf - 0.5) / (Vf - 0.5);
+        bigR = U.trim(bigR);
+    }
+    return bigR;
+}
+exports.calcBigR = calcBigR;
+// TODO - Add unit tests <<< Depends on S(V)
+// MINIMAL INVERSE RESPONSIVENESS
+//
+// zeta = (1 / r) - (1 / r_sub_max)     : Eq. 5.2.1
+//
+// where r_sub_max = 10 or 20 for balanced and unbalanced states, respectively.
+function calcMinimalInverseResponsiveness(Vf, r) {
+    let MIR = undefined;
+    if (!(U.areRoughlyEqual(r, 0, S.EPSILON))) {
+        const bBalanced = isBalanced(Vf);
+        const ideal = bBalanced ? 0.1 : 0.2;
+        MIR = (1 / r) - ideal;
+        MIR = U.trim(MIR);
+    }
+    return MIR;
+}
+exports.calcMinimalInverseResponsiveness = calcMinimalInverseResponsiveness;
+function isBalanced(Vf) {
+    const [lower, upper] = C.competitiveRange();
+    const bBalanced = ((Vf > upper) || (Vf < lower)) ? false : true;
+    return bBalanced;
+}
+// HELPERS
+function printPartisanScorecardHeader() {
+    console.log('XX, Name, N, V%, ^S#, S#, B%, B$, UE#, I$, C#, Cd, Md, C$, <P$');
+}
+exports.printPartisanScorecardHeader = printPartisanScorecardHeader;
+function printPartisanScorecardRow(xx, name, N, Vf, s) {
+    console.log('%s, %s, %i, %f, %i, %f, %f, %i, %f, %i, %i, %f, %f, %i, %i', xx, // 1
+    name, // 2
+    N, // 3
+    Vf, // 4
+    s.bias.propS, // 5
+    s.bias.estS, // 6
+    s.bias.bias, // 7
+    s.bias.score, s.impact.unearnedS, // 9
+    s.impact.score, s.competitiveness.c, // 11
+    s.competitiveness.cD, s.competitiveness.mD, s.competitiveness.score, s.score // 15
+    );
+}
+exports.printPartisanScorecardRow = printPartisanScorecardRow;
+// Generate partisan details (Table 1)
+function printPartisanDetailsHeader() {
+    console.log('XX, <V>, S(<V>), S50V, V50S, Decl, B_G, EG, Beta, l-gamma, mM, TO, mM\', LO, R, r, Zeta');
+}
+exports.printPartisanDetailsHeader = printPartisanDetailsHeader;
+function printPartisanDetailsRow(xx, name, N, Vf, s) {
+    console.log('%s, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f', xx, Vf, s.bias.estSf, s.bias.s50V, s.bias.v50S, s.bias.decl, s.bias.gSym, s.bias.eG, s.bias.sVg, // Beta
+    s.bias.prop, // Lower-gamma
+    s.bias.mMs, s.bias.tOf, s.bias.mMd, s.bias.lO, s.competitiveness.bigR, s.competitiveness.littleR, s.competitiveness.mIR // Zeta
+    );
+}
+exports.printPartisanDetailsRow = printPartisanDetailsRow;
 
 
 /***/ }),
@@ -90809,7 +91239,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
 const S = __importStar(__webpack_require__(/*! ./settings */ "./src/settings.ts"));
 const C = __importStar(__webpack_require__(/*! ./config */ "./src/config.ts"));
 const compact_1 = __webpack_require__(/*! ./compact */ "./src/compact.ts");
@@ -90852,7 +91281,12 @@ function scorePlan(p, overridesJSON) {
         populationDeviation: pdS
     };
     // PARTISAN ("fair") subcategories - bias, impact, & competitiveness (plus lots of supporting measures)
-    const pS = partisan_1.scorePartisan(p.partisanProfile.statewideVf, p.partisanProfile.vfArray);
+    const options = {
+        alternates: true,
+        constrained: true,
+        shift: 0 /* Proportional */
+    };
+    const pS = partisan_1.scorePartisan(p.partisanProfile.statewideVf, p.partisanProfile.vfArray, options);
     // Combine the partisan/partisan & traditional principles/best scores into an overall
     // score for comparing plans w/in a state
     let score = weightOverall(pS.score2, tpS.score, 1 /* WithinAState */);
@@ -90905,11 +91339,26 @@ function mixinMinorityBonus(score, minorityBonus) {
 }
 exports.mixinMinorityBonus = mixinMinorityBonus;
 function printScorecardHeader() {
-    console.log('XX, Name, N, V%, ^S#, S#, B%, B$, UE#, I$, C#, Cd, Md, C$, <P$, >P$, Rc, Rc$, Pc, Pc$, G$, Cs, Cs$, Ds, Ds$, S$, Eq, Eq$, T$, O1, O2, Od, Pd, M$, $$$');
+    console.log('XX, Name, N, V%, ^S#, S#, B%, B$, UE#, I$, C#, Cd, Md, C$, >P$, Rc, Rc$, Pc, Pc$, G$, Cs, Cs$, Ds, Ds$, S$, Eq, Eq$, T$, Od, M$, $$$');
 }
 exports.printScorecardHeader = printScorecardHeader;
 function printScorecardRow(xx, name, N, Vf, s) {
-    console.log('%s, %s, %i, %f, %i, %f, %f, %i, %f, %i, %i, %f, %f, %i, %i, %i, %f, %i, %f, %i, %i, %f, %i, %f, %i, %i, %f, %i, %i, %i, %i, %f, %i, %i, %i', xx, name, N, U.trim(Vf), s.partisan.bias.bestS, s.partisan.bias.probableS, s.partisan.bias.bias, s.partisan.bias.score, s.partisan.impact.unearnedS, s.partisan.impact.score, s.partisan.competitiveness.c, s.partisan.competitiveness.cD, s.partisan.competitiveness.mD, s.partisan.competitiveness.score, s.partisan.score, s.partisan.score2, s.traditionalPrinciples.compactness.reock.raw, s.traditionalPrinciples.compactness.reock.normalized, s.traditionalPrinciples.compactness.polsby.raw, s.traditionalPrinciples.compactness.polsby.normalized, s.traditionalPrinciples.compactness.score, s.traditionalPrinciples.splitting.county.raw, s.traditionalPrinciples.splitting.county.normalized, s.traditionalPrinciples.splitting.district.raw, s.traditionalPrinciples.splitting.district.normalized, s.traditionalPrinciples.splitting.score, s.traditionalPrinciples.populationDeviation.raw, s.traditionalPrinciples.populationDeviation.normalized, s.traditionalPrinciples.score, s.minority.nOpportunity1, s.minority.nOpportunity2, s.minority.opportunityDistricts, s.minority.nProportional, s.minority.score, s.score);
+    console.log('%s, %s, %i, %f, %i, %f, %f, %i, %f, %i, %i, %f, %f, %i, %i, %f, %i, %f, %i, %i, %f, %i, %f, %i, %i, %f, %i, %i, %f, %i, %i', xx, // 1
+    name, // 2
+    N, // 3
+    Vf, // 4
+    s.partisan.bias.propS, // 5
+    s.partisan.bias.estS, // 6
+    s.partisan.bias.bias, // 7
+    s.partisan.bias.score, s.partisan.impact.unearnedS, // 9
+    s.partisan.impact.score, s.partisan.competitiveness.c, // 11
+    s.partisan.competitiveness.cD, s.partisan.competitiveness.mD, s.partisan.competitiveness.score, s.partisan.score2, // 15
+    s.traditionalPrinciples.compactness.reock.raw, s.traditionalPrinciples.compactness.reock.normalized, s.traditionalPrinciples.compactness.polsby.raw, s.traditionalPrinciples.compactness.polsby.normalized, s.traditionalPrinciples.compactness.score, s.traditionalPrinciples.splitting.county.raw, s.traditionalPrinciples.splitting.county.normalized, s.traditionalPrinciples.splitting.district.raw, s.traditionalPrinciples.splitting.district.normalized, s.traditionalPrinciples.splitting.score, s.traditionalPrinciples.populationDeviation.raw, s.traditionalPrinciples.populationDeviation.normalized, s.traditionalPrinciples.score, 
+    // s.minority.nOpportunity1,
+    // s.minority.nOpportunity2,
+    s.minority.opportunityDistricts, 
+    // s.minority.nProportional,
+    s.minority.score, s.score);
 }
 exports.printScorecardRow = printScorecardRow;
 
@@ -90966,6 +91415,66 @@ const sample_profile_json_1 = __importDefault(__webpack_require__(/*! ../testdat
 exports.sampleProfile = sample_profile_json_1.default;
 const sample_scorecard_json_1 = __importDefault(__webpack_require__(/*! ../testdata/samples/sample-scorecard.json */ "./testdata/samples/sample-scorecard.json"));
 exports.sampleScorecard = sample_scorecard_json_1.default;
+exports.Metrics = {
+    // PARTISAN
+    // Bias metrics
+    Vf: { label: "Statewide D vote share", abbr: "V" },
+    estS: { label: "Probable D seats", abbr: "S_V" },
+    estSf: { label: "Probable D seat share", units: 1 /* Percentage */, abbr: "S%" },
+    propS: { label: "D seats closest to proportional", abbr: "^S" },
+    propSf: { label: "D seat share closest to proportional", units: 1 /* Percentage */, abbr: "^S%" },
+    fptpS: { label: "Probable FPTP D seats", abbr: "S!" },
+    bias: { label: "Effective bias", units: 1 /* Percentage */, abbr: "B%", description: "Calculated as S% – ^S%" },
+    biasScore: { label: "Bias score", abbr: "B$", description: "Bias score normalized [0–100]" },
+    // Additional bias metrics
+    s50v: { label: "Seats bias", units: 1 /* Percentage */, abbr: "BS_50", symbol: "\u{03B1}" },
+    v50s: { label: "Votes bias", units: 1 /* Percentage */, abbr: "BV_50", symbol: "\u{03B1}2" },
+    decl: { label: "Declination", units: 2 /* Degrees */, abbr: "decl", symbol: "\u{03B4}" },
+    gSym: { label: "Global symmetry", abbr: "GS", symbol: "\u{0393}" },
+    EG: { label: "Efficiency gap", units: 1 /* Percentage */, abbr: "EG", symbol: "\u{03B3}2" },
+    BsGf: { label: "Partisan bias", units: 1 /* Percentage */, abbr: "BS_V", symbol: "\u{03D0}" },
+    prop: { label: "Disproprtionality", units: 1 /* Percentage */, abbr: "prop", symbol: "\u{03B3}" },
+    MM: { label: "Mean–median", abbr: "MM" },
+    LO: { label: "Lopsided outcomes", abbr: "LO" },
+    // Impact metrics
+    unearnedS: { label: "Unearned seats", abbr: "UE" },
+    impactScore: { label: "Impact score", abbr: "I$", description: "Impact score normalized to [0–100]" },
+    // Competitiveness/responsiveness metrics
+    c: { label: "Simple competitive districts", abbr: "C", description: "Count of districts in the range [45–55%]" },
+    cD: { label: "Probable competitive districts", abbr: "Cd", description: "Probable competitive districts, using probabilities" },
+    cDf: { label: "Probable competitive districts share", units: 1 /* Percentage */, abbr: "Cdf" },
+    mD: { label: "Competitive marginal districts", abbr: "Md", description: "Probable competitive marginal districts, using probabilities" },
+    mDf: { label: "Competitive marginal districts share", units: 1 /* Percentage */, abbr: "Mdf" },
+    competitivenessScore: { label: "Competitiveness score", abbr: "C$", description: "Competitiveness score normalized to [0–100]" },
+    // Additional competitiveness/responsiveness metrics
+    rD: { label: "Responsive districts", abbr: "Rd" },
+    rDf: { label: "Responsive districts %", abbr: "Rd%" },
+    bigR: { label: "Overall responsiveness", abbr: "R" /*, symbol: "\u{}" */ },
+    littleR: { label: "Point responsiveness", abbr: "r", symbol: "\u{03C1}" },
+    MIR: { label: "Minimal inverse responsiveness", abbr: "MIR", symbol: "\u{03B6}" },
+    partisanScore: { label: "Partisan score", abbr: "P$" },
+    // * <P$ [score] = the combined partisan score used to compare plans *across* states
+    // * >P$ [score2] = the combined partisan score used to compare plans *within* a state, along with traditional districting principles
+    // MINORITY
+    oD: { label: "Opportunity districts", abbr: "Od" },
+    minorityBonus: { label: "Minority bonus", abbr: "M$" },
+    // TRADITIONAL DISTRICTING PRINCIPLES
+    reockRaw: { label: "Reock", abbr: "Rc" },
+    reockNormalized: { label: "Reock", abbr: "Rc$", description: "Reock normalized to [0–100]" },
+    polsbyRaw: { label: "Polsby-Popper", abbr: "Pc" },
+    polsbyNormalized: { label: "Polsby-Popper", abbr: "Pc$", description: "Polsby-Popper normalized to [0–100]" },
+    compactnessScore: { label: "Compactness score", abbr: "G$" },
+    countySplittingRaw: { label: "County splitting", abbr: "Cs" },
+    countySplittingNormalized: { label: "County splitting", abbr: "Cs$", description: "County splitting normalized to [0–100]" },
+    districtSplittingRaw: { label: "District splitting", abbr: "Ds" },
+    districtSplittingNormalized: { label: "District splitting", abbr: "Ds$", description: "District splitting normalized to [0–100]" },
+    splittingScore: { label: "Splitting score", abbr: "S$" },
+    populationDeviationRaw: { label: "Population deviation", abbr: "Eq" },
+    populationDeviationNormalized: { label: "County splitting", abbr: "Eq$", description: "Population deviation normalized to [0–100]" },
+    traditionalPrinciplesScore: { label: "Traditional districting principles score", abbr: "T$", description: "Traditional principles score normalized to [0–100]" },
+    // OVERALL SCORE
+    score: { label: "Overall score", abbr: "$$$" }
+};
 
 
 /***/ }),
@@ -91008,11 +91517,31 @@ function maxArray(arr) {
     return Math.max(...arr);
 }
 exports.maxArray = maxArray;
+// Modified from https://jsfiddle.net/Lucky500/3sy5au0c/
+function medianArray(arr) {
+    if (arr.length === 0)
+        return 0;
+    arr.sort(function (a, b) {
+        return a - b;
+    });
+    var half = Math.floor(arr.length / 2);
+    if (arr.length % 2)
+        return arr[half];
+    return (arr[half - 1] + arr[half]) / 2.0;
+}
+exports.medianArray = medianArray;
 function initArray(n, value) {
     return Array.from(Array(n), () => value);
 }
 exports.initArray = initArray;
 // MISCELLANEOUS
+// Deal with decimal census "counts" due to disagg/re-agg
+function areRoughlyEqual(x, y, tolerance) {
+    let delta = Math.abs(x - y);
+    let result = (delta < tolerance) ? true : false;
+    return result;
+}
+exports.areRoughlyEqual = areRoughlyEqual;
 // Round a fractional number [0-1] to the desired level of PRECISION.
 function trim(fullFraction, digits = undefined) {
     if (digits == 0) {
@@ -91064,7 +91593,7 @@ module.exports = JSON.parse("{\"state\":\"NC\",\"planName\":\"NC 116th Congressi
 /*! exports provided: score, partisan, minority, traditionalPrinciples, default */
 /***/ (function(module) {
 
-module.exports = JSON.parse("{\"score\":5,\"partisan\":{\"bias\":{\"bestS\":7,\"bestSf\":0.5385,\"probableS\":4.1925,\"probableSf\":0.3225,\"bias\":0.216,\"score\":0},\"impact\":{\"unearnedS\":2.8075,\"score\":0},\"competitiveness\":{\"c\":6,\"cD\":0.7266,\"cDf\":0.0559,\"mRange\":[5,11],\"mD\":0.7134,\"mDf\":0.1019,\"score\":10},\"score\":3,\"score2\":2},\"minority\":{\"report\":{\"bucketsByDemographic\":[[10,14],[3,0],[1,9],[0,0],[0,0],[0,0]],\"averageDVf\":0.6737588682747838},\"nOpportunity1\":4,\"nOpportunity2\":9,\"nProportional\":18,\"opportunityDistricts\":12.9424,\"score\":14},\"traditionalPrinciples\":{\"score\":18,\"compactness\":{\"score\":35,\"reock\":{\"raw\":0.3373,\"normalized\":35,\"notes\":{}},\"polsby\":{\"raw\":0.2418,\"normalized\":35,\"notes\":{}}},\"splitting\":{\"score\":0,\"county\":{\"raw\":1.1474,\"normalized\":0,\"notes\":{}},\"district\":{\"raw\":1.4839,\"normalized\":3,\"notes\":{}}},\"populationDeviation\":{\"raw\":0.016,\"normalized\":0,\"notes\":{\"maxDeviation\":11693}}}}");
+module.exports = JSON.parse("{\"score\":5,\"partisan\":{\"bias\":{\"propS\":7,\"propSf\":0.5385,\"estS\":4.1925,\"estSf\":0.3225,\"bias\":0.216,\"tOf\":-0.0023,\"fptpS\":3,\"s50V\":0.2172,\"v50S\":0.045,\"decl\":36.5164,\"gSym\":6.6602,\"eG\":0.2846,\"sVg\":0.2098,\"prop\":0.2695,\"mMd\":0.0593,\"mMs\":0.057,\"lO\":0.1106,\"score\":0},\"impact\":{\"unearnedS\":2.8075,\"score\":0},\"competitiveness\":{\"bigR\":-16.926,\"littleR\":4.3523,\"mIR\":0.1298,\"rD\":4.0207,\"rDf\":0.3093,\"c\":6,\"cD\":0.7266,\"cDf\":0.0559,\"mRange\":[5,11],\"mD\":0.7134,\"mDf\":0.1019,\"score\":10},\"score\":3,\"score2\":2},\"minority\":{\"report\":{\"bucketsByDemographic\":[[10,14],[3,0],[1,9],[0,0],[0,0],[0,0]],\"averageDVf\":0.6737588682747838},\"nProportional\":18,\"opportunityDistricts\":12.9424,\"score\":14},\"traditionalPrinciples\":{\"score\":18,\"compactness\":{\"score\":35,\"reock\":{\"raw\":0.3373,\"normalized\":35,\"notes\":{}},\"polsby\":{\"raw\":0.2418,\"normalized\":35,\"notes\":{}}},\"splitting\":{\"score\":0,\"county\":{\"raw\":1.1474,\"normalized\":0,\"notes\":{}},\"district\":{\"raw\":1.4839,\"normalized\":3,\"notes\":{}}},\"populationDeviation\":{\"raw\":0.016,\"normalized\":0,\"notes\":{\"maxDeviation\":11693}}}}");
 
 /***/ })