@ebowwa/quant-rust 0.1.0 → 0.2.0

package/src/ffi.rs

@@ -301,6 +301,71 @@ pub extern "C" fn quant_kelly_criterion(
 // Arbitrage Detection
 // ============================================================================
 
+/// Detect arbitrage opportunities for multiple price pairs at once (batch operation)
+/// This is much more efficient than calling quant_detect_arbitrage multiple times
+/// because it only crosses the FFI boundary once.
+///
+/// # Arguments
+/// * `yes_prices` - Pointer to array of YES prices
+/// * `no_prices` - Pointer to array of NO prices
+/// * `count` - Number of pairs (length of both arrays)
+///
+/// # Returns
+/// JSON array of arbitrage results with profit field
+#[no_mangle]
+pub extern "C" fn quant_detect_arbitrage_batch(
+    yes_prices: *const f64,
+    no_prices: *const f64,
+    count: usize,
+) -> *mut c_char {
+    if yes_prices.is_null() || no_prices.is_null() || count == 0 {
+        set_last_error("Null pointer or zero count provided");
+        return ptr::null_mut();
+    }
+
+    let yes_slice = unsafe { std::slice::from_raw_parts(yes_prices, count) };
+    let no_slice = unsafe { std::slice::from_raw_parts(no_prices, count) };
+
+    let mut results = Vec::with_capacity(count);
+
+    for i in 0..count {
+        let yes_price = yes_slice[i];
+        let no_price = no_slice[i];
+
+        // Validate inputs
+        if yes_price < 0.0 || yes_price > 1.0 || no_price < 0.0 || no_price > 1.0 {
+            results.push(serde_json::json!({
+                "error": format!("Prices at index {} must be between 0 and 1", i),
+                "index": i,
+                "has_arbitrage": false,
+                "yes_price": yes_price,
+                "no_price": no_price,
+                "total_price": yes_price + no_price,
+                "profit_per_share": 0.0,
+                "profit_bps": 0.0,
+                "profit": 0.0
+            }));
+            continue;
+        }
+
+        let total = yes_price + no_price;
+        let has_arb = total < 1.0;
+        let profit_per_share = if has_arb { 1.0 - total } else { 0.0 };
+
+        results.push(serde_json::json!({
+            "has_arbitrage": has_arb,
+            "yes_price": yes_price,
+            "no_price": no_price,
+            "total_price": total,
+            "profit_per_share": profit_per_share,
+            "profit_bps": profit_per_share * 10000.0,
+            "profit": profit_per_share
+        }));
+    }
+
+    return_json_value(serde_json::json!(results))
+}
+
 /// Detect arbitrage opportunity (if yes_price + no_price < 1)
 #[no_mangle]
 pub extern "C" fn quant_detect_arbitrage(yes_price: f64, no_price: f64) -> *mut c_char {
@@ -326,6 +391,92 @@ pub extern "C" fn quant_detect_arbitrage(yes_price: f64, no_price: f64) -> *mut
     }
 }
 
