powerball-quantum 1.0.0

package/README.md

@@ -0,0 +1,80 @@
+# powerball-quantum
+
+Powerball number predictor using quantum-inspired algorithm with momentum, mean reversion, and statistical filters.
+
+## Installation
+
+```bash
+npm install powerball-quantum
+```
+
+## CLI Usage
+
+```bash
+# Get 5 recommended picks
+npx powerball-quantum predict
+
+# Get 10 picks with analysis
+npx powerball-quantum predict -c 10 -a
+
+# Quick single pick
+npx powerball-quantum quick
+
+# Update data from NY Lottery API
+npx powerball-quantum update
+```
+
+## Programmatic Usage
+
+```typescript
+import { predict, quickPick, formatPick, updateData } from 'powerball-quantum';
+
+// Get 5 picks
+const picks = await predict({ count: 5 });
+picks.forEach(pick => {
+  console.log(formatPick(pick));
+  // Output: 21 - 26 - 34 - 57 - 61  🔴 1
+});
+
+// Quick single pick
+const myPick = await quickPick();
+console.log(myPick);
+// { whiteBalls: [5, 7, 28, 38, 66], powerball: 23, score: 46.5 }
+
+// Update data
+await updateData();
+```
+
+## Algorithm
+
+**QUANTUM** combines multiple Wall Street quant-inspired signals:
+
+| Signal | Description |
+|--------|-------------|
+| **Momentum** | Exponential decay weighting - recent numbers score higher |
+| **Z-Score** | Mean reversion - overdue numbers get boosted |
+| **Recent Trend** | Last 15 draws with stronger emphasis |
+| **Pair Synergy** | Numbers that frequently appear together |
+
+### 7-Stage Filter
+
+All picks must pass:
+1. ❌ No duplicate with historical combinations
+2. ✅ Sum range: 130-220
+3. ✅ Odd/Even ratio: 2:3 or 3:2
+4. ✅ High/Low balance: 2:3 or 3:2
+5. ✅ Decade balance: At least 3 different decades
+6. ✅ Ending diversity: At least 4 different last digits
+7. ❌ No triple consecutive numbers
+
+## Data Source
+
+Historical data from [NY Open Data Powerball API](https://data.ny.gov/Government-Finance/Lottery-Powerball-Winning-Numbers-Beginning-2010/d6yy-54nr).
+
+## Disclaimer
+
+**For educational and entertainment purposes only.** Lottery numbers are randomly drawn. No algorithm can predict or guarantee winning numbers. Gamble responsibly.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const index_1 = require("./index");
+const program = new commander_1.Command();
+program
+    .name('powerball-quantum')
+    .description('Powerball number predictor using quantum-inspired algorithm')
+    .version('1.0.0');
+program
+    .command('predict')
+    .description('Generate predicted Powerball numbers')
+    .option('-c, --count <number>', 'Number of picks to generate', '5')
+    .option('-a, --analysis', 'Show signal analysis', false)
+    .action(async (options) => {
+    console.log('');
+    console.log('🎱 POWERBALL QUANTUM PREDICTOR');
+    console.log('═'.repeat(50));
+    try {
+        const picks = await (0, index_1.predict)({
+            count: parseInt(options.count),
+            showAnalysis: options.analysis
+        });
+        console.log('\n⭐ RECOMMENDED PICKS:\n');
+        picks.forEach((pick, i) => {
+            const score = pick.score?.toFixed(1) || '?';
+            console.log(`  #${i + 1}  ${(0, index_1.formatPick)(pick)}  (score: ${score})`);
+        });
+        console.log('\n' + '═'.repeat(50));
+        console.log('Good luck! 🍀\n');
+    }
+    catch (error) {
+        console.error('Error:', error);
+        process.exit(1);
+    }
+});
+program
+    .command('update')
+    .description('Update Powerball data from NY Lottery API')
+    .action(async () => {
+    console.log('');
+    console.log('📥 Updating Powerball data...');
+    console.log('═'.repeat(50));
+    try {
+        await (0, index_1.updateData)();
+        console.log('✅ Data updated successfully!\n');
+    }
+    catch (error) {
+        console.error('Error updating data:', error);
+        process.exit(1);
+    }
+});
+program
+    .command('quick')
+    .description('Get one quick pick')
+    .action(async () => {
+    try {
+        const picks = await (0, index_1.predict)({ count: 1 });
+        if (picks[0]) {
+            console.log('\n🎫 Your lucky numbers:');
+            console.log(`\n   ${(0, index_1.formatPick)(picks[0])}\n`);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error);
+        process.exit(1);
+    }
+});
+// Default action (no command)
+if (process.argv.length === 2) {
+    program.parse(['node', 'cli', 'predict']);
+}
+else {
+    program.parse();
+}

package/dist/data.d.ts

@@ -0,0 +1,17 @@
+import { Draw } from './types';
+/**
+ * Download latest Powerball data from NY Lottery API
+ */
+export declare function downloadData(): Promise<string>;
+/**
+ * Parse CSV data into Draw objects
+ */
+export declare function parseCSV(csvContent: string): Draw[];
+/**
+ * Load data from file or download if not exists
+ */
+export declare function loadData(): Promise<Draw[]>;
+/**
+ * Update data (force re-download)
+ */
+export declare function updateData(): Promise<Draw[]>;

package/dist/data.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadData = downloadData;
+exports.parseCSV = parseCSV;
+exports.loadData = loadData;
+exports.updateData = updateData;
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const types_1 = require("./types");
+const DATA_FILE = path.join(__dirname, '..', 'powerball_data.csv');
+/**
+ * Download latest Powerball data from NY Lottery API
+ */
+async function downloadData() {
+    console.log('Downloading latest Powerball data...');
+    const response = await axios_1.default.get(types_1.DATA_URL);
+    fs.writeFileSync(DATA_FILE, response.data);
+    console.log('Download complete!');
+    return DATA_FILE;
+}
+/**
+ * Parse CSV data into Draw objects
+ */
+function parseCSV(csvContent) {
+    const lines = csvContent.trim().split('\n');
+    const draws = [];
+    // Skip header
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        const parts = line.split(',');
+        if (parts.length < 3)
+            continue;
+        const dateStr = parts[0];
+        const numbersStr = parts[1];
+        const multiplier = parseInt(parts[2]) || 2;
+        const numbers = numbersStr.split(' ').map(n => parseInt(n.trim()));
+        if (numbers.length < 6)
+            continue;
+        const date = new Date(dateStr);
+        // Filter for current rules (post Oct 7, 2015)
+        if (date < new Date('2015-10-07'))
+            continue;
+        draws.push({
+            date,
+            whiteBalls: numbers.slice(0, 5),
+            powerball: numbers[5],
+            multiplier
+        });
+    }
+    return draws;
+}
+/**
+ * Load data from file or download if not exists
+ */
+async function loadData() {
+    let csvContent;
+    if (fs.existsSync(DATA_FILE)) {
+        csvContent = fs.readFileSync(DATA_FILE, 'utf-8');
+    }
+    else {
+        await downloadData();
+        csvContent = fs.readFileSync(DATA_FILE, 'utf-8');
+    }
+    const draws = parseCSV(csvContent);
+    console.log(`Loaded ${draws.length} draws (current rules since 2015-10-07)`);
+    return draws;
+}
+/**
+ * Update data (force re-download)
+ */
+async function updateData() {
+    await downloadData();
+    const csvContent = fs.readFileSync(DATA_FILE, 'utf-8');
+    const draws = parseCSV(csvContent);
+    console.log(`Updated! ${draws.length} draws loaded.`);
+    return draws;
+}

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { Draw, Pick, PredictOptions } from './types';
+import { loadData, updateData } from './data';
+export { Draw, Pick, PredictOptions } from './types';
+export { loadData, updateData } from './data';
+/**
+ * Generate a single quantum-powered pick
+ */
+export declare function generatePick(draws: Draw[], historySet: Set<string>, whiteMomentum: Record<number, number>, redMomentum: Record<number, number>, whiteZ: Record<number, number>, redZ: Record<number, number>, whiteRecent: Record<number, number>, redRecent: Record<number, number>, pairBonus: Record<number, number>): Pick | null;
+/**
+ * Main prediction function - call this to get picks!
+ *
+ * @example
+ * ```typescript
+ * import { predict } from 'powerball-quantum';
+ *
+ * const picks = await predict({ count: 5 });
+ * console.log(picks);
+ * ```
+ */
+export declare function predict(options?: PredictOptions): Promise<Pick[]>;
+/**
+ * Quick function to get a single best pick
+ */
+export declare function quickPick(): Promise<Pick | null>;
+/**
+ * Format pick for display
+ */
+export declare function formatPick(pick: Pick): string;
+declare const _default: {
+    predict: typeof predict;
+    quickPick: typeof quickPick;
+    updateData: typeof updateData;
+    loadData: typeof loadData;
+    formatPick: typeof formatPick;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateData = exports.loadData = void 0;
+exports.generatePick = generatePick;
+exports.predict = predict;
+exports.quickPick = quickPick;
+exports.formatPick = formatPick;
+const data_1 = require("./data");
+const quantum_1 = require("./quantum");
+var data_2 = require("./data");
+Object.defineProperty(exports, "loadData", { enumerable: true, get: function () { return data_2.loadData; } });
+Object.defineProperty(exports, "updateData", { enumerable: true, get: function () { return data_2.updateData; } });
+/**
+ * Generate a single quantum-powered pick
+ */
+function generatePick(draws, historySet, whiteMomentum, redMomentum, whiteZ, redZ, whiteRecent, redRecent, pairBonus) {
+    const maxAttempts = 150000;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const whiteBalls = (0, quantum_1.quantumSelect)(whiteMomentum, whiteZ, whiteRecent, pairBonus, 5).sort((a, b) => a - b);
+        const powerball = (0, quantum_1.quantumSelect)(redMomentum, redZ, redRecent, {}, 1)[0];
+        // Apply all filters
+        if ((0, quantum_1.isInHistory)(whiteBalls, powerball, historySet))
+            continue;
+        if (!(0, quantum_1.checkSumRange)(whiteBalls))
+            continue;
+        if (!(0, quantum_1.checkOddEvenRatio)(whiteBalls))
+            continue;
+        if (!(0, quantum_1.checkHighLowBalance)(whiteBalls))
+            continue;
+        if (!(0, quantum_1.checkDecadeBalance)(whiteBalls))
+            continue;
+        if (!(0, quantum_1.checkEndingDiversity)(whiteBalls))
+            continue;
+        if (!(0, quantum_1.checkNoTripleConsecutive)(whiteBalls))
+            continue;
+        // Calculate score
+        let score = 0;
+        whiteBalls.forEach(n => {
+            score += (whiteMomentum[n] || 0) * 1.0;
+            score += Math.max(0, whiteZ[n] || 0) * 3.0;
+            score += (whiteRecent[n] || 0) * 2.0;
+            score += (pairBonus[n] || 0) * 0.5;
+        });
+        score += (redMomentum[powerball] || 0) * 2.0;
+        score += Math.max(0, redZ[powerball] || 0) * 4.0;
+        return { whiteBalls, powerball, score };
+    }
+    return null;
+}
+/**
+ * Main prediction function - call this to get picks!
+ *
+ * @example
+ * ```typescript
+ * import { predict } from 'powerball-quantum';
+ *
+ * const picks = await predict({ count: 5 });
+ * console.log(picks);
+ * ```
+ */
+async function predict(options = {}) {
+    const { count = 5, showAnalysis = false } = options;
+    // Load data
+    const draws = await (0, data_1.loadData)();
+    const historySet = (0, quantum_1.buildHistorySet)(draws);
+    // Calculate all signals
+    const { white: wMom, red: rMom } = (0, quantum_1.calculateMomentum)(draws);
+    const { white: wZ, red: rZ } = (0, quantum_1.calculateZScores)(draws);
+    const { white: wRecent, red: rRecent } = (0, quantum_1.calculateRecentMomentum)(draws, 15);
+    const pairBonus = (0, quantum_1.analyzePairFrequency)(draws, 50);
+    if (showAnalysis) {
+        console.log('\n📊 Signal Analysis:');
+        const topMom = Object.entries(wMom).sort((a, b) => b[1] - a[1]).slice(0, 10);
+        console.log('🔥 Hot Numbers:', topMom.map(([n]) => n));
+        const topZ = Object.entries(wZ).sort((a, b) => b[1] - a[1]).slice(0, 10);
+        console.log('⏰ Overdue Numbers:', topZ.filter(([, z]) => z > 1).map(([n]) => n));
+    }
+    // Generate picks
+    const picks = [];
+    const seen = new Set();
+    for (let i = 0; i < count * 10 && picks.length < count; i++) {
+        const pick = generatePick(draws, historySet, wMom, rMom, wZ, rZ, wRecent, rRecent, pairBonus);
+        if (pick) {
+            const key = pick.whiteBalls.join(',') + '-' + pick.powerball;
+            if (!seen.has(key)) {
+                seen.add(key);
+                picks.push(pick);
+            }
+        }
+    }
+    // Sort by score
+    picks.sort((a, b) => (b.score || 0) - (a.score || 0));
+    return picks;
+}
+/**
+ * Quick function to get a single best pick
+ */
+async function quickPick() {
+    const picks = await predict({ count: 1 });
+    return picks[0] || null;
+}
+/**
+ * Format pick for display
+ */
+function formatPick(pick) {
+    const whites = pick.whiteBalls.map(n => n.toString().padStart(2, ' ')).join(' - ');
+    return `${whites}  🔴 ${pick.powerball}`;
+}
+// Default export
+exports.default = { predict, quickPick, updateData: data_1.updateData, loadData: data_1.loadData, formatPick };

