@dra2020/dra-analytics 4.1.7 → 5.0.0

package/README.md

@@ -23,7 +23,9 @@ them for several elections, one at a time, and then generate statistics for them
 This repo & package can be integrated into other tools.
 The libraries here are normally included like this:
 
-    import { Compactness, Equal, Graph, Minority, Partisan, Splitting } from '@dra2020/dra-analytics';
+```TypeScript
+import { Compactness, Equal, Graph, Minority, Partisan, Splitting } from '@dra2020/dra-analytics';
+```
 
 Then the various functions of the different sets are available under their appropriate symbol.
 

package/cli/partisan.ts

@@ -161,10 +161,10 @@ export function printPartisanDetailsRow(xx: string, name: string, N: number, Vf:
     (s.bias.gamma) ? trim(s.bias.gamma) : s.bias.gamma,
 
     trim(s.bias.deviation),                                                                  // Simple deviation from best # of seats
-    // (s.experimental.lProp) ? trim(s.experimental.lProp) : s.experimental.lProp,
-    (s.experimental.lPropAlt) ? trim(s.experimental.lPropAlt) : s.experimental.lPropAlt,
-    // trim(s.impact.unearnedS),
-    (s.experimental.lUE) ? trim(s.experimental.lUE) : s.experimental.lUE
-    // (s.experimental.lSym) ? trim(s.experimental.lSym) : s.experimental.lSym,
+    // // (s.experimental.lProp) ? trim(s.experimental.lProp) : s.experimental.lProp,
+    // (s.experimental.lPropAlt) ? trim(s.experimental.lPropAlt) : s.experimental.lPropAlt,
+    // // trim(s.impact.unearnedS),
+    // (s.experimental.lUE) ? trim(s.experimental.lUE) : s.experimental.lUE
+    // // (s.experimental.lSym) ? trim(s.experimental.lSym) : s.experimental.lSym,
   );
 }

package/dist/dra-analytics.js

