bulltrackers-module 1.0.732 → 1.0.733

package/functions/computation-system/layers/index.js

@@ -1,40 +0,0 @@
-/**
- * @fileoverview Layers Barrel File
- * Aggregates all mathematical, extractor, and profiling primitives.
- * Utilizes require-all to dynamically load new modules added to this directory.
- */
-
-const requireAll = require('require-all');
-
-// 1. Manually Require Core Modules to ensure order and presence
-const profiling   = require('./profiling');
-const extractors  = require('./extractors');
-const mathematics = require('./mathematics');
-const validators  = require('./validators');
-
-// 2. Aggregate explicit exports
-const coreExports = {
-    ...profiling,
-    ...extractors,
-    ...mathematics,
-    ...validators
-};
-
-// 3. Dynamic Loading (Optional/Future-Proofing)
-// This loads any OTHER file in this directory that wasn't manually required above.
-const dynamicModules = requireAll({
-    dirname: __dirname,
-    filter: /^(?!index\.js$|profiling\.js$|extractors\.js$|mathematics\.js$|validators\.js$).+\.js$/, 
-    resolve: (mod) => mod
-});
-
-// Flatten dynamic modules into the export object
-const dynamicExports = {};
-Object.values(dynamicModules).forEach(moduleExports => {
-    Object.assign(dynamicExports, moduleExports);
-});
-
-module.exports = {
-    ...coreExports,
-    ...dynamicExports
-};

package/functions/computation-system/layers/mathematics.js

