aiden-shared-calculations-unified 1.0.156 → 1.0.157

package/calculations/popular-investor/PiCryptoBuyers.js

@@ -1,6 +1,15 @@
 /**
- * @fileoverview Popular Investors Who Bought Crypto.
+ * @fileoverview Popular Investors Who Bought Crypto - OPTIMIZED & DETERMINISTIC
  * Flags if the specific PI has bought crypto recently.
+ * * ALGORITHM: Domain-Aware Hybrid Integer Subset Sum Solver
+ * 0. DOMAIN FILTER: Crypto assets have 6-digit InstrumentIDs (100000+)
+ * 1. Integerization: Scaled integers (x100,000) to eliminate FP drift.
+ * 2. Grouping: Bounded-choice branching for identical weights.
+ * 3. Strategy: 
+ * - N <= 40: DFS with Suffix Max, Greedy Bounding, Early Termination
+ * - N > 40: Meet-in-the-Middle with immediate left-side checks.
+ * 4. Determinism: Strictly prefers solutions with fewer assets.
+ * 5. Tolerance: 0.01% rounding tolerance for financial data
  */
 
 class PiCryptoBuyers {
@@ -10,7 +19,7 @@ class PiCryptoBuyers {
 
     static getMetadata() {
         return {
-            type: 'standard', // [FIX] Changed to standard
+            type: 'standard',
             category: 'popular_investor',
             rootDataDependencies: ['portfolio', 'history'],
             userType: 'POPULAR_INVESTOR'
@@ -24,47 +33,84 @@ class PiCryptoBuyers {
             type: 'object',
             properties: {
                 isCryptoBuyer: { type: 'boolean' },
-                lastCryptoTrade: { type: 'string' }
+                lastCryptoTrade: { type: 'string' },
+                cryptoAssets: { type: 'array', items: { type: 'number' } }
             }
         };
     }
 
     process(context) {
-        const { DataExtractor, HistoryExtractor } = context.math;
+        // 1. Dependency Injection & Safety
+        // HistoryExtractor is injected into context.math by ContextFactory -> layers/index.js
+        const { HistoryExtractor } = context.math; 
+        if (!HistoryExtractor) throw new Error("HistoryExtractor not found in context.math");
+
         const userId = context.user.id;
         const portfolio = context.user.portfolio.today;
         const historyDoc = context.user.history.today;
+
+        // 2. Deterministic Date Handling (CRITICAL FIX)
+        // Use the computation date (context.date.today), NOT new Date() (server time).
+        const runDateString = context.date.today;
+        const runDate = new Date(runDateString); 
         
-        // Default time window: 7 days
         const TIME_WINDOW_DAYS = 7;
-        const cutoffDate = new Date();
+        const cutoffDate = new Date(runDate);
         cutoffDate.setDate(cutoffDate.getDate() - TIME_WINDOW_DAYS);
-        
-        const CRYPTO_INSTRUMENT_TYPES = [28, 100028]; 
-        
+
+        // ID 10 is Cryptocurrencies
+        const CRYPTO_INSTRUMENT_TYPES = [10, 28, 100028]; 
+
         let isCryptoBuyer = false;
         let lastCryptoTrade = null;
-        
-        // 1. Check current portfolio
+        let identifiedCryptoInstrumentIDs = [];
+
+        // 3. Check current portfolio
         if (portfolio) {
-            const positions = DataExtractor.getPositions(portfolio, 'POPULAR_INVESTOR');
-            for (const pos of positions) {
-                const instrumentType = pos.InstrumentTypeID || 0;
-                if (CRYPTO_INSTRUMENT_TYPES.includes(instrumentType)) {
-                    isCryptoBuyer = true;
-                    lastCryptoTrade = new Date().toISOString(); 
-                    break;
+            const aggregatedTypes = portfolio.AggregatedPositionsByInstrumentTypeID || [];
+            const cryptoAggregate = aggregatedTypes.find(type => type.InstrumentTypeID === 10);
+
+            if (cryptoAggregate && cryptoAggregate.Invested > 0) {
+                isCryptoBuyer = true;
+                // Use the deterministic run date for the "last seen" timestamp
+                lastCryptoTrade = runDate.toISOString(); 
+
+                const allPositions = portfolio.AggregatedPositions || [];
+                
+                // DOMAIN OPTIMIZATION: Pre-filter to crypto assets only (6-digit IDs >= 100000)
+                // This reduces candidate pool from 50+ to ~5-15 assets
+                const cryptoCandidates = allPositions
+                    .filter(p => p.Invested > 0 && p.InstrumentID >= 100000)
+                    .map(p => ({
+                        id: p.InstrumentID,
+                        val: p.Invested
+                    }));
+
+                // Fast path: If crypto candidates sum exactly matches, we're done (O(N))
+                const cryptoSum = cryptoCandidates.reduce((sum, c) => sum + c.val, 0);
+                const tolerance = 0.0001; // 0.01% tolerance
+                
+                if (Math.abs(cryptoSum - cryptoAggregate.Invested) <= tolerance) {
+                    // Perfect match - all 6-digit IDs are the crypto assets
+                    identifiedCryptoInstrumentIDs = cryptoCandidates.map(c => c.id);
+                } else {
+                    // Fallback to subset sum (now with much smaller input)
+                    identifiedCryptoInstrumentIDs = this.solveSubsetSum(
+                        cryptoAggregate.Invested, 
+                        cryptoCandidates
+                    );
                 }
             }
         }
-        
-        // 2. Check history
+
+        // 4. Check history (Fallback)
         if (!isCryptoBuyer && historyDoc) {
             const trades = HistoryExtractor.getTrades(historyDoc);
             for (const trade of trades) {
                 const openDate = trade.OpenDateTime ? new Date(trade.OpenDateTime) : null;
+                // Filter against the deterministic cutoff date
                 if (!openDate || openDate < cutoffDate) continue;
-                
+
                 const instrumentType = trade.InstrumentTypeID || 0;
                 if (CRYPTO_INSTRUMENT_TYPES.includes(instrumentType)) {
                     isCryptoBuyer = true;
@@ -74,17 +120,242 @@ class PiCryptoBuyers {
                 }
             }
         }
-        
+
+        // 5. Store Result
+        // StandardExecutor reads directly from this.results[userId]
         this.results[userId] = {
             isCryptoBuyer,
-            lastCryptoTrade
+            lastCryptoTrade,
+            cryptoAssets: identifiedCryptoInstrumentIDs
         };
+
         return this.results;
     }
 
     async getResult() {
         return this.results;
     }
+
+    /**
+     * Master Solver Orchestrator
+     */
+    solveSubsetSum(targetFloat, candidates) {
+        const SCALE = 100000;
+        const TOLERANCE = Math.round(0.0001 * SCALE); // 0.01% tolerance for rounding
+        const target = Math.round(targetFloat * SCALE);
+        
+        // Canonicalize & Filter
+        const items = candidates
+            .map(c => ({ id: c.id, w: Math.round(c.val * SCALE) }))
+            .filter(c => c.w > 0 && c.w <= target + TOLERANCE);
+
+        // Early exit: no valid candidates
+        if (items.length === 0) return [];
+
+        // Domain Rule: Single Dominant Asset Check (with tolerance)
+        const exactMatch = items.find(i => Math.abs(i.w - target) <= TOLERANCE);
+        if (exactMatch) return [exactMatch.id];
+
+        // Complement Logic (60% threshold for better performance)
+        const totalSum = items.reduce((sum, item) => sum + item.w, 0);
+        let effectiveTarget = target;
+        let solvingForComplement = false;
+
+        if (target > (totalSum * 0.6)) {
+            effectiveTarget = totalSum - target;
+            solvingForComplement = true;
+        }
+
+        // Strategy Selection
+        let resultIds = [];
+        if (items.length <= 40) {
+            resultIds = this.solveBoundedDFS(effectiveTarget, items, TOLERANCE);
+        } else {
+            resultIds = this.solveMeetInTheMiddle(effectiveTarget, items, TOLERANCE);
+        }
+
+        // Return Result
+        if (!solvingForComplement) {
+            return resultIds;
+        } else {
+            const complementSet = new Set(resultIds);
+            return items.filter(i => !complementSet.has(i.id)).map(i => i.id);
+        }
+    }
+
+    /**
+     * STRATEGY A: Bounded-Choice DFS (N <= 40)
+     * Features: Suffix Max, Greedy Bounds, Early Termination, Tolerance
+     */
+    solveBoundedDFS(target, items, tolerance) {
+        // 1. Group by Weight
+        const groupsMap = new Map();
+        for (const item of items) {
+            if (!groupsMap.has(item.w)) {
+                groupsMap.set(item.w, { weight: item.w, ids: [] });
+            }
+            groupsMap.get(item.w).ids.push(item.id);
+        }
+
+        // 2. Sort Groups Descending (Greedy)
+        const groups = Array.from(groupsMap.values()).sort((a, b) => b.weight - a.weight);
+        groups.forEach(g => g.ids.sort()); // Deterministic ID order
+
+        // 3. Global GCD Pruning (skip if tolerance is active)
+        if (tolerance === 0 && groups.length > 0) {
+            let overallGCD = groups[0].weight;
+            for(let i=1; i<groups.length; i++) overallGCD = this.gcd(overallGCD, groups[i].weight);
+            if (target % overallGCD !== 0) return [];
+        }
+
+        // 4. Precompute Suffix Max
+        const suffixMax = new Array(groups.length).fill(0);
+        for (let i = groups.length - 1; i >= 0; i--) {
+            const groupMax = groups[i].weight * groups[i].ids.length;
+            suffixMax[i] = groupMax + (i < groups.length - 1 ? suffixMax[i+1] : 0);
+        }
+
+        const failedStates = new Set();
+        let bestSolution = null;
+
+        const dfs = (index, currentSum, currentSelection) => {
+            // Success (with tolerance)
+            if (Math.abs(currentSum - target) <= tolerance) {
+                if (!bestSolution || currentSelection.length < bestSolution.length) {
+                    bestSolution = [...currentSelection];
+                }
+                return true; // Signal early termination
+            }
+
+            // Pruning 1: Overshot or End
+            if (currentSum > target + tolerance || index >= groups.length) return false;
+
+            // Pruning 2: Best-Path Pruning
+            if (bestSolution && currentSelection.length >= bestSolution.length) return false;
+
+            // Pruning 3: Memoization
+            const stateKey = `${index}:${currentSum}`;
+            if (failedStates.has(stateKey)) return false;
+
+            // Pruning 4: Suffix Max
+            if (currentSum + suffixMax[index] < target - tolerance) {
+                failedStates.add(stateKey);
+                return false;
+            }
+
+            const group = groups[index];
+            const weight = group.weight;
+            const availableCount = group.ids.length;
+            const remainingSpace = target - currentSum + tolerance;
+            const maxCalc = Math.floor(remainingSpace / weight);
+            const maxToTake = Math.min(availableCount, maxCalc);
+
+            // Try taking k items (Greedy: largest k first)
+            for (let k = maxToTake; k >= 0; k--) {
+                const newSelection = [...currentSelection];
+                for(let i=0; i<k; i++) newSelection.push(group.ids[i]);
+
+                const foundSolution = dfs(index + 1, currentSum + (k * weight), newSelection);
+                
+                // Early termination: if we found optimal solution, stop
+                if (foundSolution && bestSolution && bestSolution.length === 1) {
+                    return true;
+                }
+            }
+            
+            if (!bestSolution) failedStates.add(stateKey);
+            return bestSolution !== null;
+        };
+
+        dfs(0, 0, []);
+        return bestSolution || [];
+    }
+
+    /**
+     * STRATEGY B: Meet-in-the-Middle (N > 40)
+     * Features: Early Exit, Tolerance, O(1) Lookup
+     */
+    solveMeetInTheMiddle(target, items, tolerance) {
+        const n = items.length;
+        const mid = Math.floor(n / 2);
+        const left = items.slice(0, mid);
+        const right = items.slice(mid);
+
+        // Generate Left Sums
+        const leftMap = new Map();
+        
+        const generateLeft = (pool) => {
+            const limit = 1 << pool.length;
+            for (let i = 0; i < limit; i++) {
+                let s = 0;
+                let ids = [];
+                for (let j = 0; j < pool.length; j++) {
+                    if ((i >> j) & 1) {
+                        s += pool[j].w;
+                        ids.push(pool[j].id);
+                    }
+                }
+                if (s <= target + tolerance) {
+                    // Early Exit on Left Side (with tolerance)
+                    if (Math.abs(s - target) <= tolerance) return { earlyExit: ids };
+                    
+                    // Store shortest solution for each sum
+                    if (!leftMap.has(s) || ids.length < leftMap.get(s).length) {
+                        leftMap.set(s, ids);
+                    }
+                }
+            }
+            return null;
+        };
+
+        const early = generateLeft(left);
+        if (early && early.earlyExit) return early.earlyExit;
+
+        // Iterate Right Side
+        const rightLimit = 1 << right.length;
+        let bestSolution = null;
+        
+        for (let i = 0; i < rightLimit; i++) {
+            let s = 0;
+            let rightIds = [];
+            for (let j = 0; j < right.length; j++) {
+                if ((i >> j) & 1) {
+                    s += right[j].w;
+                    rightIds.push(right[j].id);
+                }
+            }
+
+            // Early Exit Right Side (with tolerance)
+            if (Math.abs(s - target) <= tolerance) {
+                if (!bestSolution || rightIds.length < bestSolution.length) {
+                    bestSolution = rightIds;
+                }
+                continue;
+            }
+            
+            if (s > target + tolerance) continue;
+
+            // Check for complement in left map (with tolerance range)
+            const remainder = target - s;
+            
+            // Search within tolerance range
+            for (let delta = -tolerance; delta <= tolerance; delta++) {
+                const lookupSum = remainder + delta;
+                if (leftMap.has(lookupSum)) {
+                    const combined = [...leftMap.get(lookupSum), ...rightIds];
+                    if (!bestSolution || combined.length < bestSolution.length) {
+                        bestSolution = combined;
+                    }
+                }
+            }
+        }
+
+        return bestSolution || [];
+    }
+
+    gcd(a, b) {
+        return b === 0 ? a : this.gcd(b, a % b);
+    }
 }
 
 module.exports = PiCryptoBuyers;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-shared-calculations-unified",
-  "version": "1.0.156",
+  "version": "1.0.157",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [