@dra2020/district-analytics 14.1.2 → 14.1.3

package/dist/district-analytics.js

@@ -46,6 +46,7 @@ exports.AnalyticsSession = void 0;
 const baseclient_1 = __webpack_require__(/*! @dra2020/baseclient */ "@dra2020/baseclient");
 // import * as DT from '@dra2020/dra-types';
 const Score = __importStar(__webpack_require__(/*! @dra2020/dra-score */ "@dra2020/dra-score"));
+const dra_analytics_1 = __webpack_require__(/*! @dra2020/dra-analytics */ "@dra2020/dra-analytics");
 const preprocess_1 = __webpack_require__(/*! ./preprocess */ "./src/preprocess.ts");
 const analyze_1 = __webpack_require__(/*! ./analyze */ "./src/analyze.ts");
 const score_1 = __webpack_require__(/*! ./score */ "./src/score.ts");
@@ -53,6 +54,7 @@ const results_1 = __webpack_require__(/*! ./results */ "./src/results.ts");
 const results_2 = __webpack_require__(/*! ./results */ "./src/results.ts");
 const minority_1 = __webpack_require__(/*! ./minority */ "./src/minority.ts");
 const D = __importStar(__webpack_require__(/*! ./_data */ "./src/_data.ts"));
+const M = __importStar(__webpack_require__(/*! ./minority */ "./src/minority.ts"));
 const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
 // import * as S from './settings';
 class AnalyticsSession {
@@ -108,13 +110,59 @@ class AnalyticsSession {
             (0, analyze_1.doAnalyzeDistricts)(this, bLog);
             // This does a little stuff that didn't get factored out into dra-score and then dra-analytics
             (0, analyze_1.doAnalyzePlan)(this, bLog);
-            // The main analytics are next
-            // Run legacy analytics
+            // THE MAIN ANALYTICS ARE NEXT
+            // Even though we don't save the profile (as I thought we would),
+            // we allow it to be exported, so keep generating it, and use it
+            // to gather the inputs to new analytics (as well as the legacy).
             this._profile = (0, score_1.profilePlan)(this, bLog);
-            this._scorecard = (0, score_1.scorePlan)(this, this._profile, bLog, overridesJSON);
-            // TODO: Run new analytics
-            // TODO: Compare the new & legacy scorecards
-            // TODO: Set a scorecard
+            let legacyScorecard = {};
+            let legacyScorecardAlt = {};
+            let newScorecard = {};
+            // LEGACY - Run legacy analytics
+            if (this.config.legacyanalytics) {
+                if (bLog)
+                    console.log("Running legacy analytics ...");
+                legacyScorecard = (0, score_1.scorePlan)(this, this._profile, bLog, overridesJSON);
+            }
+            // Construct a new/alternate scorecard
+            if (this.config.newanalytics) {
+                if (bLog)
+                    console.log("Running new analytics ...");
+                newScorecard = (0, score_1.computeMetrics)(this._profile, this.getGoodShapes(), bLog); // w/o ratings
+                newScorecard = (0, score_1.rateKeyDimensions)(newScorecard, this._profile, bLog); // w/  ratings
+                legacyScorecardAlt = (0, score_1.thunkScorecard)(newScorecard, bLog);
+                // Add minority notes
+                legacyScorecardAlt.minority.details['majorityMinority'] = M.getMajorityMinority(this);
+                legacyScorecardAlt.minority.details['vraPreclearance'] = M.getVRASection5(this);
+                // Compare the new & legacy scorecards
+                (0, score_1.compareScorecards)(legacyScorecardAlt, legacyScorecard, bLog);
+            }
+            // Use the new scorecard, after creating it
+            this._scorecard = (this.config.newanalytics) ? legacyScorecardAlt : legacyScorecard;
+            // Post-scorecard housekeeping - copied from scorePlan()
+            if (this.config.newanalytics) {
+                // Before returning, create a dummy population deviation test, for 
+                // doHasEqualPopulations() to use later.This is preserving the old calling sequence.
+                let test = this.getTest(4 /* PopulationDeviation */);
+                // Get the raw population deviation
+                const popDev = this._scorecard.populationDeviation.raw;
+                // Populate the test entry
+                test['score'] = popDev;
+                test['details'] = { 'maxDeviation': this._scorecard.populationDeviation.notes['maxDeviation'] };
+                // Populate the N+1 summary "district" in district.statistics
+                let totalPop = this.districts.table.totalPop;
+                let popDevPct = this.districts.table.popDevPct;
+                let totalVAP = this.districts.table.totalVAP;
+                const summaryRow = this.districts.numberOfRows() - 1;
+                totalPop[summaryRow] = this._profile.population.targetSize;
+                popDevPct[summaryRow] = popDev;
+                totalVAP[summaryRow] = Math.round(totalVAP[summaryRow] / this._profile.nDistricts);
+                // Added w/ new scorecard
+                // Use 'roughly' equal population from dra-analytics
+                let test2 = this.getTest(3 /* EqualPopulation */);
+                test2['score'] = newScorecard.populationDeviation.roughlyEqual;
+            }
+            // END main analytics
             (0, results_1.doAnalyzePostProcessing)(this, bLog);
         }
         catch (e) {
@@ -124,6 +172,29 @@ class AnalyticsSession {
         }
         return true;
     }
+    getGoodShapes() {
+        const rawShapes = this.districts.getDistrictShapes();
+        // Filter the real shapes & throw everything else away
+        let goodShapes = {};
+        goodShapes['type'] = "FeatureCollection";
+        goodShapes['features'] = [];
+        for (let i = 0; i < rawShapes.features.length; i++) {
+            const shape = rawShapes.features[i];
+            if (isAShape(shape)) {
+                const d = baseclient_1.Poly.polyDescribe(shape);
+                let f = {
+                    type: 'Feature',
+                    properties: { districtID: `${i + 1}` },
+                    geometry: {
+                        type: (d.npoly > 1) ? 'MultiPolygon' : 'Polygon',
+                        coordinates: shape.geometry.coordinates
+                    }
+                };
+                goodShapes.features.push(f);
+            }
+        }
+        return goodShapes;
+    }
     // 11-03-2020 - Added for racially polarized voting analysis
     // NOTE - This assumes that analyzePlan() has been run!
     analyzeRacialPolarization(districtID, groups, bLog = false) {
@@ -196,15 +267,29 @@ class AnalyticsSession {
         // Return a pointer to the the test entry for this test
         return this.tests[testID];
     }
+    // LEGACY - Threshold defined in dra-analytics for new analytics
     // NOTE - Not sure why this has to be up here ...
     populationDeviationThreshold() {
-        // NOTE - This assumes the plan has been profiled
-        const scorer = new Score.Scorer();
-        const threshold = scorer.populationDeviationThreshold(this.legislativeDistricts); // TODO - 2020
+        let threshold;
+        if (this.config.legacyanalytics && !this.config.newanalytics) {
+            // NOTE - This assumes the plan has been profiled
+            const scorer = new Score.Scorer();
+            threshold = scorer.populationDeviationThreshold(this.legislativeDistricts); // TODO - 2020
+        }
+        else {
+            threshold = dra_analytics_1.Rate.popdevThreshold(this.legislativeDistricts);
+        }
         return threshold;
     }
 }
 exports.AnalyticsSession = AnalyticsSession;
+function isAShape(poly) {
+    if (poly == null)
+        return false;
+    if (baseclient_1.Poly.polyNull(poly))
+        return false;
+    return poly.geometry && poly.geometry.coordinates && !U.isArrayEmpty(poly.geometry.coordinates);
+}
 
 
 /***/ }),
