powerball-quantum 1.0.0

package/dist/quantum.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateMomentum = calculateMomentum;
+exports.calculateZScores = calculateZScores;
+exports.calculateRecentMomentum = calculateRecentMomentum;
+exports.analyzePairFrequency = analyzePairFrequency;
+exports.weightedSample = weightedSample;
+exports.quantumSelect = quantumSelect;
+exports.checkSumRange = checkSumRange;
+exports.checkOddEvenRatio = checkOddEvenRatio;
+exports.checkHighLowBalance = checkHighLowBalance;
+exports.checkDecadeBalance = checkDecadeBalance;
+exports.checkEndingDiversity = checkEndingDiversity;
+exports.checkNoTripleConsecutive = checkNoTripleConsecutive;
+exports.isInHistory = isInHistory;
+exports.buildHistorySet = buildHistorySet;
+const types_1 = require("./types");
+/**
+ * Calculate exponential decay momentum scores
+ */
+function calculateMomentum(draws, decayAlpha = 0.03) {
+    const whiteScores = {};
+    const redScores = {};
+    // Initialize scores
+    for (let n = types_1.WHITE_BALL_RANGE.min; n <= types_1.WHITE_BALL_RANGE.max; n++) {
+        whiteScores[n] = 0.1;
+    }
+    for (let n = types_1.RED_BALL_RANGE.min; n <= types_1.RED_BALL_RANGE.max; n++) {
+        redScores[n] = 0.1;
+    }
+    // Sort by date ascending
+    const sorted = [...draws].sort((a, b) => a.date.getTime() - b.date.getTime());
+    const total = sorted.length;
+    sorted.forEach((draw, idx) => {
+        const t = total - 1 - idx; // t=0 for most recent
+        const weight = Math.exp(-decayAlpha * t);
+        draw.whiteBalls.forEach(w => {
+            if (whiteScores[w] !== undefined) {
+                whiteScores[w] += weight;
+            }
+        });
+        if (redScores[draw.powerball] !== undefined) {
+            redScores[draw.powerball] += weight;
+        }
+    });
+    return { white: whiteScores, red: redScores };
+}
+/**
+ * Calculate Z-scores for gap analysis (mean reversion)
+ */
+function calculateZScores(draws) {
+    const whiteGaps = {};
+    const redGaps = {};
+    const lastSeenWhite = {};
+    const lastSeenRed = {};
+    // Initialize
+    for (let n = types_1.WHITE_BALL_RANGE.min; n <= types_1.WHITE_BALL_RANGE.max; n++) {
+        whiteGaps[n] = [];
+        lastSeenWhite[n] = -1;
+    }
+    for (let n = types_1.RED_BALL_RANGE.min; n <= types_1.RED_BALL_RANGE.max; n++) {
+        redGaps[n] = [];
+        lastSeenRed[n] = -1;
+    }
+    const sorted = [...draws].sort((a, b) => a.date.getTime() - b.date.getTime());
+    sorted.forEach((draw, idx) => {
+        // White balls
+        draw.whiteBalls.forEach(w => {
+            if (lastSeenWhite[w] !== -1) {
+                whiteGaps[w].push(idx - lastSeenWhite[w]);
+            }
+            lastSeenWhite[w] = idx;
+        });
+        // Red ball
+        if (lastSeenRed[draw.powerball] !== -1) {
+            redGaps[draw.powerball].push(idx - lastSeenRed[draw.powerball]);
+        }
+        lastSeenRed[draw.powerball] = idx;
+    });
+    const total = sorted.length;
+    const whiteZ = {};
+    const redZ = {};
+    // Calculate Z-scores
+    for (let n = types_1.WHITE_BALL_RANGE.min; n <= types_1.WHITE_BALL_RANGE.max; n++) {
+        const currentGap = total - 1 - lastSeenWhite[n];
+        const gaps = whiteGaps[n];
+        if (gaps.length === 0) {
+            whiteZ[n] = 0;
+            continue;
+        }
+        const mean = gaps.reduce((a, b) => a + b, 0) / gaps.length;
+        const variance = gaps.reduce((sum, g) => sum + Math.pow(g - mean, 2), 0) / gaps.length;
+        const stdev = Math.sqrt(variance) || 1;
+        whiteZ[n] = (currentGap - mean) / stdev;
+    }
+    for (let n = types_1.RED_BALL_RANGE.min; n <= types_1.RED_BALL_RANGE.max; n++) {
+        const currentGap = total - 1 - lastSeenRed[n];
+        const gaps = redGaps[n];
+        if (gaps.length === 0) {
+            redZ[n] = 0;
+            continue;
+        }
+        const mean = gaps.reduce((a, b) => a + b, 0) / gaps.length;
+        const variance = gaps.reduce((sum, g) => sum + Math.pow(g - mean, 2), 0) / gaps.length;
+        const stdev = Math.sqrt(variance) || 1;
+        redZ[n] = (currentGap - mean) / stdev;
+    }
+    return { white: whiteZ, red: redZ };
+}
+/**
+ * Calculate recent momentum (last N draws)
+ */
+function calculateRecentMomentum(draws, nRecent = 15, decay = 0.15) {
+    const whiteScores = {};
+    const redScores = {};
+    for (let n = types_1.WHITE_BALL_RANGE.min; n <= types_1.WHITE_BALL_RANGE.max; n++) {
+        whiteScores[n] = 0.1;
+    }
+    for (let n = types_1.RED_BALL_RANGE.min; n <= types_1.RED_BALL_RANGE.max; n++) {
+        redScores[n] = 0.1;
+    }
+    const sorted = [...draws].sort((a, b) => b.date.getTime() - a.date.getTime()).slice(0, nRecent);
+    sorted.forEach((draw, idx) => {
+        const weight = Math.exp(-decay * idx) * 2;
+        draw.whiteBalls.forEach(w => {
+            if (whiteScores[w] !== undefined) {
+                whiteScores[w] += weight;
+            }
+        });
+        if (redScores[draw.powerball] !== undefined) {
+            redScores[draw.powerball] += weight;
+        }
+    });
+    return { white: whiteScores, red: redScores };
+}
+/**
+ * Analyze pair frequency
+ */
+function analyzePairFrequency(draws, topN = 50) {
+    const pairCounts = new Map();
+    draws.forEach(draw => {
+        const whites = [...draw.whiteBalls].sort((a, b) => a - b);
+        for (let i = 0; i < whites.length; i++) {
+            for (let j = i + 1; j < whites.length; j++) {
+                const key = `${whites[i]}-${whites[j]}`;
+                pairCounts.set(key, (pairCounts.get(key) || 0) + 1);
+            }
+        }
+    });
+    const pairBonus = {};
+    const sorted = [...pairCounts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, topN);
+    sorted.forEach(([pair, count]) => {
+        const [a, b] = pair.split('-').map(Number);
+        pairBonus[a] = (pairBonus[a] || 0) + count * 0.1;
+        pairBonus[b] = (pairBonus[b] || 0) + count * 0.1;
+    });
+    return pairBonus;
+}
+/**
+ * Weighted random selection
+ */
+function weightedSample(candidates, weights, k) {
+    const selected = new Set();
+    const totalWeight = weights.reduce((a, b) => a + b, 0);
+    while (selected.size < k) {
+        let r = Math.random() * totalWeight;
+        for (let i = 0; i < candidates.length; i++) {
+            r -= weights[i];
+            if (r <= 0) {
+                selected.add(candidates[i]);
+                break;
+            }
+        }
+    }
+    return [...selected];
+}
+/**
+ * Quantum selector combining all signals
+ */
+function quantumSelect(momentum, zScores, recentMomentum, pairBonus, nPicks) {
+    const candidates = Object.keys(momentum).map(Number);
+    const weights = candidates.map(n => {
+        const base = momentum[n] || 0;
+        const zBoost = Math.max(0, zScores[n] || 0) * 5;
+        const recentBoost = (recentMomentum[n] || 0) * 1.5;
+        const pairB = (pairBonus[n] || 0) * 0.5;
+        return Math.max(0.1, base + zBoost + recentBoost + pairB);
+    });
+    return weightedSample(candidates, weights, nPicks);
+}
+// --- FILTERS ---
+function checkSumRange(whiteBalls, min = 130, max = 220) {
+    const sum = whiteBalls.reduce((a, b) => a + b, 0);
+    return sum >= min && sum <= max;
+}
+function checkOddEvenRatio(whiteBalls) {
+    const odds = whiteBalls.filter(x => x % 2 !== 0).length;
+    const evens = 5 - odds;
+    return (odds === 3 && evens === 2) || (odds === 2 && evens === 3);
+}
+function checkHighLowBalance(whiteBalls, threshold = 35) {
+    const lows = whiteBalls.filter(x => x < threshold).length;
+    const highs = 5 - lows;
+    return (lows === 3 && highs === 2) || (lows === 2 && highs === 3);
+}
+function checkDecadeBalance(whiteBalls) {
+    const decades = new Set(whiteBalls.map(n => Math.floor(n / 10)));
+    return decades.size >= 3;
+}
+function checkEndingDiversity(whiteBalls) {
+    const endings = new Set(whiteBalls.map(n => n % 10));
+    return endings.size >= 4;
+}
+function checkNoTripleConsecutive(whiteBalls) {
+    const sorted = [...whiteBalls].sort((a, b) => a - b);
+    const diffs = [];
+    for (let i = 0; i < sorted.length - 1; i++) {
+        diffs.push(sorted[i + 1] - sorted[i]);
+    }
+    const consecutiveOnes = diffs.filter(d => d === 1).length;
+    return consecutiveOnes < 2;
+}
+/**
+ * Check if combination exists in history
+ */
+function isInHistory(whiteBalls, powerball, history) {
+    const key = [...whiteBalls].sort((a, b) => a - b).join(',') + '-' + powerball;
+    return history.has(key);
+}
+function buildHistorySet(draws) {
+    const history = new Set();
+    draws.forEach(draw => {
+        const key = [...draw.whiteBalls].sort((a, b) => a - b).join(',') + '-' + draw.powerball;
+        history.add(key);
+    });
+    return history;
+}

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+export interface Draw {
+    date: Date;
+    whiteBalls: number[];
+    powerball: number;
+    multiplier: number;
+}
+export interface Pick {
+    whiteBalls: number[];
+    powerball: number;
+    score?: number;
+}
+export interface Scores {
+    [key: number]: number;
+}
+export interface PredictOptions {
+    count?: number;
+    showAnalysis?: boolean;
+}
+export declare const WHITE_BALL_RANGE: {
+    min: number;
+    max: number;
+};
+export declare const RED_BALL_RANGE: {
+    min: number;
+    max: number;
+};
+export declare const DATA_URL = "https://data.ny.gov/api/views/d6yy-54nr/rows.csv?accessType=DOWNLOAD";

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATA_URL = exports.RED_BALL_RANGE = exports.WHITE_BALL_RANGE = void 0;
+exports.WHITE_BALL_RANGE = { min: 1, max: 69 };
+exports.RED_BALL_RANGE = { min: 1, max: 26 };
+exports.DATA_URL = "https://data.ny.gov/api/views/d6yy-54nr/rows.csv?accessType=DOWNLOAD";

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "powerball-quantum",
+  "version": "1.0.0",
+  "description": "Powerball number predictor using quantum-inspired algorithm with momentum, mean reversion, and statistical filters",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "powerball-quantum": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "predict": "node dist/cli.js predict",
+    "update": "node dist/cli.js update",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "powerball",
+    "lottery",
+    "predictor",
+    "quantum",
+    "statistics",
+    "probability"
+  ],
+  "author": "seochan99",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/seochan99/Powerball-Predictor-Quantum"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "commander": "^11.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}