@dra2020/district-analytics 6.2.0 → 7.0.0

package/dist/cli.js

@@ -89099,10 +89099,10 @@ exports.scorePolsbyPopper = scorePolsbyPopper;
 /*!*************************!*\
   !*** ./src/config.json ***!
   \*************************/
-/*! exports provided: partisan, minority, traditionalPrinciples, default */
+/*! exports provided: partisan, minority, compactness, splitting, popdev, default */
 /***/ (function(module) {
 
-module.exports = JSON.parse("{\"partisan\":{\"bias\":{\"range\":[0,0.2],\"weight\":[50,80]},\"impact\":{\"weight\":[50,0],\"threshold\":4},\"competitiveness\":{\"range\":[0,0.75],\"distribution\":[0.25,0.75],\"simpleRange\":[0.45,0.55],\"weight\":[0,20]},\"bonus\":2,\"weight\":[100,80]},\"minority\":{\"range\":[0.37,0.5],\"distribution\":[0.25,0.75],\"shift\":0.15,\"coalition\":{\"weight\":0.5},\"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.26,1.68],[1.09,1.45]],\"weight\":50},\"district\":{\"range\":[[1.26,1.68],[1.09,1.45]],\"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\":{\"range\":[0,0.75],\"distribution\":[0.25,0.75],\"simpleRange\":[0.45,0.55],\"weight\":[0,20]},\"bonus\":2},\"minority\":{\"range\":[0.37,0.5],\"distribution\":[0.25,0.75],\"shift\":0.15,\"coalition\":{\"weight\":0.5}},\"compactness\":{\"reock\":{\"range\":[0.25,0.5],\"weight\":50},\"polsby\":{\"range\":[0.1,0.5],\"weight\":50}},\"splitting\":{\"county\":{\"range\":[[1.26,1.68],[1.09,1.45]],\"weight\":50},\"district\":{\"range\":[[1.26,1.68],[1.09,1.45]],\"weight\":50}},\"popdev\":{\"range\":[[0.0075,0.002],[0.1,-1]]}}");
 
 /***/ }),
 
