@dra2020/district-analytics 6.1.0 → 6.3.1

package/dist/cli.js

@@ -89102,7 +89102,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\":100},\"marginal\":{\"range\":[0,0.85],\"weight\":0},\"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.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,\"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]}}");
 
 /***/ }),
 
@@ -89160,8 +89160,9 @@ function competitivenessWeight(context, overridesJSON) {
     return cW;
 }
 exports.competitivenessWeight = competitivenessWeight;
+// COMPETITIVENESS - The simple user-facing range, i.e., 45–55%.
 function competitiveRange(overridesJSON) {
-    const range = config_json_1.default.partisan.competitiveness.range;
+    const range = config_json_1.default.partisan.competitiveness.simpleRange;
     return range;
 }
 exports.competitiveRange = competitiveRange;
@@ -89170,26 +89171,29 @@ 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.
 function overallCompetitivenessRange(overridesJSON) {
-    const range = config_json_1.default.partisan.competitiveness.overall.range;
+    const range = config_json_1.default.partisan.competitiveness.range;
     return range;
 }
 exports.overallCompetitivenessRange = overallCompetitivenessRange;
-function marginalCompetitivenessRange(overridesJSON) {
-    const range = config_json_1.default.partisan.competitiveness.marginal.range;
-    return range;
-}
-exports.marginalCompetitivenessRange = marginalCompetitivenessRange;
-function marginalCompetitivenessWeight(overridesJSON) {
-    const mcW = config_json_1.default.partisan.competitiveness.marginal.weight;
-    return mcW;
-}
-exports.marginalCompetitivenessWeight = marginalCompetitivenessWeight;
-function overallCompetitivenessWeight(overridesJSON) {
-    const ocW = config_json_1.default.partisan.competitiveness.overall.weight;
-    return ocW;
-}
-exports.overallCompetitivenessWeight = overallCompetitivenessWeight;
+// export function marginalCompetitivenessRange(overridesJSON?: any): number[]
+// {
+//   const range = config.partisan.competitiveness.marginal.range;
+//   return range;
+// }
+// export function marginalCompetitivenessWeight(overridesJSON?: any): number
+// {
+//   const mcW = config.partisan.competitiveness.marginal.weight;
+//   return mcW;
+// }
+// export function overallCompetitivenessWeight(overridesJSON?: any): number
+// {
+//   const ocW = config.partisan.competitiveness.overall.weight;
+//   return ocW;
+// }
 // MINORITY
 function minorityOpportunityRange(overridesJSON) {
     const range = config_json_1.default.minority.range;
@@ -89396,6 +89400,8 @@ function __export(m) {
 }
 Object.defineProperty(exports, "__esModule", { value: true });
 __export(__webpack_require__(/*! ./_api */ "./src/_api.ts"));
+var partisan_1 = __webpack_require__(/*! ./partisan */ "./src/partisan.ts");
+exports.estSeatProbability = partisan_1.estSeatProbability;
 
 
 /***/ }),
@@ -89431,39 +89437,63 @@ function evalMinorityOpportunity(p, bLog = false) {
     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;
-    // Determine proportional minority districts by demographic (ignore 'White')
-    const districtsByDemo = calcDistrictsByDemo(p.demographicProfile.stateMfArray.slice(1), p.nDistricts);
     // Initialize arrays for results
     const offset = 1; // Don't process 'White'
-    const nDemos = 6 /* Native */ + 1 - offset; // Ditto
-    const nBuckets = 2; // 37–50% and > 50%
+    const nDemos = 6 /* Total */; // Ditto
+    // const nDemos = T.DemographicField.Native + 1 - offset;  // Ditto
     const demosByDistrict = p.demographicProfile.mfArrayByDistrict;
     // Initialize the demographic buckets
-    let bucketsByDemo = new Array(nDemos);
+    // 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')
+    const districtsByDemo = calcDistrictsByDemo(vapPctArray, p.nDistricts);
+    let bucketsByDemo = new Array(nDemos + 1); // Add a row for the 'Total' row
+    let totalProportional = 0;
     for (let j = 0; j < nDemos; j++) {
-        bucketsByDemo[j] = [0, 0];
-    }
-    let opptyByDemo = U.initArray(nDemos, 0.0);
+        const vapPct = vapPctArray[j];
+        const prop = districtsByDemo[j];
+        // Accumulate the proportional values for each demographic, ignoring the first
+        // all Minority demographic.
+        if (j > 0)
+            totalProportional += prop;
+        bucketsByDemo[j] = [0, 0, 0, vapPct, prop]; // Five conceptual columns for each demographic
+    }
+    // Add a 'Total' row
+    bucketsByDemo[nDemos] = [0, 0, 0, 0, totalProportional];
+    let opptyByDemo = U.initArray(nDemos, 0.0); // A state-level value
     // For each district
     for (let i = 0; i < p.nDistricts; i++) {
         // Find the opportunities for minority representation
         for (let j = 0; j < nDemos; j++) {
             const proportion = U.deepCopy(demosByDistrict[i][j + offset]); // Skip the 'White' entries
             if (exceedsMinimumThreshold(proportion)) {
-                // Bucket opportunity districts
+                // Bucket opportunity districts for each demographic
                 const bucket = (exceedsMaximumThreshold(proportion)) ? 1 : 0;
                 bucketsByDemo[j][bucket] += 1;
+                bucketsByDemo[j][2 /* Total */] += 1;
                 // Accumulate seat probabilities
                 opptyByDemo[j] += estMinorityOpportunity(proportion);
+                // Also accumulate the 'Total' row summing the opportunities for each demographic,
+                // ignoring the first all Minority demographic.
+                if (j > 0) {
+                    bucketsByDemo[nDemos][bucket] += 1;
+                    bucketsByDemo[nDemos][2 /* Total */] += 1;
+                }
             }
         }
     }
     // 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[0]; // All minorities