@@ -1,522 +0,0 @@
-/**
- * @fileoverview Mathematics Layer
- * Core mathematical functions, statistics, and signal primitives.
- */
-
-const { DataExtractor } = require('./extractors');
-const { SCHEMAS } = require('./profiling');
-
-class MathPrimitives {
-    static average(values) {
-        if (!values || !values.length) return 0;
-        return values.reduce((a, b) => a + b, 0) / values.length;
-    }
-    
-    static median(values) {
-        if (!values || !values.length) return 0;
-        const sorted = [...values].sort((a, b) => a - b);
-        const mid    = Math.floor(sorted.length / 2);
-        return sorted.length % 2 === 0
-            ? (sorted[mid - 1] + sorted[mid]) / 2
-            : sorted[mid];
-    }
-
-    static standardDeviation(values) {
-        if (!values || !values.length) return 0;
-        const avg         = this.average(values);
-        const squareDiffs = values.map(val => Math.pow((val || 0) - avg, 2));
-        return Math.sqrt(this.average(squareDiffs));
-    }
-
-    static bucketBinary(value, threshold = 0) {
-        return value > threshold ? 'winner' : 'loser';
-    }
-
-    static calculateHitProbability(currentPrice, barrierPrice, volatility, days, drift = 0) {
-        if (currentPrice <= 0 || barrierPrice <= 0 || volatility <= 0 || days <= 0) return 0;
-
-        const t          = days / 365.0; 
-        const sigma      = volatility;
-        const mu         = drift;
-        const b          = Math.log(barrierPrice / currentPrice);
-        const nu         = mu - 0.5 * Math.pow(sigma, 2);
-        const sqrtT      = Math.sqrt(t);
-        const sigmaSqrtT = sigma * sqrtT;
-
-        const normCDF = (x) => {
-            const t    = 1 / (1 + 0.2316419 * Math.abs(x));
-            const d    = 0.3989423 * Math.exp(-x * x / 2);
-            const prob = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))));
-            return x > 0 ? 1 - prob : prob;
-        };
-
-        const term1 = (b - nu * t) / sigmaSqrtT;
-        const term2 = (2 * nu * b) / (sigma * sigma);
-        const term3 = (b + nu * t) / sigmaSqrtT;
-
-        if ((currentPrice > barrierPrice && barrierPrice > currentPrice) || 
-            (currentPrice < barrierPrice && barrierPrice < currentPrice)) {
-             return 1.0;
-        }
-
-        const probability = normCDF(-term3) + Math.exp(term2) * normCDF(-term1);
-
-        return Math.min(Math.max(probability, 0), 1);
-    }
-
-    static simulateGBM(currentPrice, volatility, days, simulations = 1000, drift = 0) {
-        if (currentPrice <= 0 || volatility <= 0 || days <= 0) return new Float32Array(0);
-        
-        const t         = days / 365.0;
-        const sigma     = volatility;
-        const mu        = drift;
-        const driftTerm = (mu - 0.5 * sigma * sigma) * t;
-        const volTerm   = sigma * Math.sqrt(t);
-        
-        const results = new Float32Array(simulations);
-        
-        for (let i = 0; i < simulations; i++) {
-            const u1 = Math.random();
-            const u2 = Math.random();
-            const z  = Math.sqrt(-2.0 * Math.log(u1)) * Math.cos(2.0 * Math.PI * u2);
-            results[i] = currentPrice * Math.exp(driftTerm + volTerm * z);
-        }
-        return results;
-    }
-
-    static simulatePopulationBreakdown(pricePaths, userProfiles) {
-        if (!pricePaths.length || !userProfiles.length) return 0;
-        
-        let totalBreakdownEvents = 0;
-        const totalSims = pricePaths.length;
-        const totalUsers = userProfiles.length;
-
-        for (let i = 0; i < totalSims; i++) {
-            const simPrice = pricePaths[i];
-            let capitulatedUsersInScenario = 0;
-
-            for (let j = 0; j < totalUsers; j++) {
-                const user = userProfiles[j];
-                const hypotheticalPnL = ((simPrice - user.entryPrice) / user.entryPrice) * 100;
-                
-                if (hypotheticalPnL < user.thresholdPct) {
-                    capitulatedUsersInScenario++;
-                }
-            }
-            
-            totalBreakdownEvents += (capitulatedUsersInScenario / totalUsers);
-        }
-        
-        return totalBreakdownEvents / totalSims;
-    }
-}
-
-class FinancialEngineering {
-    static sortinoRatio(returns, targetReturn = 0) {
-        if (!returns || returns.length < 2) return 0;
-        const avgReturn = MathPrimitives.average(returns);
-        const downsideDiffs = returns.map(r => Math.min(0, r - targetReturn));
-        const downsideVariance = downsideDiffs.reduce((sum, d) => sum + (d * d), 0) / returns.length;
-        const downsideDev = Math.sqrt(downsideVariance);
-        if (downsideDev === 0) return 0;
-        return (avgReturn - targetReturn) / downsideDev;
-    }
-
-    static kellyCriterion(winRatio, avgWinPct, avgLossPct) {
-        const p = winRatio / 100;
-        const q = 1 - p;
-        const lossMag = Math.abs(avgLossPct);
-        if (lossMag === 0) return 0; 
-        const b = avgWinPct / lossMag; 
-        const f = (b * p - q) / b;
-        return Math.max(0, f); 
-    }
-}
-
-class TimeSeriesAnalysis {
-    static hurstExponent(series) {
-        if (!series || series.length < 10) return 0.5;
-        const logReturns = [];
-        for (let i = 1; i < series.length; i++) {
-            logReturns.push(Math.log(series[i] / series[i-1]));
-        }
-        const mean = MathPrimitives.average(logReturns);
-        const stdDev = MathPrimitives.standardDeviation(logReturns);
-        if (stdDev === 0) return 0.5;
-        const deviations = logReturns.map(r => r - mean);
-        let sum = 0;
-        const cumulativeDeviations = deviations.map(d => sum += d);
-        const maxDev = Math.max(...cumulativeDeviations);
-        const minDev = Math.min(...cumulativeDeviations);
-        const range = maxDev - minDev;
-        const rs = range / stdDev;
-        const n = logReturns.length;
-        const hurst = Math.log(rs) / Math.log(n);
-        return Math.min(1, Math.max(0, hurst));
-    }
-
-    /**
-     * UPGRADE: Fast Fourier Transform (Cooley-Tukey Algorithm) - O(n log n)
-     * Useful for detecting cycles in price data.
-     * @param {Array<number>} data - Input signal
-     * @returns {Array<Object>} Array of { real, imag } complex numbers
-     */
-    static fft(data) {
-        const n = data.length;
-        if (n <= 1) return data.map(v => ({ real: v, imag: 0 }));
-
-        if ((n & (n - 1)) !== 0) {
-            // If n is not power of 2, zero-pad to next power of 2 for O(n log n)
-            const nextPow2 = Math.pow(2, Math.ceil(Math.log2(n)));
-            const padded = new Array(nextPow2).fill(0);
-            for(let i=0; i<n; i++) padded[i] = data[i];
-            return this.fft(padded);
-        }
-
-        const even = new Array(n / 2);
-        const odd = new Array(n / 2);
-        for (let i = 0; i < n / 2; i++) {
-            even[i] = data[2 * i];
-            odd[i] = data[2 * i + 1];
-        }
-
-        const evenResult = this.fft(even);
-        const oddResult = this.fft(odd);
-
-        const result = new Array(n);
-        for (let k = 0; k < n / 2; k++) {
-            const t = -2 * Math.PI * k / n;
-            const expReal = Math.cos(t);
-            const expImag = Math.sin(t);
-            
-            // Multiply oddResult[k] by exp
-            const tReal = expReal * oddResult[k].real - expImag * oddResult[k].imag;
-            const tImag = expReal * oddResult[k].imag + expImag * oddResult[k].real;
-
-            result[k] = {
-                real: evenResult[k].real + tReal,
-                imag: evenResult[k].imag + tImag
-            };
-            result[k + n / 2] = {
-                real: evenResult[k].real - tReal,
-                imag: evenResult[k].imag - tImag
-            };
-        }
-        return result;
-    }
-}
-
-class SignalPrimitives {
-    static getMetric(dependencies, calcName, ticker, fieldName, fallback = 0) {
-        if (!dependencies || !dependencies[calcName]) return fallback;
-        const tickerData = dependencies[calcName][ticker];
-        if (!tickerData) return fallback;
-        const val = tickerData[fieldName];
-        return (typeof val === 'number') ? val : fallback;
-    }
-
-    static getUnionKeys(dependencies, calcNames) {
-        const keys = new Set();
-        if (!dependencies) return [];
-        for (const name of calcNames) {
-            const resultObj = dependencies[name];
-            if (resultObj && typeof resultObj === 'object') {
-                Object.keys(resultObj).forEach(k => keys.add(k));
-            }
-        }
-        return Array.from(keys);
-    }
-
-    static normalizeTanh(value, scale = 10, sensitivity = 10.0) {
-        if (value === 0) return 0;
-        return Math.tanh(value / sensitivity) * scale;
-    }
-
-    static normalizeZScore(value, mean, stdDev) {
-        if (!stdDev || stdDev === 0) return 0;
-        return (value - mean) / stdDev;
-    }
-
-    static divergence(valueA, valueB) {
-        return (valueA || 0) - (valueB || 0);
-    }
-
-    static getPreviousState(previousComputed, calcName, ticker, fieldName = null) {
-        if (!previousComputed || !previousComputed[calcName]) return null;
-        const tickerData = previousComputed[calcName][ticker];
-        if (!tickerData) return null;
-        if (fieldName) return tickerData[fieldName];
-        return tickerData; 
-    }
-}
-
-class Aggregators {
-    static bucketUsersByPnlPerAsset(usersData, tickerMap) {
-        const buckets = new Map();
-        for (const [userId, portfolio] of Object.entries(usersData)) {
-            const userType  = portfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
-            const positions = DataExtractor.getPositions(portfolio, userType);
-            for (const pos of positions) {
-                const id = DataExtractor.getInstrumentId(pos);
-                const pnl = DataExtractor.getNetProfit(pos);
-                if (!id || pnl === 0) continue;
-                const ticker = tickerMap[id];
-                if (!ticker) continue;
-                if (!buckets.has(ticker)) buckets.set(ticker, { winners: [], losers: [] });
-                const b = buckets.get(ticker);
-                if (pnl > 0) b.winners.push(userId);
-                else b.losers.push(userId);
-            }
-        }
-        return Object.fromEntries(buckets);
-    }
-
-    static getWeightedSentiment(positions) {
-        if (!positions || positions.length === 0) return 0;
-        let totalWeightedPnL = 0;
-        let totalWeight = 0;
-        for (const pos of positions) {
-            const pnl = DataExtractor.getNetProfit(pos);
-            const weight = DataExtractor.getPositionWeight(pos);
-            if (weight > 0) {
-                totalWeightedPnL += (pnl * weight);
-                totalWeight += weight;
-            }
-        }
-        if (totalWeight === 0) return 0;
-        return totalWeightedPnL / totalWeight;
-    }
-}
-
-class TimeSeries {
-    static updateEMAState(value, state, alpha = 0.1) {
-        const mean = state ? (state.mean || 0) : 0;
-        const variance = state ? (state.variance || 1) : 1; 
-        if (value === undefined || value === null || isNaN(value)) {
-            return { mean, variance };
-        }
-        const diff = value - mean;
-        const newMean = mean + (alpha * diff);
-        const newVariance = (1 - alpha) * (variance + (alpha * diff * diff));
-        return { mean: newMean, variance: newVariance };
-    }
-
-    static pearsonCorrelation(x, y) {
-        if (!x || !y || x.length !== y.length || x.length === 0) return 0;
-        const n = x.length;
-        let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
-        for (let i = 0; i < n; i++) {
-            sumX  += x[i]; sumY  += y[i];
-            sumXY += x[i] * y[i];
-            sumX2 += x[i] * x[i]; sumY2 += y[i] * y[i];
-        }
-        const numerator   = (n * sumXY) - (sumX * sumY);
-        const denominator = Math.sqrt(((n * sumX2) - (sumX * sumX)) * ((n * sumY2) - (sumY * sumY)));
-        return (denominator === 0) ? 0 : numerator / denominator;
-    }
-
-    /**
-     * UPGRADE: Sliding Window Min/Max using Monotonic Queue - O(n)
-     * Calculates rolling min/max for a stream of numbers efficiently.
-     * @param {Array<number>} data - Input series
-     * @param {number} windowSize - The rolling window size
-     * @returns {Object} { min: Array, max: Array }
-     */
-    static slidingWindowExtrema(data, windowSize) {
-        if (!data || data.length === 0) return { min: [], max: [] };
-        const resultMin = [];
-        const resultMax = [];
-        const dequeMin = []; // Indexes for Min (increasing values)
-        const dequeMax = []; // Indexes for Max (decreasing values)
-
-        for (let i = 0; i < data.length; i++) {
-            // 1. Remove out of range
-            if (dequeMin.length > 0 && dequeMin[0] <= i - windowSize) dequeMin.shift();
-            if (dequeMax.length > 0 && dequeMax[0] <= i - windowSize) dequeMax.shift();
-
-            // 2. Maintain Monotonic properties
-            // Min: Remove elements from tail that are >= current
-            while (dequeMin.length > 0 && data[dequeMin[dequeMin.length - 1]] >= data[i]) {
-                dequeMin.pop();
-            }
-            // Max: Remove elements from tail that are <= current
-            while (dequeMax.length > 0 && data[dequeMax[dequeMax.length - 1]] <= data[i]) {
-                dequeMax.pop();
-            }
-
-            // 3. Add current
-            dequeMin.push(i);
-            dequeMax.push(i);
-
-            // 4. Record result (once window is full)
-            if (i >= windowSize - 1) {
-                resultMin.push(data[dequeMin[0]]);
-                resultMax.push(data[dequeMax[0]]);
-            }
-        }
-        return { min: resultMin, max: resultMax };
-    }
-}
-
-class DistributionAnalytics {
-    static computeKDE(data, bandwidth, steps = 60) {
-        if (!data || data.length === 0) return [];
-        let min = Infinity, max = -Infinity;
-        for (const p of data) {
-            if (p.value < min) min = p.value;
-            if (p.value > max) max = p.value;
-        }
-        min -= bandwidth * 3;
-        max += bandwidth * 3;
-        const stepSize = (max - min) / steps;
-        const curve = [];
-        for (let i = 0; i <= steps; i++) {
-            const x = min + (i * stepSize);
-            let density = 0;
-            for (const p of data) {
-                const diff = (x - p.value);
-                if (Math.abs(diff) > bandwidth * 3) continue;
-                const u = diff / bandwidth;
-                const k = 0.39894228 * Math.exp(-0.5 * u * u); 
-                density += (p.weight * k) / bandwidth;
-            }
-            if (density > 0) curve.push({ price: x, density });
-        }
-        return curve;
-    }
-
-    static integrateProfile(curve, startPrice, endPrice) {
-        if (!curve || !Array.isArray(curve)) return 0;
-        let sum = 0;
-        for (let i = 0; i < curve.length - 1; i++) {
-            const p1 = curve[i];
-            const p2 = curve[i+1];
-            if (p1.price >= startPrice && p2.price <= endPrice) {
-                sum += (p2.price - p1.price) * ((p1.density + p2.density) / 2);
-            }
-        }
-        return sum;
-    }
-
-    static linearRegression(xValues, yValues) {
-        const n = xValues.length;
-        if (n !== yValues.length || n < 2) return { slope: 0, r2: 0 };
-        let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0, sumYY = 0;
-        for (let i = 0; i < n; i++) {
-            sumX  += xValues[i]; sumY  += yValues[i];
-            sumXY += xValues[i] * yValues[i];
-            sumXX += xValues[i] * xValues[i]; sumYY += yValues[i] * yValues[i];
-        }
-        const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
-        return { slope, n };
-    }
-}
-
-/**
- * file: computation-system/layers/mathematics.js
- * [Previous content remains, adding LinearAlgebra class]
- */
-
-class LinearAlgebra {
-    /**
-     * Calculates the Covariance Matrix and Mean Vector for a dataset
-     * @param {Array<Array<number>>} data - Rows are observations, Cols are features
-     * @returns {Object} { matrix: Array<Array<number>>, means: Array<number> }
-     */
-    static covarianceMatrix(data) {
-        if (!data || data.length === 0) return { matrix: [], means: [] };
-        const n = data.length;
-        const numFeatures = data[0].length;
-        
-        // 1. Calculate Means
-        const means = new Array(numFeatures).fill(0);
-        for (let i = 0; i < n; i++) {
-            for (let j = 0; j < numFeatures; j++) {
-                means[j] += data[i][j];
-            }
-        }
-        for (let j = 0; j < numFeatures; j++) means[j] /= n;
-
-        // 2. Calculate Covariance
-        // Cov(x,y) = Σ(x_i - x_mean)(y_i - y_mean) / (N-1)
-        const cov = Array(numFeatures).fill(0).map(() => Array(numFeatures).fill(0));
-        for (let i = 0; i < numFeatures; i++) {
-            for (let j = 0; j < numFeatures; j++) {
-                let sum = 0;
-                for (let k = 0; k < n; k++) {
-                    sum += (data[k][i] - means[i]) * (data[k][j] - means[j]);
-                }
-                cov[i][j] = sum / (n > 1 ? n - 1 : 1);
-            }
-        }
-        return { matrix: cov, means };
-    }
-
-    /**
-     * Inverts a Matrix using Gaussian Elimination
-     * Required to transform the distance into standard deviations
-     * @param {Array<Array<number>>} M - Square Matrix
-     */
-    static invertMatrix(M) {
-        if (!M || M.length === 0) return null;
-        const n = M.length;
-        
-        // Deep copy to create the augmented matrix [M | I]
-        const A = M.map(row => [...row]);
-        const I = Array(n).fill(0).map((_, i) => Array(n).fill(0).map((_, j) => (i === j ? 1 : 0)));
-
-        for (let i = 0; i < n; i++) {
-            // Find pivot
-            let pivot = A[i][i];
-            if (Math.abs(pivot) < 1e-10) return null; // Singular matrix (features are perfectly correlated)
-
-            // Normalize row i
-            for (let j = 0; j < n; j++) {
-                A[i][j] /= pivot;
-                I[i][j] /= pivot;
-            }
-
-            // Eliminate other rows
-            for (let k = 0; k < n; k++) {
-                if (k !== i) {
-                    const factor = A[k][i];
-                    for (let j = 0; j < n; j++) {
-                        A[k][j] -= factor * A[i][j];
-                        I[k][j] -= factor * I[i][j];
-                    }
-                }
-            }
-        }
-        return I;
-    }
-
-    /**
-     * Calculates Mahalanobis Distance
-     * D = sqrt( (x - μ)^T * Σ^-1 * (x - μ) )
-     * @param {Array<number>} vector - The current day's feature vector
-     * @param {Array<number>} means - The baseline mean vector
-     * @param {Array<Array<number>>} inverseCovariance - The inverted covariance matrix
-     */
-    static mahalanobisDistance(vector, means, inverseCovariance) {
-        if (!inverseCovariance || vector.length !== means.length) return 0;
-        const n = vector.length;
-        
-        // Difference Vector (x - μ)
-        const diff = vector.map((val, i) => val - means[i]);
-        
-        let distanceSq = 0;
-        for (let i = 0; i < n; i++) {
-            let rowSum = 0;
-            for (let j = 0; j < n; j++) {
-                rowSum += diff[j] * inverseCovariance[j][i];
-            }
-            distanceSq += rowSum * diff[i];
-        }
-        
-        return Math.sqrt(Math.max(0, distanceSq));
-    }
-}
-
-// ... existing exports ...
-module.exports = { MathPrimitives, SignalPrimitives, Aggregators, TimeSeries, DistributionAnalytics, FinancialEngineering, TimeSeriesAnalysis, LinearAlgebra };
-