@dra2020/district-analytics 6.0.1 → 6.3.0

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);
@@ -89739,35 +89770,41 @@ function scorePartisan(Vf, VfArray, options) {
     const impactScore = scoreImpact(unearnedS, Vf, estSf, N);
     // Calculate additional alternate metrics for reference
     // NOTE - Use the uncompressed seat probability function
-    const inferredSVpoints = bAlternateMetrics ? inferSVpoints(Vf, VfArray, shift) : undefined;
+    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(inferredSVpoints, N) : undefined;
+    const Bs50 = bAlternateMetrics ? estPartisanBias(dSVpoints, N) : undefined;
     const Bs50f = (!(Bs50 === undefined)) ? U.trim(Bs50 / N) : undefined;
-    const Bv50f = bAlternateMetrics ? estVotesBias(inferredSVpoints, 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(inferredSVpoints, Bs50f) : undefined;
+    const gSym = bAlternateMetrics ? calcGlobalSymmetry(dSVpoints, rSVpoints, Bs50f) : undefined;
     const EG = bAlternateMetrics ? calcEfficiencyGap(Vf, estSf) : undefined;
-    const BsGf = bAlternateMetrics ? estGeometricSeatsBias(Vf, inferredSVpoints) : 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;
     // Calculate alternate responsiveness metrics for reference
     const bigR = bAlternateMetrics ? calcBigR(Vf, estSf) : undefined;
-    const littleR = bAlternateMetrics ? estResponsiveness(Vf, inferredSVpoints) : 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 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,
@@ -89784,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) {
@@ -89821,6 +89858,8 @@ function scorePartisan(Vf, VfArray, options) {
         bias: biasScoring,
         impact: impactScoring,
         competitiveness: competitiveScoring,
+        dSVpoints: dSVpoints,
+        rSVpoints: rSVpoints,
         score: acrossStatesPartisanScore,
         score2: withinStatesPartisanScore,
         details: {}
@@ -89902,32 +89941,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
@@ -90161,19 +90227,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);
@@ -90187,14 +90254,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;
@@ -90292,9 +90359,9 @@ function estVotesBias(inferredSVpoints, nDistricts) {
 }
 exports.estVotesBias = estVotesBias;
 // GEOMETRIC SEATS BIAS (@ V = statewide vote share)
-function estGeometricSeatsBias(Vf, inferredSVpoints) {
+function estGeometricSeatsBias(Vf, dSVpoints, rSVpoints) {
     let BsGf = undefined;
-    const bgsSVpoints = inferGeometricSeatsBiasPoints(inferredSVpoints);
+    const bgsSVpoints = inferGeometricSeatsBiasPoints(dSVpoints, rSVpoints);
     // Interpolate the seat fraction @ Vf
     const lowerPt = findBracketingLowerVf(Vf, bgsSVpoints);
     const upperPt = findBracketingUpperVf(Vf, bgsSVpoints);
@@ -90307,14 +90374,13 @@ function estGeometricSeatsBias(Vf, inferredSVpoints) {
     return BsGf;
 }
 exports.estGeometricSeatsBias = estGeometricSeatsBias;
-function inferGeometricSeatsBiasPoints(inferredSVpoints) {
-    const nPoints = inferredSVpoints.length;
-    const inverseSVpoints = invertSVPoints(inferredSVpoints);
+function inferGeometricSeatsBiasPoints(dSVpoints, rSVpoints) {
+    const nPoints = dSVpoints.length;
     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 Vf = dSVpoints[i].v;
+        const sD = dSVpoints[i].s;
+        const sR = rSVpoints[i].s;
         const BsGf = 0.5 * (sR - sD);
         bgsSVpoints.push({ v: Vf, s: BsGf });
     }
@@ -90473,11 +90539,10 @@ function calcLopsidedOutcomes(VfArray) {
 }
 exports.calcLopsidedOutcomes = calcLopsidedOutcomes;
 // GLOBAL SYMMETRY - Fig. 17 in Section 5.1
-function calcGlobalSymmetry(inferredSVpoints, S50V) {
-    const invertedSVpoints = invertSVPoints(inferredSVpoints);
+function calcGlobalSymmetry(dSVpoints, rSVpoints, S50V) {
     let gSym = 0.0;
-    for (let i in inferredSVpoints) {
-        gSym += Math.abs(inferredSVpoints[i].s - invertedSVpoints[i].s) / 2;
+    for (let i in dSVpoints) {
+        gSym += Math.abs(dSVpoints[i].s - rSVpoints[i].s) / 2;
     }
     const sign = (S50V < 0) ? -1 : 1;
     gSym *= sign;
@@ -90537,7 +90602,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) {
@@ -90550,21 +90615,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;
 
@@ -90694,11 +90762,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
@@ -90707,8 +90775,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;
 
@@ -102853,6 +102923,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);