@@ -89118,7 +89118,8 @@ module.exports = JSON.parse("{\"partisan\":{\"bias\":{\"range\":[0,0.2],\"weight
 //
 // THRESHOLDS, SCALES, AND WEIGHTS FOR SCORING MODEL
 //
-// * A layer of functions over config.json, so that they can be overridden dynamically (TODO)
+// * A layer of functions over config.json, so that they could be overridden dynamically.
+//   That is not implemented yet.
 //
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -89160,7 +89161,7 @@ function competitivenessWeight(context, overridesJSON) {
     return cW;
 }
 exports.competitivenessWeight = competitivenessWeight;
-// COMPETITIVENESS - The simple user-facing range, i.e., 45–55%.
+// The simple user-facing range, i.e., 45–55%.
 function competitiveRange(overridesJSON) {
     const range = config_json_1.default.partisan.competitiveness.simpleRange;
     return range;
@@ -89171,9 +89172,9 @@ function competitiveDistribution(overridesJSON) {
     return dist;
 }
 exports.competitiveDistribution = competitiveDistribution;
-// COMPETITIVENESS - The more complex internal range for normalizing Cdf.
-// COMPETITIVENESS - 06/23/2020 - As part of relaxing the competitive range, I
-//   I changed this max from 0.67 to 0.75.
+// The more complex internal range for normalizing Cdf.
+// * 06/23/2020 - As part of relaxing the competitive range, I changed this max
+//   from 0.67 to 0.75.
 function overallCompetitivenessRange(overridesJSON) {
     const range = config_json_1.default.partisan.competitiveness.range;
     return range;
@@ -89181,17 +89182,17 @@ function overallCompetitivenessRange(overridesJSON) {
 exports.overallCompetitivenessRange = overallCompetitivenessRange;
 // export function marginalCompetitivenessRange(overridesJSON?: any): number[]
 // {
-//   const range = config.partisan.competitiveness.marginal.range;
+//   const range = config.partisan.responsiveness.marginal.range;
 //   return range;
 // }
 // export function marginalCompetitivenessWeight(overridesJSON?: any): number
 // {
-//   const mcW = config.partisan.competitiveness.marginal.weight;
+//   const mcW = config.partisan.responsiveness.marginal.weight;
 //   return mcW;
 // }
 // export function overallCompetitivenessWeight(overridesJSON?: any): number
 // {
-//   const ocW = config.partisan.competitiveness.overall.weight;
+//   const ocW = config.partisan.responsiveness.overall.weight;
 //   return ocW;
 // }
 // MINORITY
@@ -89215,74 +89216,55 @@ function coalitionDistrictWeight(overridesJSON) {
     return weight;
 }
 exports.coalitionDistrictWeight = coalitionDistrictWeight;
-function minorityBonus(overridesJSON) {
-    const bonus = config_json_1.default.minority.bonus;
-    return bonus;
-}
-exports.minorityBonus = minorityBonus;
-// TRADITIONAL DISTRICTING PRINCIPLES
-function compactnessWeight(context, overridesJSON) {
-    const cW = config_json_1.default.traditionalPrinciples.compactness.weight[context];
-    return cW;
-}
-exports.compactnessWeight = compactnessWeight;
+// COMPACTNESS
 function reockWeight(overridesJSON) {
-    const rW = config_json_1.default.traditionalPrinciples.compactness.reock.weight;
+    const rW = config_json_1.default.compactness.reock.weight;
     return rW;
 }
 exports.reockWeight = reockWeight;
 function reockRange(overridesJSON) {
-    const range = config_json_1.default.traditionalPrinciples.compactness.reock.range;
+    const range = config_json_1.default.compactness.reock.range;
     return range;
 }
 exports.reockRange = reockRange;
 function polsbyWeight(overridesJSON) {
-    const ppW = config_json_1.default.traditionalPrinciples.compactness.polsby.weight;
+    const ppW = config_json_1.default.compactness.polsby.weight;
     return ppW;
 }
 exports.polsbyWeight = polsbyWeight;
 function polsbyRange(overridesJSON) {
-    const range = config_json_1.default.traditionalPrinciples.compactness.polsby.range;
+    const range = config_json_1.default.compactness.polsby.range;
     return range;
 }
 exports.polsbyRange = polsbyRange;
-function splittingWeight(context, overridesJSON) {
-    const sW = config_json_1.default.traditionalPrinciples.splitting.weight[context];
-    return sW;
-}
-exports.splittingWeight = splittingWeight;
+// SPLITTING
 function countySplittingWeight(overridesJSON) {
-    const csW = config_json_1.default.traditionalPrinciples.splitting.county.weight;
+    const csW = config_json_1.default.splitting.county.weight;
     return csW;
 }
 exports.countySplittingWeight = countySplittingWeight;
 function countySplittingRange(d, overridesJSON) {
-    const range = config_json_1.default.traditionalPrinciples.splitting.county.range[d];
+    const range = config_json_1.default.splitting.county.range[d];
     return range;
 }
 exports.countySplittingRange = countySplittingRange;
 function districtSplittingWeight(overridesJSON) {
-    const dsW = config_json_1.default.traditionalPrinciples.splitting.district.weight;
+    const dsW = config_json_1.default.splitting.district.weight;
     return dsW;
 }
 exports.districtSplittingWeight = districtSplittingWeight;
 function districtSplittingRange(d, overridesJSON) {
-    const range = config_json_1.default.traditionalPrinciples.splitting.district.range[d];
+    const range = config_json_1.default.splitting.district.range[d];
     return range;
 }
 exports.districtSplittingRange = districtSplittingRange;
-function popdevWeight(context, overridesJSON) {
-    const pdW = config_json_1.default.traditionalPrinciples.popdev.weight[context];
-    return pdW;
-}
-exports.popdevWeight = popdevWeight;
 // NOTE - Raw ranges, not inverted (i.e., smaller is better)
 // NOTE - This could be optimized to not calc LD values for CD's (or do it once)
 function popdevRange(bLegislative, overridesJSON) {
-    const cdRange = config_json_1.default.traditionalPrinciples.popdev.range[0 /* Congressional */];
+    const cdRange = config_json_1.default.popdev.range[0 /* Congressional */];
     const worstCD = cdRange[exports.BEG];
     const bestCD = cdRange[exports.END];
-    const ldRange = config_json_1.default.traditionalPrinciples.popdev.range[1 /* StateLegislative */];
+    const ldRange = config_json_1.default.popdev.range[1 /* StateLegislative */];
     const iRange = bLegislative ? ldRange : cdRange;
     const worst = iRange[exports.BEG];
     const best = bLegislative ? (bestCD / worstCD) * iRange[exports.BEG] : iRange[exports.END];
@@ -89296,17 +89278,6 @@ function popdevThreshold(bLegislative, overridesJSON) {
     return threshold;
 }
 exports.popdevThreshold = popdevThreshold;
-// OVERALL SCORE 
-function partisanWeight(context, overridesJSON) {
-    const pW = config_json_1.default.partisan.weight[context];
-    return pW;
-}
-exports.partisanWeight = partisanWeight;
-function traditionalPrinciplesWeight(context, overridesJSON) {
-    const tpW = config_json_1.default.traditionalPrinciples.weight[context];
-    return tpW;
-}
-exports.traditionalPrinciplesWeight = traditionalPrinciplesWeight;
 
 
 /***/ }),
@@ -89431,18 +89402,12 @@ const C = __importStar(__webpack_require__(/*! ./config */ "./src/config.ts"));
 const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts");
 const partisan_1 = __webpack_require__(/*! ./partisan */ "./src/partisan.ts");
 function evalMinorityOpportunity(p, bLog = false) {
-    // Calculate average Democratic win share
-    const VfArray = p.partisanProfile.vfArray;
-    const DWins = VfArray.filter(x => x > 0.5);
-    const RWins = VfArray.filter(x => x <= 0.5); // Ties credited to R's
-    const averageDVf = (DWins.length > 0) ? U.avgArray(DWins) : undefined;
-    const averageRVf = (RWins.length > 0) ? U.avgArray(RWins) : undefined;
     // Initialize arrays for results
     const offset = 1; // Don't process 'White'
-    const nDemos = 6 /* Native */ + 1 - offset; // Ditto
+    const nDemos = 6 /* Total */; // Ditto
+    // const nDemos = T.DemographicField.Native + 1 - offset;  // Ditto
     const demosByDistrict = p.demographicProfile.mfArrayByDistrict;
     // Initialize the demographic buckets
-    // COMPETITIVENESS - 06/23/2020 - And populate the statewide values.
     // Get the statewide minority VAP/CVAP % (ignore 'White')
     const vapPctArray = p.demographicProfile.stateMfArray.slice(1);
     // Determine proportional minority districts by demographic (ignoring'White')
@@ -89484,23 +89449,15 @@ function evalMinorityOpportunity(p, bLog = false) {
     }
     // The # of opportunity districts for each separate demographic and all minorities
     const oD = U.sumArray(opptyByDemo.slice(1)); // Sum individual demos, skipping all minorities
-    const cD = opptyByDemo[1 /* Minority */ - offset]; // All minorities
+    const cD = opptyByDemo[0 /* Minority */]; // All minorities
     // The # of proportional districts for each separate demographic and all minorities
-    const pOd = bucketsByDemo[7 /* Total */ - 1][4 /* PropSeats */];
-    const pCd = bucketsByDemo[1 /* Minority */ - 1][4 /* PropSeats */];
-    // const pOd: number = U.sumArray(districtsByDemo.slice(1));  // Sum individual demos, skipping all minorities
-    // const pCd: number = districtsByDemo[0];                    // All minorities
+    const pOd = bucketsByDemo[6 /* Total */][4 /* PropSeats */];
+    const pCd = bucketsByDemo[0 /* Minority */][4 /* PropSeats */];
     // Score opportunity
     const score = scoreMinority(oD, pOd, cD, pCd);
     let mS = {
-        report: {
-            averageDVf: averageDVf,
-            averageRVf: averageRVf,
-            bucketsByDemographic: bucketsByDemo
-        },
-        // proportionalOpportunities: pOd,
+        pivotByDemographic: bucketsByDemo,
         opportunityDistricts: oD,
-        // proportionalCoalitions: pCd,
         coalitionDistricts: cD,
         score: score,
         details: {}
@@ -89513,14 +89470,13 @@ exports.evalMinorityOpportunity = evalMinorityOpportunity;
 //   how minority opportunities are estimated (so that 37% minority shares score
 //   like 52% share).
 function scoreMinority(oD, pOd, cD, pCd) {
-    // Score minority opportunity [0–100] here; weight it later
-    const bonus = 100; // C.minorityBonus();
+    // Score minority opportunity [0–100]
     const cDWeight = C.coalitionDistrictWeight();
     // Cap opportunity & coalition districts
     const oDCapped = Math.min(oD, pOd);
     const cdCapped = Math.min(cD, pCd);
-    const opportunityScore = (pOd > 0) ? Math.round((oDCapped / pOd) * bonus) : 0;
-    const coalitionScore = (pCd > 0) ? Math.round((cdCapped / pCd) * bonus) : 0;
+    const opportunityScore = (pOd > 0) ? Math.round((oDCapped / pOd) * 100) : 0;
+    const coalitionScore = (pCd > 0) ? Math.round((cdCapped / pCd) * 100) : 0;
     const score = Math.round(Math.min(opportunityScore + cDWeight * Math.max(coalitionScore - opportunityScore, 0), 100));
     return score;
 }
@@ -89561,7 +89517,6 @@ function exceedsMaximumThreshold(Mf) {
     return Mf > threshold;
 }
 function calcProportionalDistricts(proportion, nDistricts) {
-    // TODO - Maybe bump up to get a statewide proportion on the bubble to rate one district?
     const roundUp = 0.0;
     const fractional = proportion * nDistricts;
     const integral = Math.round(fractional + roundUp);
@@ -89613,7 +89568,6 @@ class Normalizer {
     }
     // Invert a value in the unit range [0.0–1.0] (so that bigger is better).
     invert() {
-        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
         console.assert(((this.wipNum >= 0.0) && (this.wipNum <= 1.0)), "Inverting: " + S.OUT_OF_RANGE_MSG, this.wipNum);
         this.wipNum = 1.0 - this.wipNum;
         return this.wipNum;
@@ -89637,7 +89591,6 @@ class Normalizer {
     unitize(begin_range, end_range) {
         const min_range = Math.min(begin_range, end_range);
         const max_range = Math.max(begin_range, end_range);
-        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
         console.assert(((this.wipNum >= min_range) && (this.wipNum <= max_range)), "Unitizing: " + S.OUT_OF_RANGE_MSG, this.wipNum);
         const ranged = this.wipNum - min_range;
         this.wipNum = Math.abs(ranged / (end_range - begin_range));
@@ -89647,7 +89600,6 @@ class Normalizer {
     // NOTE - If the range is already such that "bigger is better," then the closer
     //   the value is to 1.0 (the best) the *less* it will decay.
     decay(fn = 0 /* Gravity */) {
-        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
         console.assert(((this.wipNum >= 0.0) && (this.wipNum <= 1.0)), "Decaying: " + S.OUT_OF_RANGE_MSG, this.wipNum);
         switch (fn) {
             case 0 /* Gravity */: {
@@ -89661,7 +89613,6 @@ class Normalizer {
     }
     // Translate a value in the unit range to the user-friendly range [0 – 100].
     rescale() {
-        // TODO - DAVID: Can we make this throw an Error and expect that in unit test?
         console.assert(((this.wipNum >= 0.0) && (this.wipNum <= 1.0)), "Rescaling: " + S.OUT_OF_RANGE_MSG, this.wipNum);
         this.normalizedNum = Math.round(this.wipNum * S.NORMALIZED_RANGE);
         return this.normalizedNum;
@@ -89698,12 +89649,12 @@ const C = __importStar(__webpack_require__(/*! ./config */ "./src/config.ts"));
 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.
+// TODO - Revise this.
 // SCORE BIAS & COMPETITIVENESS
 /* SCORECARD FIELDS:
 
 * ??? [statewideV] (V) = the average statewide two-party vote for Democrats
 
-
 * ^S# [bestS] = the Democratic seats closest to proportional
 * ^S% [bestSf] = the corresponding Democratic seat share
 * S! [fptpS] = the estimated number of Democratic seats using first past the post
@@ -89714,7 +89665,7 @@ const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts")
 * BV_50 [bV50] = Votes bias as a fraction
 * decl [decl] = Declination
 * GS [gSym] = Global symmetry
-* ?? [gamma] = TODO
+* ?? [gamma] = TODO: describe
 
 * EG [EG] = Efficiency gap as a fraction
 * BS_V [bSV] = Seats bias @ <V> (geometric)
@@ -89727,9 +89678,6 @@ const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts")
 * 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 [bigR] = Overall responsiveness or winner’s bonus
 * r [littleR] = The point responsiveness at V% (the slope of the S(V) curve at <V>)
 * MIR [MIR] = Minimal inverse responsiveness
@@ -89744,85 +89692,66 @@ const normalize_1 = __webpack_require__(/*! ./normalize */ "./src/normalize.ts")
 * Md% [mDf] = the probability that the marginal seats will flip, so S% => ^S%
 * C$ [competitiveness.score] = the competitiveness score normalized [0–100]
 
-* <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
-
 */
 function scorePartisan(Vf, VfArray, options) {
-    const bAlternateMetrics = options.alternates;
+    const bAdvanced = options.advanced;
     const bConstrained = options.constrained;
     const shift = options.shift;
     const N = VfArray.length;
     const bestS = bestSeats(N, Vf);
     const bestSf = bestSeatShare(bestS, N);
-    const fptpS = bAlternateMetrics ? estFPTPSeats(VfArray) : undefined;
-    // NOTE - When not constrained, use the full probability distribution to calc metrics.
+    const fptpS = bAdvanced ? estFPTPSeats(VfArray) : undefined;
+    // When not constrained, use the full probability distribution to calc metrics.
     const range = bConstrained ? C.competitiveDistribution() : undefined;
     const estS = estSeats(VfArray, range);
     const estSf = estSeatShare(estS, N);
-    const bias = estBias(estSf, bestSf);
-    const biasScore = scorebias(bias, Vf, estSf);
-    const unearnedS = estUnearnedSeats(bestS, estS);
-    const impactScore = scoreImpact(unearnedS, Vf, estSf, N);
+    const deviation = estDeviation(estSf, bestSf);
+    const proportionalityScore = scoreDeviation(deviation, Vf, estSf);
     // Calculate additional alternate metrics for reference
-    // NOTE - Use the uncompressed seat probability function
     const dSVpoints = inferSVpoints(Vf, VfArray, shift);
     const rSVpoints = invertSVPoints(dSVpoints);
-    // const dSVpoints = bAlternateMetrics ? inferSVpoints(Vf, VfArray, shift) : undefined;
-    const TOf = bAlternateMetrics ? calcTurnoutBias(Vf, VfArray) : undefined;
-    const Bs50 = bAlternateMetrics ? estPartisanBias(dSVpoints, N) : undefined;
+    // const dSVpoints = bAdvanced ? inferSVpoints(Vf, VfArray, shift) : undefined;
+    const TOf = bAdvanced ? calcTurnoutBias(Vf, VfArray) : undefined;
+    const Bs50 = bAdvanced ? estPartisanBias(dSVpoints, N) : undefined;
     const Bs50f = (!(Bs50 === undefined)) ? U.trim(Bs50 / N) : undefined;
-    const Bv50f = bAlternateMetrics ? estVotesBias(dSVpoints, N) : undefined;
-    const rvPoints = bAlternateMetrics ? keyRVpoints(VfArray) : undefined;
-    const decl = bAlternateMetrics ? calcDeclination(VfArray) : undefined;
-    const gSym = bAlternateMetrics ? calcGlobalSymmetry(dSVpoints, rSVpoints, Bs50f) : undefined;
-    const EG = bAlternateMetrics ? calcEfficiencyGap(Vf, estSf) : undefined;
-    const BsGf = bAlternateMetrics ? estGeometricSeatsBias(Vf, dSVpoints, rSVpoints) : 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;
+    const Bv50f = bAdvanced ? estVotesBias(dSVpoints, N) : undefined;
+    const rvPoints = bAdvanced ? keyRVpoints(VfArray) : undefined;
+    const decl = bAdvanced ? calcDeclination(VfArray) : undefined;
+    const gSym = bAdvanced ? calcGlobalSymmetry(dSVpoints, rSVpoints, Bs50f) : undefined;
+    const EG = bAdvanced ? calcEfficiencyGap(Vf, estSf) : undefined;
+    const BsGf = bAdvanced ? estGeometricSeatsBias(Vf, dSVpoints, rSVpoints) : undefined;
+    const prop = bAdvanced ? calcDisproportionality(Vf, estSf) : undefined;
+    const mMs = bAdvanced ? estMeanMedianDifference(VfArray, Vf) : undefined;
+    const mMd = bAdvanced ? estMeanMedianDifference(VfArray) : undefined;
+    const LO = bAdvanced ? calcLopsidedOutcomes(VfArray) : undefined;
     // Calculate alternate responsiveness metrics for reference
-    const bigR = bAlternateMetrics ? calcBigR(Vf, estSf) : undefined;
-    const littleR = bAlternateMetrics ? estResponsiveness(Vf, dSVpoints) : undefined;
-    const MIR = (bAlternateMetrics && littleR) ? calcMinimalInverseResponsiveness(Vf, littleR) : undefined;
-    const rD = (!bConstrained || bAlternateMetrics) ? estResponsiveDistricts(VfArray) : undefined;
-    const rDf = bAlternateMetrics ? estResponsiveDistrictsShare(rD, N) : undefined;
-    const gamma = (bAlternateMetrics && littleR) ? calcGamma(Vf, estSf, littleR) : undefined;
+    const bigR = bAdvanced ? calcBigR(Vf, estSf) : undefined;
+    const littleR = bAdvanced ? estResponsiveness(Vf, dSVpoints) : undefined;
+    const MIR = (bAdvanced && littleR) ? calcMinimalInverseResponsiveness(Vf, littleR) : undefined;
+    const rD = (!bConstrained || bAdvanced) ? estResponsiveDistricts(VfArray) : undefined;
+    const rDf = bAdvanced ? estResponsiveDistrictsShare(rD, N) : undefined;
+    const gamma = (bAdvanced && littleR) ? calcGamma(Vf, estSf, littleR) : undefined;
     const Cn = countCompetitiveDistricts(VfArray);
     // NOTE - Cd by definition uses a *possibly* different (more narrow) probability
     //   distribution than Rd.
     const cD = estCompetitiveDistricts(VfArray);
-    // const cD = bConstrained ? estCompetitiveDistricts(VfArray) : rD as number;
     const cDf = estCompetitiveDistrictsShare(cD, N);
     const competitivenessScore = scoreCompetitiveness(cDf);
-    // NOTE: Original version:
-    // const Mrange = findMarginalDistricts(Vf, VfArray, N);
-    // const Md = estMarginalCompetitiveDistricts(Mrange, VfArray);
-    // const Mdf = estMarginalCompetitiveShare(Md, Mrange);
-    // const competitivenessScore = scoreCompetitiveness(Mdf, cDf);
     let biasScoring = {
         bestS: bestS,
         bestSf: bestSf,
         estS: estS,
         estSf: estSf,
-        bias: bias,
-        score: biasScore
-    };
-    const impactScoring = {
-        unearnedS: unearnedS,
-        score: impactScore
+        deviation: deviation,
+        score: proportionalityScore
     };
     let competitiveScoring = {
         cSimple: Cn,
         cD: cD,
         cDf: cDf,
-        // mRange: Mrange,
-        // mD: Md,
-        // mDf: Mdf,
         score: competitivenessScore
     };
-    if (bAlternateMetrics) {
+    if (bAdvanced) {
         biasScoring.tOf = TOf;
         biasScoring.fptpS = fptpS;
         biasScoring.bS50 = Bs50f;
@@ -89843,47 +89772,36 @@ function scorePartisan(Vf, VfArray, options) {
         competitiveScoring.rD = rD;
         competitiveScoring.rDf = rDf;
     }
-    // Weight bias, impact, and competitiveness into partisan scores to compare
-    // plans across states and within a state.
-    const bS = biasScoring.score;
-    const iS = impactScoring.score;
-    const cS = competitiveScoring.score;
-    const acrossStatesPartisanScore = weightPartisan(bS, iS, cS, 0 /* AcrossStates */);
-    const withinStatesPartisanScore = weightPartisan(bS, iS, cS, 1 /* WithinAState */);
+    const DWins = VfArray.filter(x => x > 0.5);
+    const RWins = VfArray.filter(x => x <= 0.5); // Ties credited to R's
+    const averageDVf = (DWins.length > 0) ? U.avgArray(DWins) : undefined;
+    const averageRVf = (RWins.length > 0) ? U.avgArray(RWins) : undefined;
     const s = {
         bias: biasScoring,
-        impact: impactScoring,
-        competitiveness: competitiveScoring,
+        responsiveness: competitiveScoring,
         dSVpoints: dSVpoints,
         rSVpoints: rSVpoints,
-        score: acrossStatesPartisanScore,
-        score2: withinStatesPartisanScore,
+        averageDVf: averageDVf,
+        averageRVf: averageRVf,
         details: {}
     };
     return s;
 }
 exports.scorePartisan = scorePartisan;
-function weightPartisan(bS, iS, cS, context) {
-    const bW = C.biasWeight(context);
-    const iW = C.impactWeight(context);
-    const cW = C.competitivenessWeight(context);
-    const score = Math.round(((bS * bW) + (iS * iW) + (cS * cW)) / (bW + iW + cW));
-    return score;
-}
-exports.weightPartisan = weightPartisan;
 function extraBonus(Vf) {
-    const okExtra = (0.5 - Vf) * (C.winnerBonus() - 1.0);
+    const over50Pct = (Vf > 0.5) ? (Vf - 0.5) : (0.5 - Vf);
+    const okExtra = over50Pct * (C.winnerBonus() - 1.0);
     return U.trim(okExtra);
 }
 exports.extraBonus = extraBonus;
-function scorebias(rawBias, Vf, Sf) {
+function scoreDeviation(deviation, Vf, Sf) {
     if (isAntimajoritarian(Vf, Sf)) {
         return 0;
     }
     else {
         // Adjust bias to incorporate an acceptable winner's bonus based on Vf
         const extra = extraBonus(Vf);
-        const adjusted = adjustBias(Vf, rawBias, extra);
+        const adjusted = adjustDeviation(Vf, deviation, extra);
         // Then normalize
         const _normalizer = new normalize_1.Normalizer(adjusted);
         const worst = C.biasRange()[C.BEG];
@@ -89897,15 +89815,24 @@ function scorebias(rawBias, Vf, Sf) {
         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.scoreDeviation = scoreDeviation;
+// Adjust deviation from proportionality to account for a winner's bonus
+// * If the bias is in the *same* direction as the statewide vote %, then
+//   discount the bias by the winner's bonus (extra).
+// * But if the bias and statewide vote % go in opposite directions, leave the
+//   bias unadjusted.
+function adjustDeviation(Vf, deviation, extra) {
+    let adjusted = deviation;
+    if ((Vf > 0.5) && (deviation < 0)) {
+        adjusted = Math.min(deviation + extra, 0);
+    }
+    else if ((Vf < 0.5) && (deviation > 0)) {
+        adjusted = Math.max(deviation - extra, 0);
+    }
+    return adjusted;
 }
-exports.adjustBias = adjustBias;
+exports.adjustDeviation = adjustDeviation;
+// NOTE - Not used.
 // Normalize unearned seats
 function scoreImpact(rawUE, Vf, Sf, N) {
     if (isAntimajoritarian(Vf, Sf)) {
@@ -89914,7 +89841,7 @@ function scoreImpact(rawUE, Vf, Sf, N) {
     else {
         // Adjust impact to incorporate an acceptable winner's bonus based on Vf
         const extra = extraBonus(Vf);
-        const adjustedBias = adjustBias(Vf, rawUE / N, extra);
+        const adjustedBias = adjustDeviation(Vf, rawUE / N, extra);
         const adjustedImpact = adjustedBias * N;
         // Then normalize
         const _normalizer = new normalize_1.Normalizer(adjustedImpact);
@@ -89937,9 +89864,8 @@ function isAntimajoritarian(Vf, Sf) {
     return bDem || bRep;
 }
 exports.isAntimajoritarian = isAntimajoritarian;
-// COMPETITIVENESS - Revised 06/23/2020
 // Normalize overall competitiveness - Raw values are in the range [0.0–1.0]. 
-// But the practical max is more like 2/3's, so unitize that range to [0.0–1.0].
+// But the practical max is more like 3/4's, so unitize that range to [0.0–1.0].
 // Then scale the values to [0–100].
 function scoreCompetitiveness(Cdf) {
     const _normalizer = new normalize_1.Normalizer(Cdf);
@@ -90032,8 +89958,6 @@ function inferSVpoints(Vf, VfArray, shift, range) {
         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;
 }
@@ -90118,11 +90042,12 @@ function estFPTPSeats(VfArray) {
     }));
 }
 exports.estFPTPSeats = estFPTPSeats;
-// B% - The bias calculated as ^S% — S%
-function estBias(estSf, bestSf) {
+// B% - The deviation from proportionality calculated as ^S% — S%
+function estDeviation(estSf, bestSf) {
     return U.trim(bestSf - estSf);
 }
-exports.estBias = estBias;
+exports.estDeviation = estDeviation;
+// NOTE - Not used.
 // UE# - The estimated # of unearned seats
 // UE_# from http://bit.ly/2Fcuf4q
 function estUnearnedSeats(proportional, probable) {
@@ -90227,11 +90152,9 @@ function estCompetitiveDistricts(VfArray, bCompress = false) {
     return U.trim(U.sumArray(VfArray.map(v => estDistrictCompetitiveness(v, bCompress))));
 }
 exports.estCompetitiveDistricts = estCompetitiveDistricts;
-// COMPETITIVENESS - Modified 06/22/2020
-// Re-scale a Democratic vote share to the competitive range (e.g., 45–55%).
 function estDistrictCompetitiveness(Vf, bCompress = false) {
     const _normalizer = new normalize_1.Normalizer(Vf);
-    // The end points of a compressed probability distribution
+    // The end points of the 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%].
@@ -90456,9 +90379,6 @@ 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;
@@ -90598,23 +90518,19 @@ function calcGamma(Vf, Sf, r) {
 exports.calcGamma = calcGamma;
 // HELPERS
 function printPartisanScorecardHeader() {
-    console.log('XX, Name, N, V%, ^S#, S#, B%, B$, UE#, I$, C#, Cd, Cdf, C$, <P$');
+    console.log('XX, Name, N, V%, ^S#, S#, B%, B$, C#, Cd, Cdf, C$');
 }
 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
+    console.log('%s, %s, %i, %f, %i, %f, %f, %i, %i, %f, %f, %i', xx, // 1
     name, // 2
     N, // 3
     Vf, // 4
     s.bias.bestS, // 5
     s.bias.estS, // 6
-    s.bias.bias, // 7
-    s.bias.score, s.impact.unearnedS, // 9
-    s.impact.score, s.competitiveness.cSimple, // 11
-    s.competitiveness.cD, s.competitiveness.cDf, 
-    // s.competitiveness.mD,
-    s.competitiveness.score, s.score // 15
-    );
+    s.bias.deviation, // 7
+    s.bias.score, s.responsiveness.cSimple, // 9
+    s.responsiveness.cD, s.responsiveness.cDf, s.responsiveness.score);
 }
 exports.printPartisanScorecardRow = printPartisanScorecardRow;
 // Generate partisan details (Table 1)
@@ -90623,12 +90539,12 @@ function printPartisanDetailsHeader() {
 }
 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, %f, %f, %f, %f', xx, Vf, s.bias.estSf, s.bias.bias, // Simple bias
+    console.log('%s, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f', xx, Vf, s.bias.estSf, s.bias.deviation, // Simple deviation from proportionality
     s.bias.bS50, s.bias.bV50, s.bias.decl, s.bias.gSym, s.bias.eG, s.bias.bSV, // Beta
     s.bias.prop, // PR
-    s.bias.mMs, s.bias.tOf, s.bias.mMd, s.bias.lO, s.competitiveness.rD, s.competitiveness.bigR, s.competitiveness.littleR, s.competitiveness.mIR, // Zeta
-    s.competitiveness.cD, // COMPETITIVENESS - Temporary to confirm new calc
-    s.competitiveness.cDf);
+    s.bias.mMs, s.bias.tOf, s.bias.mMd, s.bias.lO, s.responsiveness.rD, s.responsiveness.bigR, s.responsiveness.littleR, s.responsiveness.mIR, // Zeta
+    s.responsiveness.cD, // COMPETITIVENESS - Temporary to confirm new calc
+    s.responsiveness.cDf);
 }
 exports.printPartisanDetailsRow = printPartisanDetailsRow;
 
@@ -90655,7 +90571,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-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");
 const cohesive_1 = __webpack_require__(/*! ./cohesive */ "./src/cohesive.ts");
@@ -90671,7 +90586,8 @@ function scorePlan(p, overridesJSON) {
     const cS = {
         score: compactnessScore,
         reock: reockM,
-        polsby: polsbyM
+        polsby: polsbyM,
+        details: {}
     };
     // Splitting
     const CxD = p.splittingProfile.countyPopByDistrict;
@@ -90683,40 +90599,26 @@ function scorePlan(p, overridesJSON) {
     const sS = {
         score: splittingScore,
         county: countyM,
-        district: districtM
+        district: districtM,
+        details: {}
     };
     // Population deviation
     const pdS = equal_1.doPopulationDeviation(p.populationProfile.totalPopByDistrict, p.populationProfile.targetSize, p.legislativeDistricts);
-    // Combine traditional principles into a score to compare plans w/in a state
-    const tpScore = weightTradtionalPrinciples(cS.score, sS.score, pdS.normalized, 1 /* WithinAState */);
-    // Populate the "best" traditional principles scorecard
-    const tpS = {
-        score: tpScore,
-        compactness: cS,
-        splitting: sS,
-        populationDeviation: pdS,
-        details: {}
-    };
-    // PARTISAN ("fair") subcategories - bias, impact, & competitiveness (plus lots of supporting measures)
+    // Partisan - bias & responsiveness
     const options = {
-        alternates: true,
+        advanced: true,
         constrained: false,
         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 */);
     const mS = minority_1.evalMinorityOpportunity(p);
-    // Add minority bonus, keeping score to the range [0–100]
-    const bonus = C.minorityBonus() * (mS.score / 100);
-    score = mixinMinorityBonus(score, bonus);
-    // Roll up an overall scorecard
+    // Combine the pieces into a scorecard
     const scorecard = {
         partisan: pS,
         minority: mS,
-        traditionalPrinciples: tpS,
-        score: score,
+        compactness: cS,
+        splitting: sS,
+        populationDeviation: pdS,
         details: {}
     };
     return scorecard;
@@ -90737,44 +90639,20 @@ function weightSplitting(csS, dsS) {
     return score;
 }
 exports.weightSplitting = weightSplitting;
-function weightTradtionalPrinciples(cS, sS, pdS, context) {
-    const cW = C.compactnessWeight(context);
-    const sW = C.splittingWeight(context);
-    const pdW = C.popdevWeight(context);
-    const score = Math.round(((cS * cW) + (sS * sW) + (pdS * pdW)) / (cW + sW + pdW));
-    return score;
-}
-exports.weightTradtionalPrinciples = weightTradtionalPrinciples;
-function weightOverall(pS, tpS, context) {
-    const pW = C.partisanWeight(context);
-    const tpW = C.traditionalPrinciplesWeight(context);
-    const score = Math.round(((pS * pW) + (tpS * tpW)) / (pW + tpW));
-    return score;
-}
-exports.weightOverall = weightOverall;
-function mixinMinorityBonus(score, minorityBonus) {
-    const modifiedScore = Math.min(score + minorityBonus, S.NORMALIZED_RANGE);
-    return modifiedScore;
-}
-exports.mixinMinorityBonus = mixinMinorityBonus;
 function printScorecardHeader() {
-    console.log('XX, Name, N, V%, ^S#, S#, B%, B$, UE#, I$, C#, Cd, Cdf, C$, >P$, Rc, Rc$, Pc, Pc$, G$, Cs, Cs$, Ds, Ds$, S$, Eq, Eq$, T$, Od, Md, M$, $$$');
+    console.log('XX, Name, N, V%, ^S#, S#, B%, B$, C#, Cd, Cdf, C$, Rc, Rc$, Pc, Pc$, G$, Cs, Cs$, Ds, Ds$, S$, Eq, Eq$, Od, Md, 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, %f, %i, %f, %i, %i, %f, %i, %f, %i, %i, %f, %i, %i, %f, %f, %i, %i', xx, // 1
+    console.log('%s, %s, %i, %f, %i, %f, %f, %i, %i, %f, %f, %i, %f, %i, %f, %i, %i, %f, %i, %f, %i, %i, %f, %i, %f, %f, %i', xx, // 1
     name, // 2
     N, // 3
     Vf, // 4
     s.partisan.bias.bestS, // 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.cSimple, // 11
-    s.partisan.competitiveness.cD, s.partisan.competitiveness.cDf, 
-    // 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.opportunityDistricts, s.minority.coalitionDistricts, s.minority.score, s.score);
+    s.partisan.bias.deviation, // 7
+    s.partisan.bias.score, s.partisan.responsiveness.cSimple, // 9
+    s.partisan.responsiveness.cD, s.partisan.responsiveness.cDf, s.partisan.responsiveness.score, s.compactness.reock.raw, s.compactness.reock.normalized, s.compactness.polsby.raw, s.compactness.polsby.normalized, s.compactness.score, s.splitting.county.raw, s.splitting.county.normalized, s.splitting.district.raw, s.splitting.district.normalized, s.splitting.score, s.populationDeviation.raw, s.populationDeviation.normalized, s.minority.opportunityDistricts, s.minority.coalitionDistricts, s.minority.score);
 }
 exports.printScorecardRow = printScorecardRow;
 
@@ -102923,10 +102801,10 @@ class AnalyticsSession {
         const scorecard = this._scorecard;
         const r = {
             proportionality: scorecard.partisan.bias.score,
-            competitiveness: scorecard.partisan.competitiveness.score,
+            competitiveness: scorecard.partisan.responsiveness.score,
             minorityRights: scorecard.minority.score,
-            compactness: scorecard.traditionalPrinciples.compactness.score,
-            splitting: scorecard.traditionalPrinciples.splitting.score
+            compactness: scorecard.compactness.score,
+            splitting: scorecard.splitting.score
         };
         return r;
     }
@@ -104424,7 +104302,7 @@ function doAnalyzePostProcessing(s, bLog = false) {
     // Just populate the normalized population deviation score in the test
     const scorecard = s._scorecard;
     let popDev = s.getTest(4 /* PopulationDeviation */);
-    popDev['normalizedScore'] = scorecard.traditionalPrinciples.populationDeviation.normalized;
+    popDev['normalizedScore'] = scorecard.populationDeviation.normalized;
     const datasets = {
         shapes: S.SHAPES,
         census: U.deepCopy(s.config['descriptions']['CENSUS']),
@@ -104433,12 +104311,12 @@ function doAnalyzePostProcessing(s, bLog = false) {
     };
     scorecard.partisan.details['election'] = datasets.election;
     scorecard.minority.details['vap'] = datasets.vap;
-    scorecard.traditionalPrinciples.details['shapes'] = datasets.shapes;
-    scorecard.traditionalPrinciples.details['census'] = datasets.census;
+    scorecard.details['shapes'] = datasets.shapes;
+    scorecard.details['census'] = datasets.census;
     const simpleSplits = s.getTest(5 /* UnexpectedCountySplits */);
-    scorecard.traditionalPrinciples.details['unexpectedAffected'] = simpleSplits['score'];
-    scorecard.traditionalPrinciples.details['nSplits'] = simpleSplits['details']['nSplits'];
-    scorecard.traditionalPrinciples.details['countiesSplitUnexpectedly'] = U.deepCopy(simpleSplits['details']['countiesSplitUnexpectedly']);
+    scorecard.compactness.details['unexpectedAffected'] = simpleSplits['score'];
+    scorecard.compactness.details['nSplits'] = simpleSplits['details']['nSplits'];
+    scorecard.compactness.details['countiesSplitUnexpectedly'] = U.deepCopy(simpleSplits['details']['countiesSplitUnexpectedly']);
     // NOTE - Add split precincts in dra-client directly
     // Derive secondary tests
     analyze_1.doDeriveSecondaryTests(s, bLog);
@@ -104583,10 +104461,10 @@ function scorePlan(s, p, bLog = false, overridesJSON) {
     // doHasEqualPopulations() to use later.This is preserving the old calling sequence.
     let test = s.getTest(4 /* PopulationDeviation */);
     // Get the raw population deviation
-    const popDev = scorecard.traditionalPrinciples.populationDeviation.raw;
+    const popDev = scorecard.populationDeviation.raw;
     // Populate the test entry
     test['score'] = popDev;
-    test['details'] = { 'maxDeviation': scorecard.traditionalPrinciples.populationDeviation.notes['maxDeviation'] };
+    test['details'] = { 'maxDeviation': scorecard.populationDeviation.notes['maxDeviation'] };
     // Populate the N+1 summary "district" in district.statistics
     let totalPop = s.districts.statistics[D.DistrictField.TotalPop];
     let popDevPct = s.districts.statistics[D.DistrictField.PopDevPct];