+// ============================================================================
+// Batch Functions (reduce FFI overhead)
+// ============================================================================
+
+/// Calculate Kelly criterion for multiple bets at once (batch operation)
+/// This is much more efficient than calling quant_kelly_criterion multiple times
+/// because it only crosses the FFI boundary once.
+///
+/// # Arguments
+/// * `probs` - Pointer to array of your probabilities
+/// * `prices` - Pointer to array of market prices
+/// * `count` - Number of bets (length of both arrays)
+/// * `bankroll` - Total bankroll (shared across all bets)
+///
+/// # Returns
+/// JSON array of KellyResult objects
+#[inline(never)]
+#[no_mangle]
+pub extern "C" fn quant_kelly_criterion_batch(
+    probs: *const f64,
+    prices: *const f64,
+    count: usize,
+    bankroll: f64,
+) -> *mut c_char {
+    if probs.is_null() || prices.is_null() || count == 0 {
+        set_last_error("Null pointer or zero count provided");
+        return ptr::null_mut();
+    }
+
+    let probs_slice = unsafe { std::slice::from_raw_parts(probs, count) };
+    let prices_slice = unsafe { std::slice::from_raw_parts(prices, count) };
+
+    let mut results = Vec::with_capacity(count);
+
+    for i in 0..count {
+        let your_probability = probs_slice[i];
+        let market_price = prices_slice[i];
+
+        // Validate inputs
+        if your_probability <= 0.0 || your_probability >= 1.0 {
+            results.push(serde_json::json!({
+                "error": format!("Probability at index {} must be between 0 and 1", i),
+                "index": i
+            }));
+            continue;
+        }
+        if market_price <= 0.0 || market_price >= 1.0 {
+            results.push(serde_json::json!({
+                "error": format!("Market price at index {} must be between 0 and 1", i),
+                "index": i
+            }));
+            continue;
+        }
+        if bankroll <= 0.0 {
+            results.push(serde_json::json!({
+                "error": "Bankroll must be positive",
+                "index": i
+            }));
+            continue;
+        }
+
+        let edge = your_probability - market_price;
+        let odds = (1.0 - market_price) / market_price;
+
+        // Kelly fraction: (bp - q) / b where b = odds, p = your_prob, q = 1 - your_prob
+        let kelly = (odds * your_probability - (1.0 - your_probability)) / odds;
+        let kelly = kelly.max(0.0); // Never bet negative
+
+        let half_kelly = kelly / 2.0;
+        let quarter_kelly = kelly / 4.0;
+
+        results.push(serde_json::json!(KellyResult {
+            kelly_fraction: kelly,
+            half_kelly,
+            quarter_kelly,
+            full_bet_size: kelly * bankroll,
+            half_bet_size: half_kelly * bankroll,
+            quarter_bet_size: quarter_kelly * bankroll,
+            edge,
+            odds,
+        }));
+    }
+
+    return_json_value(serde_json::json!(results))
+}
+
 // ============================================================================
 // Odds Conversion
 // ============================================================================

package/src/index.ts

@@ -1,8 +1,44 @@
 /**
- * Bun FFI wrapper for quant-rust
+ * @ebowwa/quant-rust - High-Performance Quantitative Finance Library
  *
- * This module provides TypeScript bindings for the Rust quant library
- * using Bun's FFI capabilities.
+ * This package provides a HYBRID approach:
+ * - Rust FFI for array operations (10-20x faster)
+ * - TypeScript for scalar operations (20-40x faster due to no FFI overhead)
+ *
+ * ╔═══════════════════════════════════════════════════════════════════════════╗
+ * ║                    PERFORMANCE GUIDE                                       ║
+ * ├───────────────────────────────────────────────────────────────────────────┤
+ * ║                                                                           ║
+ * ║  ✅ USE RUST FFI (fast) for ARRAY operations:                             ║
+ * ║     • sma(prices, 20)          → 10-20x faster on large arrays            ║
+ * ║     • calculateDrawdown(arr)   → 5-10x faster                             ║
+ * ║     • mean(arr), stdDev(arr)   → 2-5x faster                              ║
+ * ║     • calculateSharpeRatio(arr)→ 2x faster                                ║
+ * ║                                                                           ║
+ * ║  ✅ USE TYPESCRIPT (fast) for SCALAR operations:                          ║
+ * ║     • kellyCriterionTS()       → 20-40x faster (no FFI overhead)          ║
+ * ║     • detectArbitrageTS()      → 15-40x faster                            ║
+ * ║     • convertOddsTS()          → 20-40x faster                            ║
+ * ║                                                                           ║
+ * ║  ⚠️  WHY IS FFI SLOWER FOR SCALARS?                                       ║
+ * ║     FFI overhead ~2500ns per call                                         ║
+ * ║     Scalar computation ~5ns                                                ║
+ * ║     Overhead/computation ratio: 500:1                                      ║
+ * ║                                                                           ║
+ * ║     For arrays, O(n) computation amortizes FFI cost.                      ║
+ * ║     For scalars, FFI cost dominates.                                       ║
+ * ╚═══════════════════════════════════════════════════════════════════════════╝
+ *
+ * USAGE:
+ * ```typescript
+ * // Array operations → Rust FFI
+ * import { sma, calculateDrawdown } from '@ebowwa/quant-rust';
+ * const ma = sma(prices, 20);  // 10x faster
+ *
+ * // Scalar operations → TypeScript (use TS suffix)
+ * import { kellyCriterionTS, detectArbitrageTS } from '@ebowwa/quant-rust';
+ * const kelly = kellyCriterionTS(0.6, 0.5, 1000);  // 30x faster
+ * ```
  *
  * @packageDocumentation
  */