+    const cD = opptyByDemo[0 /* Minority */]; // All minorities
+    // const cD: number = opptyByDemo[T.DemographicField.Minority - offset];  // All minorities
     // The # of proportional districts for each separate demographic and all minorities
-    const pOd = U.sumArray(districtsByDemo.slice(1)); // Sum individual demos, skipping all minorities
-    const pCd = districtsByDemo[0]; // All minorities
+    const pOd = bucketsByDemo[6 /* Total */][4 /* PropSeats */];
+    const pCd = bucketsByDemo[0 /* Minority */][4 /* PropSeats */];
+    // const pOd: number = bucketsByDemo[T.DemographicField.Total - 1][T.PivotField.PropSeats];
+    // const pCd: number = bucketsByDemo[T.DemographicField.Minority - 1][T.PivotField.PropSeats];
+    // const pOd: number = U.sumArray(districtsByDemo.slice(1));  // Sum individual demos, skipping all minorities
+    // const pCd: number = districtsByDemo[0];                    // All minorities
     // Score opportunity
     const score = scoreMinority(oD, pOd, cD, pCd);
     let mS = {
@@ -89472,9 +89502,9 @@ function evalMinorityOpportunity(p, bLog = false) {
             averageRVf: averageRVf,
             bucketsByDemographic: bucketsByDemo
         },
-        proportionalOpportunities: pOd,
+        // proportionalOpportunities: pOd,
         opportunityDistricts: oD,
-        proportionalCoalitions: pCd,
+        // proportionalCoalitions: pCd,
         coalitionDistricts: cD,
         score: score,
         details: {}
@@ -89730,6 +89760,7 @@ function scorePartisan(Vf, VfArray, options) {
     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 range = bConstrained ? C.competitiveDistribution() : undefined;
     const estS = estSeats(VfArray, range);
     const estSf = estSeatShare(estS, N);
@@ -89763,13 +89794,17 @@ function scorePartisan(Vf, VfArray, options) {
     const rDf = bAlternateMetrics ? estResponsiveDistrictsShare(rD, N) : undefined;
     const gamma = (bAlternateMetrics && littleR) ? calcGamma(Vf, estSf, littleR) : undefined;
     const Cn = countCompetitiveDistricts(VfArray);
-    const cD = estCompetitiveDistricts(VfArray); // NOTE - Cd by definition uses a more narrow probability distribution vs. Rd
+    // 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 Mrange = findMarginalDistricts(Vf, VfArray, N);
-    const Md = estMarginalCompetitiveDistricts(Mrange, VfArray);
-    const Mdf = estMarginalCompetitiveShare(Md, Mrange);
-    const competitivenessScore = scoreCompetitiveness(Mdf, cDf);
+    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,
@@ -89786,9 +89821,9 @@ function scorePartisan(Vf, VfArray, options) {
         cSimple: Cn,
         cD: cD,
         cDf: cDf,
-        mRange: Mrange,
-        mD: Md,
-        mDf: Mdf,
+        // mRange: Mrange,
+        // mD: Md,
+        // mDf: Mdf,
         score: competitivenessScore
     };
     if (bAlternateMetrics) {
@@ -89841,7 +89876,10 @@ function weightPartisan(bS, iS, cS, context) {
 }
 exports.weightPartisan = weightPartisan;
 function extraBonus(Vf) {
-    const okExtra = (0.5 - Vf) * (C.winnerBonus() - 1.0);
+    // PROPORTIONALITY - 06/24/2020 - Making the OK extra amount always positive.
+    // const okExtra: number = (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;
@@ -89867,12 +89905,26 @@ function scorebias(rawBias, Vf, Sf) {
     }
 }
 exports.scorebias = scorebias;
+// PROPORTIONALITY - 06/24/2020
 // Adjust bias 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 adjustBias(Vf, bias, extra) {
-    if (Vf > 0.5)
-        return Math.min(bias - extra, 0);
-    else
-        return Math.max(bias - extra, 0);
+    let adjusted = bias;
+    if ((Vf > 0.5) && (bias < 0)) {
+        adjusted = Math.min(bias + extra, 0);
+    }
+    else if ((Vf < 0.5) && (bias > 0)) {
+        adjusted = Math.max(bias - extra, 0);
+    }
+    return adjusted;
+    // PROPORTIONALITY - 06/24/2020 - Original logic:
+    // if (Vf > 0.5)
+    //   return Math.min(bias + extra, 0);
+    // else
+    //   return Math.max(bias - extra, 0);
 }
 exports.adjustBias = adjustBias;
 // Normalize unearned seats
@@ -89906,32 +89958,59 @@ function isAntimajoritarian(Vf, Sf) {
     return bDem || bRep;
 }
 exports.isAntimajoritarian = isAntimajoritarian;
-function scoreCompetitiveness(rawMarginal, rawOverall) {
-    // 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].
-    // Then scale the values to [0–100].
-    const _overall = new normalize_1.Normalizer(rawOverall);
+// 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].
+// Then scale the values to [0–100].
+function scoreCompetitiveness(Cdf) {
+    const _normalizer = new normalize_1.Normalizer(Cdf);
     let worst = C.overallCompetitivenessRange()[C.BEG];
     let best = C.overallCompetitivenessRange()[C.END];
-    _overall.clip(worst, best);
-    _overall.unitize(worst, best);
-    _overall.rescale();
-    const ocS = _overall.normalizedNum;
-    // Normalize marginal competitiveness
-    const _marginal = new normalize_1.Normalizer(rawMarginal);
-    worst = C.marginalCompetitivenessRange()[C.BEG];
-    best = C.marginalCompetitivenessRange()[C.END];
-    _marginal.clip(worst, best);
-    _marginal.unitize(worst, best);
-    _marginal.rescale();
-    const mcS = _marginal.normalizedNum;
-    const mcW = C.marginalCompetitivenessWeight();
-    const ocW = C.overallCompetitivenessWeight();
-    // Then combine the results
-    const score = ((mcW + ocW) > 0) ? Math.round(((mcW * mcS) + (ocW * ocS)) / (mcW + ocW)) : 0;
+    _normalizer.clip(worst, best);
+    _normalizer.unitize(worst, best);
+    _normalizer.rescale();
+    const score = _normalizer.normalizedNum;
     return score;
 }
 exports.scoreCompetitiveness = scoreCompetitiveness;
+/* NOTE - Original version:
+export function scoreCompetitiveness(rawMarginal: number, rawOverall: number): number
+{
+  // 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].
+  // Then scale the values to [0–100].
+  const _overall = new Normalizer(rawOverall);
+
+  let worst = C.overallCompetitivenessRange()[C.BEG];
+  let best = C.overallCompetitivenessRange()[C.END];
+
+  _overall.clip(worst, best);
+  _overall.unitize(worst, best);
+  _overall.rescale();
+
+  const ocS = _overall.normalizedNum as number;
+
+
+  // Normalize marginal competitiveness
+  const _marginal = new Normalizer(rawMarginal);
+
+  worst = C.marginalCompetitivenessRange()[C.BEG];
+  best = C.marginalCompetitivenessRange()[C.END];
+
+  _marginal.clip(worst, best);
+  _marginal.unitize(worst, best);
+  _marginal.rescale();
+  const mcS = _marginal.normalizedNum as number;
+
+  const mcW = C.marginalCompetitivenessWeight();
+  const ocW = C.overallCompetitivenessWeight();
+
+  // Then combine the results
+  const score = ((mcW + ocW) > 0) ? Math.round(((mcW * mcS) + (ocW * ocS)) / (mcW + ocW)) : 0;
+
+  return score;
+}
+*/
 // CORE CAPABILITIES FROM JOHN NAGLE'S METHOD
 const { erf } = __webpack_require__(/*! mathjs */ "./node_modules/mathjs/main/esm/index.js");
 // console.log("erf(0.2) =", erf(0.2));    // returns 0.22270258921047847
@@ -90165,19 +90244,20 @@ function isCompetitive(v) {
     return ((v >= C.competitiveRange()[C.BEG]) && (v <= C.competitiveRange()[C.END])) ? 1 : 0;
 }
 // cD - The estimated # of competitive districts
-function estCompetitiveDistricts(VfArray) {
-    return U.trim(U.sumArray(VfArray.map(v => estDistrictCompetitiveness(v))));
+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) {
+function estDistrictCompetitiveness(Vf, bCompress = false) {
     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 = C.competitiveDistribution()[C.BEG];
-    const distEnd = C.competitiveDistribution()[C.END];
+    const distBeg = bCompress ? C.competitiveDistribution()[C.BEG] : 0.0;
+    const distEnd = bCompress ? C.competitiveDistribution()[C.END] : 1.0;
     _normalizer.clip(distBeg, distEnd);
     _normalizer.unitize(distBeg, distEnd);
     const dC = estDistrictResponsiveness(_normalizer.wipNum);
@@ -90191,14 +90271,14 @@ function estCompetitiveDistrictsShare(cD, N) {
 exports.estCompetitiveDistrictsShare = estCompetitiveDistrictsShare;
 // Md - The estimated # of "marginal" districts in and around the likely FPTP
 //   seats & the best seat split that are competitive.
-function estMarginalCompetitiveDistricts(Mrange, VfArray) {
+function estMarginalCompetitiveDistricts(Mrange, VfArray, bCompress = false) {
     const minId = Mrange[C.BEG];
     const maxId = Mrange[C.END];
     // Sort the array values, and subset it to those districts
     // NOTE - I'm *not* keeping track of the district indexes right now
     let subsetVfArray = U.deepCopy(VfArray).sort().slice(minId - 1, maxId);
     // Est. competitive districts on that array
-    const Md = U.sumArray(subsetVfArray.map((v) => estDistrictCompetitiveness(v)));
+    const Md = U.sumArray(subsetVfArray.map((v) => estDistrictCompetitiveness(v, bCompress)));
     return U.trim(Md);
 }
 exports.estMarginalCompetitiveDistricts = estMarginalCompetitiveDistricts;
@@ -90539,7 +90619,7 @@ 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, Md, C$, <P$');
+    console.log('XX, Name, N, V%, ^S#, S#, B%, B$, UE#, I$, C#, Cd, Cdf, C$, <P$');
 }
 exports.printPartisanScorecardHeader = printPartisanScorecardHeader;
 function printPartisanScorecardRow(xx, name, N, Vf, s) {
@@ -90552,21 +90632,24 @@ function printPartisanScorecardRow(xx, name, N, Vf, s) {
     s.bias.bias, // 7
     s.bias.score, s.impact.unearnedS, // 9
     s.impact.score, s.competitiveness.cSimple, // 11
-    s.competitiveness.cD, s.competitiveness.mD, s.competitiveness.score, s.score // 15
+    s.competitiveness.cD, s.competitiveness.cDf, 
+    // 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>), B%, BS_50, BV_50, Decl, GS, EG, Beta, PR, MM, TO, MM\', LO, Rd, R, r, MIR');
+    console.log('XX, <V>, S(<V>), B%, BS_50, BV_50, Decl, GS, EG, Beta, PR, MM, TO, MM\', LO, Rd, R, r, MIR, Cd, Cdf');
 }
 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', 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.bias, // Simple bias
     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.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);
 }
 exports.printPartisanDetailsRow = printPartisanDetailsRow;
 
@@ -90696,11 +90779,11 @@ 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$, Rc, Rc$, Pc, Pc$, G$, Cs, Cs$, Ds, Ds$, S$, Eq, Eq$, T$, Od, M$, $$$');
+    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$, $$$');
 }
 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, %i, %i', xx, // 1
+    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
     name, // 2
     N, // 3
     Vf, // 4
@@ -90709,8 +90792,10 @@ function printScorecardRow(xx, name, N, Vf, s) {
     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.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.score, s.score);
+    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);
 }
 exports.printScorecardRow = printScorecardRow;
 
@@ -102855,6 +102940,17 @@ class AnalyticsSession {
     getPlanScorecard(bLog = false) {
         return this._scorecard;
     }
+    getRatings(bLog = false) {
+        const scorecard = this._scorecard;
+        const r = {
+            proportionality: scorecard.partisan.bias.score,
+            competitiveness: scorecard.partisan.competitiveness.score,
+            minorityRights: scorecard.minority.score,
+            compactness: scorecard.traditionalPrinciples.compactness.score,
+            splitting: scorecard.traditionalPrinciples.splitting.score
+        };
+        return r;
+    }
     // NOTE - This assumes that analyzePlan() has been run!
     getRequirementsChecklist(bLog = false) {
         return results_2.prepareRequirementsChecklist(this, bLog);