@@ -1844,11 +1844,11 @@ function makePartisanScorecard(Vf, VfArray, bLog = false) {
     //   distribution than Rd.
     const cD = (0, responsiveness_1.estCompetitiveDistricts)(VfArray);
     const cDf = (0, responsiveness_1.estCompetitiveDistrictsShare)(cD, N);
-    // EXPERIMENTAL
-    const lSym = (0, bias_1.estLocalAsymmetry)(Vf, dSVpoints, rSVpoints);
-    const lProp = (0, bias_1.estLocalDisproportionality)(Vf, dSVpoints);
-    const lPropAlt = (0, bias_1.estLocalDisproportionalityAlt)(Vf, N, dSVpoints);
-    const lUE = (0, bias_1.estLocalUnearnedSeats)(Vf, N, dSVpoints);
+    // // EXPERIMENTAL
+    // const lSym = estLocalAsymmetry(Vf, dSVpoints, rSVpoints);
+    // const lProp = estLocalDisproportionality(Vf, dSVpoints);
+    // const lPropAlt = estLocalDisproportionalityAlt(Vf, N, dSVpoints);
+    // const lUE = estLocalUnearnedSeats(Vf, N, dSVpoints);
     const biasMeasurements = {
         bestS: bestS,
         bestSf: bestSf,
@@ -1887,12 +1887,13 @@ function makePartisanScorecard(Vf, VfArray, 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;
-    const experimentalMetrics = {
-        lSym: lSym,
-        lProp: lProp,
-        lPropAlt: lPropAlt,
-        lUE: lUE
-    };
+    // // EXPERIMENTAL
+    // const experimentalMetrics: T.Experimental = {
+    //   lSym: lSym,
+    //   lProp: lProp,
+    //   lPropAlt: lPropAlt,
+    //   lUE: lUE
+    // };
     const s = {
         bias: biasMeasurements,
         impact: impactMeasurements,
@@ -1901,7 +1902,7 @@ function makePartisanScorecard(Vf, VfArray, bLog = false) {
         rSVpoints: rSVpoints,
         averageDVf: averageDVf,
         averageRVf: averageRVf,
-        experimental: experimentalMetrics,
+        // experimental: experimentalMetrics,
         details: {}
     };
     return s;
@@ -1986,14 +1987,6 @@ exports.calcDisproportionality = calcDisproportionality;
 exports.calcBigR = calcBigR;
 exports.calcMinimalInverseResponsiveness = calcMinimalInverseResponsiveness;
 exports.calcGamma = calcGamma;
-exports.estLocalAsymmetry = estLocalAsymmetry;
-exports.rangeAsymmetry = rangeAsymmetry;
-exports.estLocalDisproportionality = estLocalDisproportionality;
-exports.rangeDisproportionality = rangeDisproportionality;
-exports.estLocalDisproportionalityAlt = estLocalDisproportionalityAlt;
-exports.rangeDisproportionalityAlt = rangeDisproportionalityAlt;
-exports.estLocalUnearnedSeats = estLocalUnearnedSeats;
-exports.rangeUnearnedSeats = rangeUnearnedSeats;
 const U = __importStar(__webpack_require__(/*! ../utils/all */ "./lib/utils/all.ts"));
 const C = __importStar(__webpack_require__(/*! ../rate/dra-config */ "./lib/rate/dra-config.ts"));
 const method_1 = __webpack_require__(/*! ./method */ "./lib/partisan/method.ts");
@@ -2353,111 +2346,123 @@ function calcGamma(Vf, Sf, r) {
     const g = 0.5 + (r * (Vf - 0.5)) - Sf;
     return g;
 }
-// EXPERIMENTAL
-const pctWidth = 5; // The size in % points of the 'local' window to bracket <V>
-// Average local asymmetry
-function estLocalAsymmetry(Vf, dSVpoints, rSVpoints) {
-    try {
-        const dPts = svPointRange(Vf, dSVpoints);
-        const rPts = svPointRange(Vf, rSVpoints);
-        if (!dPts || !rPts)
-            return undefined;
-        const lSym = rangeAsymmetry(dPts, rPts);
-        return lSym;
-    }
-    catch (err) {
-        console.log("Exception in estLocalAsymmetry ...");
-        return undefined;
-    }
-}
-function rangeAsymmetry(dSVpoints, rSVpoints) {
-    const ndPts = dSVpoints.length;
-    const nrPts = rSVpoints.length;
-    console.assert(ndPts == nrPts, "# of D & R points don't match: ", ndPts, nrPts);
-    let tot = 0.0;
-    for (let i in dSVpoints) {
-        tot += calcGeometricSeatsBias(dSVpoints[i].s, rSVpoints[i].s);
-    }
-    return tot / ndPts;
-}
-// Average local disproportionality
-function estLocalDisproportionality(Vf, dSVpoints) {
-    try {
-        const dPts = svPointRange(Vf, dSVpoints);
-        if (!dPts)
-            return undefined;
-        const lProp = rangeDisproportionality(dPts);
-        return lProp;
-    }
-    catch (err) {
-        console.log("Exception in estLocalDisproportionality ...");
-        return undefined;
-    }
-}
-function rangeDisproportionality(dSVpoints) {
-    const ndPts = dSVpoints.length;
-    let tot = 0.0;
-    for (let i in dSVpoints) {
-        tot += calcProp(dSVpoints[i].v, dSVpoints[i].s);
-    }
-    return tot / ndPts;
-}
-// Average local disproportionality from the best # of seats (closest to proportional)
-function estLocalDisproportionalityAlt(Vf, N, dSVpoints) {
-    const dPts = svPointRange(Vf, dSVpoints);
-    if (!dPts)
-        return undefined;
-    const lPropAlt = rangeDisproportionalityAlt(N, dPts);
-    return lPropAlt;
-}
-// Dynamically calculate the best # seats, so this is a step function
-function rangeDisproportionalityAlt(N, dSVpoints) {
-    const ndPts = dSVpoints.length;
-    let tot = 0.0;
-    for (let i in dSVpoints) {
-        const bestS = bestSeats(N, dSVpoints[i].v);
-        const bestSf = bestSeatShare(bestS, N);
-        tot += calcDisproportionalityFromBest(dSVpoints[i].s, bestSf);
-    }
-    return tot / ndPts;
-}
-// Average local unearned seats from the best # of seats (closest to proportional)
-function estLocalUnearnedSeats(Vf, N, dSVpoints) {
-    const dPts = svPointRange(Vf, dSVpoints);
-    if (!dPts)
-        return undefined;
-    const lUE = rangeUnearnedSeats(N, dPts);
-    return lUE;
-}
-function rangeUnearnedSeats(N, dSVpoints) {
-    const ndPts = dSVpoints.length;
-    let tot = 0.0;
-    for (let i in dSVpoints) {
-        const estS = dSVpoints[i].s * N;
-        const bestS = bestSeats(N, dSVpoints[i].v);
-        tot += estUnearnedSeats(bestS, estS);
-    }
-    return tot / ndPts;
-}
-// Filter the full [0.25–0.75] range of S–V points down to the 'local' range.
-// Make sure that range is w/in the full range.
-function svPointRange(Vf, svPoints) {
-    const svRange = [0.25, 0.75]; // The range over which we infer the S–V curve points
-    const halfStep = (1 / 100) / 2; // The V point increments, i.e., every half a percent
-    const localWindow = pctWidth / 100; // # of % points wide as a fraction
-    const plusMinus = localWindow / 2; // +/– % as a fraction
-    const delta = plusMinus + (halfStep / 2); // +/– % plus half a half step to deal w/ floating point precision
-    if ((Vf < svRange[0]) || (Vf > svRange[1]))
-        return undefined;
-    const bracketingVs = [
-        (0, method_1.findBracketingLowerVf)(Vf, svPoints).v,
-        (0, method_1.findBracketingUpperVf)(Vf, svPoints).v
-    ];
-    const localRange = [bracketingVs[0] - delta, bracketingVs[1] + delta];
-    const subsetPts = svPoints.filter(x => inRange(x, localRange));
-    return subsetPts;
-}
-const inRange = (pt, range) => { return (pt.v >= range[0]) && (pt.v <= range[1]); };
+// // EXPERIMENTAL
+// const pctWidth = 5;  // The size in % points of the 'local' window to bracket <V>
+// // Average local asymmetry
+// export function estLocalAsymmetry(Vf: number, dSVpoints: T.SVpoint[], rSVpoints: T.SVpoint[]): number | undefined
+// {
+//   try
+//   {
+//     const dPts = svPointRange(Vf, dSVpoints);
+//     const rPts = svPointRange(Vf, rSVpoints);
+//     if (!dPts || !rPts) return undefined;
+//     const lSym: number = rangeAsymmetry(dPts, rPts);
+//     return lSym;
+//   }
+//   catch (err)
+//   {
+//     console.log("Exception in estLocalAsymmetry ...");
+//     return undefined;
+//   }
+// }
+// export function rangeAsymmetry(dSVpoints: T.SVpoint[], rSVpoints: T.SVpoint[]): number
+// {
+//   const ndPts: number = dSVpoints.length;
+//   const nrPts: number = rSVpoints.length;
+//   console.assert(ndPts == nrPts, "# of D & R points don't match: ", ndPts, nrPts);
+//   let tot: number = 0.0;
+//   for (let i in dSVpoints)
+//   {
+//     tot += calcGeometricSeatsBias(dSVpoints[i].s, rSVpoints[i].s);
+//   }
+//   return tot / ndPts;
+// }
+// // Average local disproportionality
+// export function estLocalDisproportionality(Vf: number, dSVpoints: T.SVpoint[]): number | undefined
+// {
+//   try
+//   {
+//     const dPts = svPointRange(Vf, dSVpoints);
+//     if (!dPts) return undefined;
+//     const lProp: number = rangeDisproportionality(dPts);
+//     return lProp;
+//   }
+//   catch (err)
+//   {
+//     console.log("Exception in estLocalDisproportionality ...");
+//     return undefined;
+//   }
+// }
+// export function rangeDisproportionality(dSVpoints: T.SVpoint[]): number
+// {
+//   const ndPts: number = dSVpoints.length;
+//   let tot: number = 0.0;
+//   for (let i in dSVpoints)
+//   {
+//     tot += calcProp(dSVpoints[i].v, dSVpoints[i].s);
+//   }
+//   return tot / ndPts;
+// }
+// // Average local disproportionality from the best # of seats (closest to proportional)
+// export function estLocalDisproportionalityAlt(Vf: number, N: number, dSVpoints: T.SVpoint[]): number | undefined
+// {
+//   const dPts = svPointRange(Vf, dSVpoints);
+//   if (!dPts) return undefined;
+//   const lPropAlt: number = rangeDisproportionalityAlt(N, dPts);
+//   return lPropAlt;
+// }
+// // Dynamically calculate the best # seats, so this is a step function
+// export function rangeDisproportionalityAlt(N: number, dSVpoints: T.SVpoint[]): number
+// {
+//   const ndPts: number = dSVpoints.length;
+//   let tot: number = 0.0;
+//   for (let i in dSVpoints)
+//   {
+//     const bestS = bestSeats(N, dSVpoints[i].v);
+//     const bestSf = bestSeatShare(bestS, N);
+//     tot += calcDisproportionalityFromBest(dSVpoints[i].s, bestSf);
+//   }
+//   return tot / ndPts;
+// }
+// // Average local unearned seats from the best # of seats (closest to proportional)
+// export function estLocalUnearnedSeats(Vf: number, N: number, dSVpoints: T.SVpoint[]): number | undefined
+// {
+//   const dPts = svPointRange(Vf, dSVpoints);
+//   if (!dPts) return undefined;
+//   const lUE: number = rangeUnearnedSeats(N, dPts);
+//   return lUE;
+// }
+// export function rangeUnearnedSeats(N: number, dSVpoints: T.SVpoint[]): number
+// {
+//   const ndPts: number = dSVpoints.length;
+//   let tot: number = 0.0;
+//   for (let i in dSVpoints)
+//   {
+//     const estS: number = dSVpoints[i].s * N;
+//     const bestS = bestSeats(N, dSVpoints[i].v);
+//     tot += estUnearnedSeats(bestS, estS);
+//   }
+//   return tot / ndPts;
+// }
+// // Filter the full [0.25–0.75] range of S–V points down to the 'local' range.
+// // Make sure that range is w/in the full range.
+// function svPointRange(Vf: number, svPoints: T.SVpoint[]): T.SVpoint[] | undefined
+// {
+//   const svRange: number[] = [0.25, 0.75];            // The range over which we infer the S–V curve points
+//   const halfStep: number = (1 / 100) / 2;            // The V point increments, i.e., every half a percent
+//   const localWindow: number = pctWidth / 100;        // # of % points wide as a fraction
+//   const plusMinus: number = localWindow / 2;         // +/– % as a fraction
+//   const delta: number = plusMinus + (halfStep / 2);  // +/– % plus half a half step to deal w/ floating point precision
+//   if ((Vf < svRange[0]) || (Vf > svRange[1])) return undefined;
+//   const bracketingVs: number[] = [
+//     findBracketingLowerVf(Vf, svPoints).v,
+//     findBracketingUpperVf(Vf, svPoints).v
+//   ];
+//   const localRange: number[] = [bracketingVs[0] - delta, bracketingVs[1] + delta];
+//   const subsetPts: T.SVpoint[] = svPoints.filter(x => inRange(x, localRange));
+//   return subsetPts;
+// }
+// const inRange = (pt: T.SVpoint, range: number[]): boolean => {return (pt.v >= range[0]) && (pt.v <= range[1]);}
 
 
 /***/ }),