package/dist/quantum.d.ts

@@ -0,0 +1,45 @@
+import { Draw, Scores } from './types';
+/**
+ * Calculate exponential decay momentum scores
+ */
+export declare function calculateMomentum(draws: Draw[], decayAlpha?: number): {
+    white: Scores;
+    red: Scores;
+};
+/**
+ * Calculate Z-scores for gap analysis (mean reversion)
+ */
+export declare function calculateZScores(draws: Draw[]): {
+    white: Scores;
+    red: Scores;
+};
+/**
+ * Calculate recent momentum (last N draws)
+ */
+export declare function calculateRecentMomentum(draws: Draw[], nRecent?: number, decay?: number): {
+    white: Scores;
+    red: Scores;
+};
+/**
+ * Analyze pair frequency
+ */
+export declare function analyzePairFrequency(draws: Draw[], topN?: number): Scores;
+/**
+ * Weighted random selection
+ */
+export declare function weightedSample(candidates: number[], weights: number[], k: number): number[];
+/**
+ * Quantum selector combining all signals
+ */
+export declare function quantumSelect(momentum: Scores, zScores: Scores, recentMomentum: Scores, pairBonus: Scores, nPicks: number): number[];
+export declare function checkSumRange(whiteBalls: number[], min?: number, max?: number): boolean;
+export declare function checkOddEvenRatio(whiteBalls: number[]): boolean;
+export declare function checkHighLowBalance(whiteBalls: number[], threshold?: number): boolean;
+export declare function checkDecadeBalance(whiteBalls: number[]): boolean;
+export declare function checkEndingDiversity(whiteBalls: number[]): boolean;
+export declare function checkNoTripleConsecutive(whiteBalls: number[]): boolean;
+/**
+ * Check if combination exists in history
+ */
+export declare function isInHistory(whiteBalls: number[], powerball: number, history: Set<string>): boolean;
+export declare function buildHistorySet(draws: Draw[]): Set<string>;