@@ -1449,6 +1534,7 @@ function isAShape(poly) {
     return poly.geometry && poly.geometry.coordinates && !U.isArrayEmpty(poly.geometry.coordinates);
 }
 // SCORE KIWYSI COMPACTNESS
+// LEGACY
 function scoreKIWYSICompactness(s, bLog = false) {
     const rawShapes = s.districts.getDistrictShapes();
     // Filter the real shapes & throw everything else away
@@ -1528,17 +1614,20 @@ function doHasEqualPopulations(s, bLog = false) {
     let popDevTest = s.getTest(4 /* PopulationDeviation */);
     const popDevPct = popDevTest['score'];
     const popDevNormalized = popDevTest['normalizedScore'];
-    // 09-19-2020 - Added to catch edge case of only one non-empty district
-    const p = s._profile;
-    const totPopByDistrict = p.population.byDistrict.filter(x => x > 0);
-    const bTwoOrMoreDistricts = (totPopByDistrict.length > 1) ? true : false;
-    // Populate the test entry
-    if (bTwoOrMoreDistricts && (popDevNormalized > 0)) {
-        test['score'] = true;
-    }
-    else {
-        test['score'] = false;
-    }
+    // LEGACY - Has 'roughly' equal populations is calculated in dra-analytics
+    if (s.config.legacyanalytics && !s.config.newanalytics) {
+        // 09-19-2020 - Added to catch edge case of only one non-empty district
+        const p = s._profile;
+        const totPopByDistrict = p.population.byDistrict.filter(x => x > 0);
+        const bTwoOrMoreDistricts = (totPopByDistrict.length > 1) ? true : false;
+        // Populate the test entry
+        if (bTwoOrMoreDistricts && (popDevNormalized > 0)) {
+            test['score'] = true;
+        }
+        else {
+            test['score'] = false;
+        }
+    } // end
     test['details']['deviation'] = popDevPct;
     test['details']['thresholds'] = popDevTest['details']['scale'];
     // Populate the N+1 summary "district" in district.statistics
@@ -1573,7 +1662,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.uncertaintyOfMembership = exports.effectiveSplits = exports.avgSVError = exports.isAntimajoritarian = exports.ratePartisanBias = exports.inferSelectedMinority = exports.fieldForFeature = exports.geoIDForFeature = void 0;
+exports.uncertaintyOfMembership = exports.effectiveSplits = exports.avgSVError = exports.isAntimajoritarian = exports.ratePartisanBias = exports.estSeatProbability = exports.inferSelectedMinority = exports.fieldForFeature = exports.geoIDForFeature = void 0;
 __exportStar(__webpack_require__(/*! ./_api */ "./src/_api.ts"), exports);
 var _data_1 = __webpack_require__(/*! ./_data */ "./src/_data.ts");
 Object.defineProperty(exports, "geoIDForFeature", ({ enumerable: true, get: function () { return _data_1.geoIDForFeature; } }));
@@ -1584,6 +1673,7 @@ __exportStar(__webpack_require__(/*! ./types */ "./src/types.ts"), exports);
 __exportStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"), exports);
 // Re-export RPV types and COI splitting functions
 const dra_analytics_1 = __webpack_require__(/*! @dra2020/dra-analytics */ "@dra2020/dra-analytics");
+exports.estSeatProbability = dra_analytics_1.Partisan.estSeatProbability;
 exports.ratePartisanBias = dra_analytics_1.Rate.ratePartisanBias;
 exports.isAntimajoritarian = dra_analytics_1.Rate.isAntimajoritarian;
 exports.avgSVError = dra_analytics_1.Rate.avgSVError;
@@ -2028,6 +2118,7 @@ function doAnalyzePostProcessing(s, bLog = false) {
     scorecard.splitting.details['countiesWithSplits'] = simpleSplits['details']['countiesWithSplits'];
     // NOTE - Add split precincts in dra-client directly
     // Derive secondary tests
+    // Note - The only secondary test is 'roughly equal population (true/false)
     (0, analyze_1.doDeriveSecondaryTests)(s, bLog);
     // Toggle the semaphore, so postprocessing isn't for both the testlog & scorecard
     s.bPostProcessingDone = true;
@@ -2067,11 +2158,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.scorePlan = exports.getStatewideDemographics = exports.profilePlan = void 0;
+exports.compareScorecards = exports.thunkScorecard = exports.rateKeyDimensions = exports.computeMetrics = exports.scorePlan = exports.getStatewideDemographics = exports.profilePlan = void 0;
 const Score = __importStar(__webpack_require__(/*! @dra2020/dra-score */ "@dra2020/dra-score"));
 const U = __importStar(__webpack_require__(/*! ./utils */ "./src/utils.ts"));
 const M = __importStar(__webpack_require__(/*! ./minority */ "./src/minority.ts"));
 const C = __importStar(__webpack_require__(/*! ./compact */ "./src/compact.ts"));
+const dra_analytics_1 = __webpack_require__(/*! @dra2020/dra-analytics */ "@dra2020/dra-analytics");
 // PROFILE A PLAN
 const KEEP_DECIMALS = 6;
 function profilePlan(s, bLog = false) {
@@ -2183,26 +2275,30 @@ function getStatewideDemographics(s, bLog = false) {
     return demographics;
 }
 exports.getStatewideDemographics = getStatewideDemographics;
-// SCORE A PLAN
+// SCORE A PLAN - Legacy using dra-score
+// LEGACY
 function scorePlan(s, p, bLog = false, overridesJSON) {
     let scorer = new Score.Scorer();
     const scorecard = scorer.score(p, overridesJSON);
-    // Before returning, create a dummy population deviation test, for 
-    // 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.populationDeviation.raw;
-    // Populate the test entry
-    test['score'] = popDev;
-    test['details'] = { 'maxDeviation': scorecard.populationDeviation.notes['maxDeviation'] };
-    // Populate the N+1 summary "district" in district.statistics
-    let totalPop = s.districts.table.totalPop;
-    let popDevPct = s.districts.table.popDevPct;
-    let totalVAP = s.districts.table.totalVAP;
-    const summaryRow = s.districts.numberOfRows() - 1;
-    totalPop[summaryRow] = p.population.targetSize;
-    popDevPct[summaryRow] = popDev;
-    totalVAP[summaryRow] = Math.round(totalVAP[summaryRow] / p.nDistricts);
+    // LEGACY POST-SCORECARD HOUSEKEEPING
+    if (s.config.legacyanalytics && !s.config.newanalytics) {
+        // Before returning, create a dummy population deviation test, for 
+        // 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.populationDeviation.raw;
+        // Populate the test entry
+        test['score'] = popDev;
+        test['details'] = { 'maxDeviation': scorecard.populationDeviation.notes['maxDeviation'] };
+        // Populate the N+1 summary "district" in district.statistics
+        let totalPop = s.districts.table.totalPop;
+        let popDevPct = s.districts.table.popDevPct;
+        let totalVAP = s.districts.table.totalVAP;
+        const summaryRow = s.districts.numberOfRows() - 1;
+        totalPop[summaryRow] = p.population.targetSize;
+        popDevPct[summaryRow] = popDev;
+        totalVAP[summaryRow] = Math.round(totalVAP[summaryRow] / p.nDistricts);
+    } // end
     // Add minority notes
     scorecard.minority.details['majorityMinority'] = M.getMajorityMinority(s);
     scorecard.minority.details['vraPreclearance'] = M.getVRASection5(s);
@@ -2227,6 +2323,432 @@ function scorePlan(s, p, bLog = false, overridesJSON) {
     return scorecard;
 }
 exports.scorePlan = scorePlan;
+// SCORE A PLAN - New using dra-analytics
+function computeMetrics(p, districtShapes, bLog = false) {
+    if (bLog)
+        console.log("Computing metrics ...");
+    const bLegislative = p.bStateLeg;
+    // Calculate bias & responsiveness metrics ...
+    const byDistrictVf = p.partisanship.byDistrict;
+    const statewideVf = p.partisanship.statewide;
+    let _pS = dra_analytics_1.Partisan.makePartisanScorecard(statewideVf, byDistrictVf, bLog);
+    // Calculate minority representation metrics ...
+    const statewideDemos = p.demographics.statewide;
+    const byDistrictDemos = p.demographics.byDistrict;
+    let _mS = dra_analytics_1.Minority.makeMinorityScorecard(statewideDemos, byDistrictDemos, bLog);
+    // Calculate compactness metrics ...
+    let _cS = dra_analytics_1.Compactness.makeCompactnessScorecard(districtShapes, bLog);
+    // Calculate county-district splitting metrics ...
+    const CxD = p.counties;
+    const _sS = dra_analytics_1.Splitting.makeSplittingScorecard(CxD, bLog);
+    // Calculate population deviation-related metrics ...
+    const totPopByDistrict = p.population.byDistrict;
+    const targetSize = p.population.targetSize;
+    const _pdS = dra_analytics_1.Equal.makePopulationScorecard(totPopByDistrict, targetSize, bLegislative, bLog);
+    const details = {};
+    // Assemble the pieces into new scorecard
+    const scorecard = {
+        partisan: _pS,
+        minority: _mS,
+        compactness: _cS,
+        splitting: _sS,
+        populationDeviation: _pdS,
+        details: details,
+        scratchpad: {} // Hack to pass legacy values between processing steps
+    };
+    return scorecard;
+}
+exports.computeMetrics = computeMetrics;
+function rateKeyDimensions(scorecard, p, bLog = false) {
+    if (bLog)
+        console.log("Rating key dimensions ...");
+    const bLegislative = p.bStateLeg;
+    // Rate proportionality
+    const statewideVf = p.partisanship.statewide;
+    const Sf = scorecard.partisan.bias.estSf;
+    scorecard.partisan.bias.score = dra_analytics_1.Rate.rateProportionality(scorecard.partisan.bias.deviation, statewideVf, Sf);
+    // Rate competititveness
+    scorecard.partisan.responsiveness.score = dra_analytics_1.Rate.rateCompetitiveness(scorecard.partisan.responsiveness.cDf);
+    // Rate minority representation
+    const rawOd = scorecard.minority.opportunityDistricts;
+    const pOd = scorecard.minority.proportionalOpportunities;
+    const rawCd = scorecard.minority.coalitionDistricts;
+    const pCd = scorecard.minority.proportionalCoalitions;
+    scorecard.minority.score = dra_analytics_1.Rate.rateMinorityRepresentation(rawOd, pOd, rawCd, pCd);
+    // Rate compactness
+    const avgReock = scorecard.compactness.avgReock;
+    const avgPolsby = scorecard.compactness.avgPolsby;
+    const reockRating = dra_analytics_1.Rate.rateReock(avgReock);
+    const polsbyRating = dra_analytics_1.Rate.ratePolsby(avgPolsby);
+    scorecard.compactness.score = dra_analytics_1.Rate.rateCompactness(reockRating, polsbyRating);
+    // Rate county- & district-splitting
+    const rawCountySplitting = scorecard.splitting.county;
+    const rawDistrictSplitting = scorecard.splitting.district;
+    const nCounties = p.nCounties;
+    const nDistricts = p.nDistricts;
+    const countyRating = dra_analytics_1.Rate.rateCountySplitting(rawCountySplitting, nCounties, nDistricts, bLegislative);
+    const districtRating = dra_analytics_1.Rate.rateDistrictSplitting(rawDistrictSplitting, bLegislative);
+    const unadjusted = dra_analytics_1.Rate.rateSplitting(countyRating, districtRating);
+    scorecard.splitting.score = dra_analytics_1.Rate.adjustSplittingRating(unadjusted, rawCountySplitting, rawDistrictSplitting);
+    // Rate population deviation
+    const rawDeviation = scorecard.populationDeviation.deviation;
+    scorecard.populationDeviation.score = dra_analytics_1.Rate.ratePopulationDeviation(rawDeviation, bLegislative);
+    // Squirrel away normalized compactness & splitting ratings for the legacy scorecard
+    const keep = {
+        reockScore: reockRating,
+        polsbyScore: polsbyRating,
+        countyScore: countyRating,
+        districtScore: districtRating
+    };
+    scorecard.scratchpad = keep;
+    return scorecard;
+}
+exports.rateKeyDimensions = rateKeyDimensions;
+function thunkScorecard(newScorecard, bLog = false) {
+    if (bLog)
+        console.log("Thunking new scorecard into legacy structure ...");
+    const scratchpad = newScorecard.scratchpad;
+    // Partisan scorecard
+    const pS = U.deepCopy(newScorecard.partisan);
+    // Minority scorecard
+    const mS = U.deepCopy(newScorecard.minority);
+    // Compactness scorecard
+    const reockM = {
+        raw: newScorecard.compactness.avgReock,
+        normalized: scratchpad.reockScore,
+        notes: {}
+    };
+    const polsbyM = {
+        raw: newScorecard.compactness.avgPolsby,
+        normalized: scratchpad.polsbyScore,
+        notes: {}
+    };
+    let cS = {
+        score: newScorecard.compactness.score,
+        reock: reockM,
+        polsby: polsbyM,
+        details: U.deepCopy(newScorecard.compactness.details)
+    };
+    // Relocate byDistrict compactness #'s
+    cS.details.byDistrict = U.deepCopy(newScorecard.compactness.byDistrict);
+    // Add KIWYSI compactness score
+    cS.details['kiwysi'] = newScorecard.compactness.avgKWIWYSI;
+    // Splitting scorecard
+    const countyM = {
+        raw: newScorecard.splitting.county,
+        normalized: scratchpad.countyScore,
+        notes: {}
+    };
+    const districtM = {
+        raw: newScorecard.splitting.district,
+        normalized: scratchpad.districtScore,
+        notes: {}
+    };
+    const sS = {
+        score: newScorecard.splitting.score,
+        county: countyM,
+        district: districtM,
+        details: U.deepCopy(newScorecard.splitting.details)
+    };
+    // Population (equality) scorecard
+    const pdM = {
+        raw: newScorecard.populationDeviation.deviation,
+        normalized: newScorecard.populationDeviation.score,
+        notes: newScorecard.populationDeviation.notes
+    };
+    const pdS = pdM;
+    const scorecard = {
+        partisan: pS,
+        minority: mS,
+        compactness: cS,
+        splitting: sS,
+        populationDeviation: pdS,
+        details: newScorecard.details
+    };
+    return scorecard;
+}
+exports.thunkScorecard = thunkScorecard;
+function compareScorecards(altLegacyScorecard, legacyScorecard, bLog = false) {
+    if (bLog)
+        console.log("Comparing new & legacy scorecards ...");
+    // A pretty loose tolerance, because we're not trimming values in the new analytics
+    const DECIMAL_PLACES = 2;
+    const DEFAULT_TOLERANCE = toleranceFn(DECIMAL_PLACES);
+    // COMPARE PARTISAN SCORECARD
+    // Compare BIAS section
+    matchFloats("bestS", altLegacyScorecard.partisan.bias.bestS, legacyScorecard.partisan.bias.bestS, DEFAULT_TOLERANCE);
+    matchFloats("bestSf", altLegacyScorecard.partisan.bias.bestSf, legacyScorecard.partisan.bias.bestSf, DEFAULT_TOLERANCE);
+    matchFloats("estS", altLegacyScorecard.partisan.bias.estS, legacyScorecard.partisan.bias.estS, DEFAULT_TOLERANCE);
+    matchFloats("estSf", altLegacyScorecard.partisan.bias.estSf, legacyScorecard.partisan.bias.estSf, DEFAULT_TOLERANCE);
+    matchFloats("deviation", altLegacyScorecard.partisan.bias.deviation, legacyScorecard.partisan.bias.deviation, DEFAULT_TOLERANCE);
+    matchInts("proportionality/score", altLegacyScorecard.partisan.bias.score, legacyScorecard.partisan.bias.score);
+    matchFloats("tOf", altLegacyScorecard.partisan.bias.tOf, legacyScorecard.partisan.bias.tOf, DEFAULT_TOLERANCE);
+    matchFloats("fptpS", altLegacyScorecard.partisan.bias.fptpS, legacyScorecard.partisan.bias.fptpS, DEFAULT_TOLERANCE);
+    matchFloats("bS50", altLegacyScorecard.partisan.bias.bS50, legacyScorecard.partisan.bias.bS50, DEFAULT_TOLERANCE);
+    matchFloats("deviation", altLegacyScorecard.partisan.bias.deviation, legacyScorecard.partisan.bias.deviation, DEFAULT_TOLERANCE);
+    matchUndefinableFloats("decl", altLegacyScorecard.partisan.bias.decl, legacyScorecard.partisan.bias.decl, toleranceFn(1));
+    let rvPointsAlt = altLegacyScorecard.partisan.bias.rvPoints;
+    let rvPoints = legacyScorecard.partisan.bias.rvPoints;
+    if (matchUndefinedness("rvPoints", rvPointsAlt, rvPoints)) {
+        rvPointsAlt = rvPointsAlt;
+        rvPoints = rvPoints;
+        matchFloats("rvPoints/Sb", rvPointsAlt.Sb, rvPoints.Sb, DEFAULT_TOLERANCE);
+        matchFloats("rvPoints/Ra", rvPointsAlt.Ra, rvPoints.Ra, DEFAULT_TOLERANCE);
+        matchFloats("rvPoints/Rb", rvPointsAlt.Rb, rvPoints.Rb, DEFAULT_TOLERANCE);
+        matchFloats("rvPoints/Va", rvPointsAlt.Va, rvPoints.Va, DEFAULT_TOLERANCE);
+        matchFloats("rvPoints/Vb", rvPointsAlt.Vb, rvPoints.Vb, DEFAULT_TOLERANCE);
+    }
+    matchFloats("gSym", altLegacyScorecard.partisan.bias.gSym, legacyScorecard.partisan.bias.gSym, DEFAULT_TOLERANCE);
+    matchUndefinableFloats("gamma", altLegacyScorecard.partisan.bias.gamma, legacyScorecard.partisan.bias.gamma, DEFAULT_TOLERANCE);
+    matchFloats("eG", altLegacyScorecard.partisan.bias.eG, legacyScorecard.partisan.bias.eG, DEFAULT_TOLERANCE);
+    matchUndefinableFloats("bSV", altLegacyScorecard.partisan.bias.bSV, legacyScorecard.partisan.bias.bSV, DEFAULT_TOLERANCE);
+    matchFloats("prop", altLegacyScorecard.partisan.bias.prop, legacyScorecard.partisan.bias.prop, DEFAULT_TOLERANCE);
+    matchFloats("mMs", altLegacyScorecard.partisan.bias.mMs, legacyScorecard.partisan.bias.mMs, DEFAULT_TOLERANCE);
+    matchFloats("mMd", altLegacyScorecard.partisan.bias.mMd, legacyScorecard.partisan.bias.mMd, DEFAULT_TOLERANCE);
+    matchUndefinableFloats("lO", altLegacyScorecard.partisan.bias.lO, legacyScorecard.partisan.bias.lO, DEFAULT_TOLERANCE);
+    // Compare Impact section
+    matchFloats("unearnedS", altLegacyScorecard.partisan.impact.unearnedS, legacyScorecard.partisan.impact.unearnedS, DEFAULT_TOLERANCE);
+    // Note - We don't use the impact score, so we don't compute it in the new scorecard.
+    // matchInts("impact/score", altLegacyScorecard.partisan.impact.score as number, legacyScorecard.partisan.impact.score);
+    // Compare Responsiveness section
+    matchUndefinableFloats("bigR", altLegacyScorecard.partisan.responsiveness.bigR, legacyScorecard.partisan.responsiveness.bigR, DEFAULT_TOLERANCE);
+    matchUndefinableFloats("littleR", altLegacyScorecard.partisan.responsiveness.littleR, legacyScorecard.partisan.responsiveness.littleR, DEFAULT_TOLERANCE);
+    matchUndefinableFloats("mIR", altLegacyScorecard.partisan.responsiveness.mIR, legacyScorecard.partisan.responsiveness.mIR, DEFAULT_TOLERANCE);
+    matchFloats("rD", altLegacyScorecard.partisan.responsiveness.rD, legacyScorecard.partisan.responsiveness.rD, DEFAULT_TOLERANCE);
+    matchFloats("rDf", altLegacyScorecard.partisan.responsiveness.rDf, legacyScorecard.partisan.responsiveness.rDf, DEFAULT_TOLERANCE);
+    matchFloats("cSimple", altLegacyScorecard.partisan.responsiveness.cSimple, legacyScorecard.partisan.responsiveness.cSimple, DEFAULT_TOLERANCE);
+    matchFloats("cD", altLegacyScorecard.partisan.responsiveness.cD, legacyScorecard.partisan.responsiveness.cD, DEFAULT_TOLERANCE);
+    matchFloats("cDf", altLegacyScorecard.partisan.responsiveness.cDf, legacyScorecard.partisan.responsiveness.cDf, DEFAULT_TOLERANCE);
+    matchInts("competitiveness/score", altLegacyScorecard.partisan.responsiveness.score, legacyScorecard.partisan.responsiveness.score);
+    matchPointArrays("dSVpoints", altLegacyScorecard.partisan.dSVpoints, legacyScorecard.partisan.dSVpoints, DEFAULT_TOLERANCE);
+    matchPointArrays("rSVpoints", altLegacyScorecard.partisan.rSVpoints, legacyScorecard.partisan.rSVpoints, DEFAULT_TOLERANCE);
+    matchUndefinableFloats("averageDVf", altLegacyScorecard.partisan.averageDVf, legacyScorecard.partisan.averageDVf, DEFAULT_TOLERANCE);
+    matchUndefinableFloats("averageRVf", altLegacyScorecard.partisan.averageRVf, legacyScorecard.partisan.averageRVf, DEFAULT_TOLERANCE);
+    matchDicts("partisan/details", altLegacyScorecard.partisan.details, legacyScorecard.partisan.details);
+    // COMPARE MINORITY SCORECARD
+    matchObjectsAndArrays("pivotByDemographic", altLegacyScorecard.minority.pivotByDemographic, legacyScorecard.minority.pivotByDemographic);
+    matchFloats("opportunityDistricts", altLegacyScorecard.minority.opportunityDistricts, legacyScorecard.minority.opportunityDistricts, DEFAULT_TOLERANCE);
+    matchFloats("coalitionDistricts", altLegacyScorecard.minority.coalitionDistricts, legacyScorecard.minority.coalitionDistricts, DEFAULT_TOLERANCE);
+    matchInts("minority/score", altLegacyScorecard.minority.score, legacyScorecard.minority.score);
+    matchDicts("minority/details", altLegacyScorecard.minority.details, legacyScorecard.minority.details);
+    // COMPARE COMPACTNESS SCORECARD
+    matchFloats("reock", altLegacyScorecard.compactness.reock.raw, legacyScorecard.compactness.reock.raw, DEFAULT_TOLERANCE);
+    matchInts("reock/normalized", altLegacyScorecard.compactness.reock.normalized, legacyScorecard.compactness.reock.normalized);
+    matchFloats("polsby", altLegacyScorecard.compactness.polsby.raw, legacyScorecard.compactness.polsby.raw, DEFAULT_TOLERANCE);
+    matchInts("polsby/normalized", altLegacyScorecard.compactness.polsby.normalized, legacyScorecard.compactness.polsby.normalized);
+    matchInts("compactness/score", altLegacyScorecard.compactness.score, legacyScorecard.compactness.score);
+    // Compare 'byDistrict' results separately
+    const _altCompactnessByDistrict = dra_analytics_1.Utils.deepCopy(altLegacyScorecard.compactness.details['byDistrict']);
+    const _CompactnessByDistrict = dra_analytics_1.Utils.deepCopy(legacyScorecard.compactness.details['byDistrict']);
+    const _altCompactnessDetails = dra_analytics_1.Utils.deepCopy(altLegacyScorecard.compactness.details);
+    const _CompactnessDetails = dra_analytics_1.Utils.deepCopy(legacyScorecard.compactness.details);
+    delete _altCompactnessDetails['byDistrict'];
+    delete _CompactnessDetails['byDistrict'];
+    matchDicts("compactness/details", _altCompactnessDetails, _CompactnessDetails);
+    matchCompactnessByDistrict("compactness/byDistrict", _altCompactnessByDistrict, _CompactnessByDistrict, DEFAULT_TOLERANCE);
+    // COMPARE SPLITTING SCORECARD
+    matchFloats("county", altLegacyScorecard.splitting.county.raw, legacyScorecard.splitting.county.raw, DEFAULT_TOLERANCE);
+    matchInts("county/normalized", altLegacyScorecard.splitting.county.normalized, legacyScorecard.splitting.county.normalized);
+    matchFloats("district", altLegacyScorecard.splitting.district.raw, legacyScorecard.splitting.district.raw, DEFAULT_TOLERANCE);
+    matchInts("district/normalized", altLegacyScorecard.splitting.district.normalized, legacyScorecard.splitting.district.normalized);
+    matchInts("splitting/score", altLegacyScorecard.splitting.score, legacyScorecard.splitting.score);
+    matchDicts("splitting/details", altLegacyScorecard.splitting.details, legacyScorecard.splitting.details);
+    // COMPARE POPULATION SCORECARD
+    matchFloats("popdev", altLegacyScorecard.populationDeviation.raw, legacyScorecard.populationDeviation.raw, DEFAULT_TOLERANCE);
+    matchInts("popdev/score", altLegacyScorecard.populationDeviation.normalized, legacyScorecard.populationDeviation.normalized);
+    matchDicts("popdev/notes", altLegacyScorecard.populationDeviation.notes, legacyScorecard.populationDeviation.notes);
+    matchDicts("details", altLegacyScorecard.details, legacyScorecard.details);
+}
+exports.compareScorecards = compareScorecards;
+// Matching helpers
+function matchFloats(property, received, good, tolerance) {
+    if (dra_analytics_1.Utils.areRoughlyEqual(received, good, tolerance)) {
+        return true;
+    }
+    else {
+        console.log(`${property} does not match: ${good} expected. Received ${received}.`);
+        return false;
+    }
+}
+function toleranceFn(places) {
+    return 0.5 / Math.pow(10, places);
+}
+function matchInts(property, received, good) {
+    if (received == good) {
+        return true;
+    }
+    else {
+        console.log(`${property} does not match: ${good} expected. Received ${received}.`);
+        return false;
+    }
+}
+function matchUndefinableFloats(property, received, good, tolerance) {
+    if ((received === undefined) && (good === undefined))
+        return true;
+    if ((received === undefined) || (good === undefined)) {
+        console.log(`${property} does not match: ${good} expected. Received ${received}.`);
+        return false;
+    }
+    return matchFloats(property, received, good, tolerance);
+}
+// https://stackoverflow.com/questions/13142968/deep-comparison-of-objects-arrays
+function matchObjectsAndArrays(property, received, good) {
+    if ((received === undefined) && (good === undefined))
+        return true; // Both undefined
+    if ((received === undefined) || (good === undefined)) { // One undefined but not the other
+        console.log(`${property} does not match: ${good} expected. Received ${received}.`);
+        return false;
+    }
+    if ((Object.keys(received).length === 0) && (Object.keys(good).length === 0))
+        return true; // Both empty
+    if (JSON.stringify(received) === JSON.stringify(good))
+        return true; // Contents match
+    console.log(`${property} objects or arrays do not match.`); // Contents don't match
+    return false;
+}
+function matchDicts(property, received, good) {
+    if ((Object.keys(received).length === 0) && (Object.keys(good).length === 0))
+        return true; // Both empty
+    const receivedStr = JSON.stringify(received);
+    const goodStr = JSON.stringify(good);
+    if (receivedStr === goodStr)
+        return true; // Contents match
+    console.log(`${property} does not match: ${goodStr} expected. Received ${receivedStr}.`); // Contents don't match
+    return false;
+}
+function matchUndefinedness(property, received, good) {
+    if ((received === undefined) && (good === undefined))
+        return true;
+    if ((received === undefined) || (good === undefined))
+        return false;
+    return true;
+}
+function matchPointArrays(property, received, good, tolerance) {
+    if (received.length != good.length) {
+        console.log(`${property} does not match: Different number of points.`);
+        return false;
+    }
+    for (var i = 0; i < received.length; i++) {
+        const vLabel = property + '/' + i.toString() + '/' + 'v';
+        const sLabel = property + '/' + i.toString() + '/' + 's';
+        if (!matchFloats(vLabel, received[i].v, good[i].v, tolerance))
+            return false;
+        if (!matchFloats(sLabel, received[i].s, good[i].s, tolerance))
+            return false;
+    }
+    return true;
+}
+function matchCompactnessByDistrict(property, received, good, tolerance) {
+    if (received.length != good.length) {
+        console.log(`${property} does not match: Different number of districts.`);
+        return false;
+    }
+    let bMismatched = false;
+    for (var i = 0; i < received.length; i++) {
+        const rawReock = property + '/' + i.toString() + '/' + 'rawReock';
+        if (!matchFloats(rawReock, received[i].rawReock, good[i].rawReock, tolerance))
+            bMismatched = true;
+        const normalizedReock = property + '/' + i.toString() + '/' + 'normalizedReock';
+        if (!matchInts(normalizedReock, received[i].normalizedReock, good[i].normalizedReock))
+            bMismatched = true;
+        const rawPolsby = property + '/' + i.toString() + '/' + 'rawPolsby';
+        if (!matchFloats(rawPolsby, received[i].rawPolsby, good[i].rawPolsby, tolerance))
+            bMismatched = true;
+        // 09-17-21 - By-district Polsby–Popper ratings from dra-score in production are wrong!
+        // const normalizedPolsby: string = property + '/' + i.toString() + '/' + 'normalizedPolsby';
+        // if (!matchInts(normalizedPolsby, received[i].normalizedPolsby, good[i].normalizedPolsby)) bMismatched = true;
+        const kiwysiScore = property + '/' + i.toString() + '/' + 'kiwysiScore';
+        if (!matchInts(kiwysiScore, received[i].kiwysiScore, good[i].kiwysiScore))
+            bMismatched = true;
+    }
+    if (bMismatched = true)
+        return false;
+    return true;
+}
+// Not used, after all
+/* Modeled after David Sielaff's Jest extension 'toBeArrayWithValuesCloseTo'
+
+function matchFloatArrays(property: string, received: Array<any>, expected: Array<any>, tolerance: number): boolean
+{
+  // Note - Not sure what this check was for ...
+  // if (expected.length == 0) {
+  //     return {
+  //         message: () => `expected arrays of same size`,
+  //         pass: received.length == 0
+  //     }
+  // }
+
+  if (typeof expected[0] === "number")
+  {
+    if (typeof received[0] === "number") return matchArrays1d(property, received, expected, tolerance);
+
+    console.log(`${property} does not match: array doesn't contain numbers.`);
+    return false;
+  }
+
+  // Note - Ditto
+  // if (expected[0].length == 0) {
+  //     return {
+  //         message: () => `expected arrays of same size`,
+  //         pass: received[0].length == 0
+  //     }
+  // }
+
+  if (expected[0] instanceof Array && typeof expected[0][0] === "number")
+  {
+    if (received[0] instanceof Array && typeof received[0][0] === "number") return matchArrays2d(property, received, expected, tolerance);
+
+    console.log(`${property} does not match: arrays don't have the same dimensionality and content.`);
+    return false;
+  }
+
+  console.log(`${property}: Expected 1d or 2d arrays.`);
+  return false;
+}
+
+function matchArrays1d(property: string, received: number[], expected: number[], tolerance: number): boolean
+{
+  if (received.length != expected.length)
+  {
+    console.log(`${property} does not match: arrays have different lengths.`);
+    return false;
+  }
+
+  for (var index = 0; index < received.length; index++)
+  {
+    const cell: string = property + '/' + index.toString();
+    if (!matchFloats(cell, received[index], expected[index], tolerance)) return false;
+  }
+
+  return true;
+}
+
+function matchArrays2d(property: string, received: number[][], expected: number[][], tolerance: number): boolean
+{
+  if (received.length != expected.length)
+  {
+    console.log(`${property} does not match: arrays have different lengths.`);
+    return false;
+  }
+
+  for (var index = 0; index < received.length; index++)
+  {
+    if (received[index].length != expected[index].length)
+    {
+      console.log(`${property} does not match: arrays have different lengths.`);
+      return false;
+    }
+
+    for (var inner = 0; inner < received[index].length; inner++)
+    {
+      const cell: string = property + '/' + index.toString() + '/' + inner.toString();
+      if (!matchFloats(cell, received[index][inner], expected[index][inner], tolerance)) return false;
+    }
+  }
+
+  return true;
+}
+*/ 
 
 
 /***/ }),
@@ -2242,24 +2764,27 @@ exports.scorePlan = scorePlan;
 // GLOBAL CONSTANTS
 //
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DISTRICT_SPLITTING_WEIGHT = exports.COUNTY_SPLITTING_WEIGHT = exports.EQUAL_TOLERANCE = exports.OUT_OF_STATE = exports.NUMBER_OF_ITEMS_TO_REPORT = exports.NOT_ASSIGNED = exports.NORMALIZED_RANGE = exports.PRECISION = void 0;
+exports.OUT_OF_STATE = exports.NUMBER_OF_ITEMS_TO_REPORT = exports.NOT_ASSIGNED = exports.PRECISION = void 0;
 // Keep four decimal places for fractions [0–1], i.e.,
 // keep two decimal places for %'s [0–100].
 exports.PRECISION = 4;
+// LEGACY - Not used
 // Normalized scores [0-100]
-exports.NORMALIZED_RANGE = 100;
+// export const NORMALIZED_RANGE: number = 100;
 // The dummy district ID for features not assigned districts yet
 exports.NOT_ASSIGNED = 0;
 // # of items to report as problematic (e.g., features, districts, etc.)
 exports.NUMBER_OF_ITEMS_TO_REPORT = 10;
 // The virtual geoID for "neighbors" in other states
 exports.OUT_OF_STATE = "OUT_OF_STATE";
+// LEGACY - Not used
 // "Roughly equal" = average census block size / 2
-const AVERAGE_BLOCK_SIZE = 30;
-exports.EQUAL_TOLERANCE = AVERAGE_BLOCK_SIZE / 2;
+// const AVERAGE_BLOCK_SIZE = 30;
+// export const EQUAL_TOLERANCE: number = AVERAGE_BLOCK_SIZE / 2;
+// LEGACY - Not used
 // County & district splitting weights
-exports.COUNTY_SPLITTING_WEIGHT = 0.8;
-exports.DISTRICT_SPLITTING_WEIGHT = 1.0 - exports.COUNTY_SPLITTING_WEIGHT;
+// export const COUNTY_SPLITTING_WEIGHT = 0.8;
+// export const DISTRICT_SPLITTING_WEIGHT = 1.0 - COUNTY_SPLITTING_WEIGHT;
 // 2020
 // export const SHAPES = "2010 VTD shapes";
 
@@ -2270,16 +2795,13 @@ exports.DISTRICT_SPLITTING_WEIGHT = 1.0 - exports.COUNTY_SPLITTING_WEIGHT;
 /*!**********************!*\
   !*** ./src/types.ts ***!
   \**********************/
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+/***/ ((__unused_webpack_module, exports) => {
 
 
 //
 // TYPE DEFINITIONS
 //
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.estSeatProbability = void 0;
-var dra_score_1 = __webpack_require__(/*! @dra2020/dra-score */ "@dra2020/dra-score");
-Object.defineProperty(exports, "estSeatProbability", ({ enumerable: true, get: function () { return dra_score_1.estSeatProbability; } }));
 // END
 
 
@@ -2315,21 +2837,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.depthof = exports.deepCopy = exports.shallowCopy = exports.countEnumValues = exports.objectContains = exports.arrayContains = exports.getSelectObjectKeys = exports.getNumericObjectKeys = exports.getObjectKeys = exports.isArrayEmpty = exports.isSetEmpty = exports.isObjectEmpty = exports.keyExists = exports.andArray = exports.initArray = exports.maxArray = exports.minArray = exports.avgArray = exports.sumArray = exports.trim = exports.isUninhabited = exports.isWaterOnly = exports.parseGeoID = exports.getDistrict = exports.isOutOfState = exports.isInState = void 0;
+exports.depthof = exports.deepCopy = exports.shallowCopy = exports.countEnumValues = exports.objectContains = exports.arrayContains = exports.getSelectObjectKeys = exports.getNumericObjectKeys = exports.getObjectKeys = exports.isArrayEmpty = exports.isSetEmpty = exports.isObjectEmpty = exports.keyExists = exports.andArray = exports.initArray = exports.maxArray = exports.minArray = exports.avgArray = exports.sumArray = exports.trim = exports.isUninhabited = exports.isWaterOnly = exports.parseGeoID = exports.getDistrict = void 0;
 const DT = __importStar(__webpack_require__(/*! @dra2020/dra-types */ "@dra2020/dra-types"));
 const _data_1 = __webpack_require__(/*! ./_data */ "./src/_data.ts");
 const S = __importStar(__webpack_require__(/*! ./settings */ "./src/settings.ts"));
 // PLAN HELPERS
+// LEGACY - Not used
 // Is a "neighbor" in state?
-function isInState(geoID) {
-    return geoID != S.OUT_OF_STATE;
-}
-exports.isInState = isInState;
+// export function isInState(geoID: string): boolean
+// {
+//   return geoID != S.OUT_OF_STATE;
+// }
+// LEGACY - Not used
 // Is a "neighbor" out of state?
-function isOutOfState(geoID) {
-    return geoID == S.OUT_OF_STATE;
-}
-exports.isOutOfState = isOutOfState;
+// export function isOutOfState(geoID: string): boolean
+// {
+//   return geoID == S.OUT_OF_STATE;
+// }
 // Get the districtID to which a geoID is assigned
 function getDistrict(plan, geoID) {
     // All geoIDs in a state *should be* assigned to a district (including the