@@ -12,6 +48,9 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { existsSync } from "fs";
 
+// Import OddsType for convertOdds function (re-exported at end)
+import type { OddsType } from "./ts-fns.js";
+
 // Import types - re-exported at the end
 import type {
   OHLCV,
@@ -139,6 +178,18 @@ const symbols = {
     args: [FFIType.f64, FFIType.f64],
   },
 
+  // Batch Kelly Criterion
+  quant_kelly_criterion_batch: {
+    returns: FFIType.cstring,
+    args: [FFIType.ptr, FFIType.ptr, FFIType.usize, FFIType.f64],
+  },
+
+  // Batch Arbitrage Detection
+  quant_detect_arbitrage_batch: {
+    returns: FFIType.cstring,
+    args: [FFIType.ptr, FFIType.ptr, FFIType.usize],
+  },
+
   // Odds Conversion
   quant_convert_odds: {
     returns: FFIType.cstring,
@@ -482,6 +533,49 @@ export function kellyCriterion(
 // Alias matching @ebowwa/quant API
 export const kelly_criterion = kellyCriterion;
 
+/**
+ * Calculate Kelly criterion for multiple bets at once (batch operation)
+ *
+ * This is significantly more efficient than calling kellyCriterion multiple times
+ * because it only crosses the FFI boundary once, eliminating FFI call overhead.
+ *
+ * @param bets - Array of betting opportunities with prob and price
+ * @param bankroll - Total bankroll in currency units (shared across all bets)
+ * @returns Array of Kelly criterion results for each bet
+ *
+ * @example
+ * ```typescript
+ * const bets = [
+ *   { prob: 0.6, price: 0.5 },
+ *   { prob: 0.55, price: 0.45 },
+ *   { prob: 0.7, price: 0.6 },
+ * ];
+ * const results = kellyCriterionBatch(bets, 1000);
+ * // results[0].full_bet_size, results[1].half_bet_size, etc.
+ * ```
+ */
+export function kellyCriterionBatch(
+  bets: Array<{ prob: number; price: number }>,
+  bankroll: number
+): KellyResult[] {
+  if (bets.length === 0) return [];
+
+  const probs = new Float64Array(bets.map(b => b.prob));
+  const prices = new Float64Array(bets.map(b => b.price));
+
+  const response = lib.symbols.quant_kelly_criterion_batch(
+    ptr(probs),
+    ptr(prices),
+    bets.length,
+    bankroll
+  ) as string;
+
+  return parseJsonResponse<KellyResult[]>(response);
+}
+
+// Alias matching @ebowwa/quant API
+export const kelly_criterion_batch = kellyCriterionBatch;
+
 // ============================================================================
 // Arbitrage Detection Functions
 // ============================================================================
@@ -505,15 +599,53 @@ export function detectArbitrage(yesPrice: number, noPrice: number): ArbitrageRes
 // Alias matching @ebowwa/quant API
 export const detect_arbitrage = detectArbitrage;
 
+/**
+ * Detect arbitrage opportunities for multiple price pairs at once (batch operation)
+ *
+ * This is significantly more efficient than calling detectArbitrage multiple times
+ * because it only crosses the FFI boundary once, eliminating FFI call overhead.
+ *
+ * @param pairs - Array of YES/NO price pairs to check for arbitrage
+ * @returns Array of arbitrage results with profit field for each pair
+ *
+ * @example
+ * ```typescript
+ * const pairs = [
+ *   { yesPrice: 0.45, noPrice: 0.45 }, // 10% arb opportunity
+ *   { yesPrice: 0.50, noPrice: 0.50 }, // no arb
+ *   { yesPrice: 0.40, noPrice: 0.40 }, // 20% arb opportunity
+ * ];
+ * const results = detectArbitrageBatch(pairs);
+ * // results[0].profit = 0.10, results[1].profit = 0, results[2].profit = 0.20
+ * ```
+ */
+export function detectArbitrageBatch(
+  pairs: Array<{ yesPrice: number; noPrice: number }>
+): Array<ArbitrageResult & { profit: number }> {
+  if (pairs.length === 0) return [];
+
+  const yesPrices = new Float64Array(pairs.map(p => p.yesPrice));
+  const noPrices = new Float64Array(pairs.map(p => p.noPrice));
+
+  const response = lib.symbols.quant_detect_arbitrage_batch(
+    ptr(yesPrices),
+    ptr(noPrices),
+    pairs.length
+  ) as string;
+
+  return parseJsonResponse<Array<ArbitrageResult & { profit: number }>>(response);
+}
+
+// Alias matching @ebowwa/quant API
+export const detect_arbitrage_batch = detectArbitrageBatch;
+
 // ============================================================================
 // Odds Conversion Functions
 // ============================================================================
 
-/** Odds input type */
-export type OddsType = "probability" | "decimal" | "american";
-
 /**
  * Convert between probability, decimal odds, and American odds
+ * @note OddsType is imported from ts-fns.ts (re-exported at end of file)
  *
  * @param value - The value to convert
  * @param fromType - The type of the input value
@@ -1005,10 +1137,56 @@ export const calculate_beta_alpha = calculateBetaAlpha;
 
 export * from "../types/index.js";
 
+// ============================================================================
+// TypeScript Fallbacks (FASTER for scalar operations - no FFI overhead)
+// ============================================================================
+
+/**
+ * TypeScript implementations for scalar operations.
+ *
+ * These are 20-40x faster than FFI for simple calculations because:
+ * - No FFI boundary crossing (~500ns saved each way)
+ * - No type marshalling (~500ns saved)
+ * - No JSON serialization (~500ns saved)
+ *
+ * USE THESE for: kellyCriterion, detectArbitrage, convertOdds
+ * USE RUST FFI for: sma, ema, drawdown, sharpe, mean, stdDev
+ */
+export {
+  kellyCriterion as kellyCriterionTS,
+  fractionalKelly,
+  detectArbitrage as detectArbitrageTS,
+  findCrossMarketArbitrage,
+  convertOdds as convertOddsTS,
+  probToDecimalOdds,
+  probToAmericanOdds,
+  decimalOddsToProb,
+  americanOddsToProb,
+  calculateEdge,
+  expectedValue,
+  hasPositiveEV,
+  breakEvenProbability,
+} from "./ts-fns.js";
+
+// Re-export types from ts-fns
+export type { OddsType } from "./ts-fns.js";
+
 // ============================================================================
 // Default Export
 // ============================================================================
 
+// Import TS functions for default export
+import {
+  kellyCriterion as kellyCriterionTS,
+  detectArbitrage as detectArbitrageTS,
+  convertOdds as convertOddsTS,
+  fractionalKelly,
+  calculateEdge,
+  expectedValue,
+  hasPositiveEV,
+  breakEvenProbability,
+} from "./ts-fns.js";
+
 export default {
   // Library info
   getVersion,
@@ -1032,17 +1210,32 @@ export default {
   lmsrCost,
   lmsrCalculate,
 
-  // Kelly
+  // Kelly (FFI - use kellyCriterionTS for single calls, 20-40x faster)
   kellyCriterion,
   kelly_criterion,
-
-  // Arbitrage
+  kellyCriterionBatch,
+  kelly_criterion_batch,
+  // TypeScript versions (FASTER for single calls)
+  kellyCriterionTS,
+  fractionalKelly,
+  calculateEdge,
+  expectedValue,
+  hasPositiveEV,
+  breakEvenProbability,
+
+  // Arbitrage (FFI - use detectArbitrageTS for single calls, 15-40x faster)
   detectArbitrage,
   detect_arbitrage,
+  detectArbitrageBatch,
+  detect_arbitrage_batch,
+  // TypeScript version (FASTER for single calls)
+  detectArbitrageTS,
 
-  // Odds
+  // Odds (FFI - use convertOddsTS for single calls, 20-40x faster)
   convertOdds,
   convert_odds,
+  // TypeScript version (FASTER for single calls)
+  convertOddsTS,
 
   // Statistics
   mean,