@buley/hexgrid-3d 1.0.0 → 1.1.1

package/src/algorithms/OutlierDetection.ts

@@ -159,7 +159,9 @@ export function detectGrowthSpikes(values: number[]): TimeSeriesAnomaly[] {
   });
 }
 
-export function detectVarianceChanges(values: number[]): VarianceChangeResult[] {
+export function detectVarianceChanges(
+  values: number[]
+): VarianceChangeResult[] {
   if (values.length < 6) return [];
   const results: VarianceChangeResult[] = [];
   const windowSize = Math.max(3, Math.floor(values.length / 4));
@@ -171,7 +173,8 @@ export function detectVarianceChanges(values: number[]): VarianceChangeResult[]
     const afterMean = mean(after);
     const beforeVar = stdDev(before, beforeMean) ** 2;
     const afterVar = stdDev(after, afterMean) ** 2;
-    const ratio = beforeVar === 0 ? (afterVar === 0 ? 1 : Infinity) : afterVar / beforeVar;
+    const ratio =
+      beforeVar === 0 ? (afterVar === 0 ? 1 : Infinity) : afterVar / beforeVar;
 
     results.push({
       index: i,
@@ -199,18 +202,22 @@ export interface GameAnomaly {
   description: string;
 }
 
-export function detectGameAnomalies(values: number[], windowSize: number = 5): GameAnomaly[] {
+export function detectGameAnomalies(
+  values: number[],
+  windowSize: number = 5
+): GameAnomaly[] {
   const anomalies: GameAnomaly[] = [];
   if (values.length < windowSize * 2) return anomalies;
-  
+
   for (let i = windowSize; i < values.length - windowSize; i++) {
     const before = values.slice(i - windowSize, i);
     const after = values.slice(i, i + windowSize);
     const beforeMean = before.reduce((s, v) => s + v, 0) / before.length;
     const afterMean = after.reduce((s, v) => s + v, 0) / after.length;
     const change = Math.abs(afterMean - beforeMean);
-    const threshold = before.reduce((s, v) => s + Math.abs(v - beforeMean), 0) / before.length;
-    
+    const threshold =
+      before.reduce((s, v) => s + Math.abs(v - beforeMean), 0) / before.length;
+
     if (change > threshold * 2) {
       anomalies.push({
         index: i,
@@ -220,7 +227,7 @@ export function detectGameAnomalies(values: number[], windowSize: number = 5): G
       });
     }
   }
-  
+
   return anomalies;
 }
 
@@ -231,22 +238,32 @@ export interface MultivariateOutlierResult {
   method: string;
 }
 
-export function comprehensiveOutlierAnalysis(values: number[]): MultivariateOutlierResult {
+export function comprehensiveOutlierAnalysis(
+  values: number[]
+): MultivariateOutlierResult {
   const zScore = detectOutliersZScore(values);
   const iqr = detectOutliersIQR(values);
   const combined = new Set([...zScore.outlierIndices, ...iqr.outlierIndices]);
-  
+
   return {
     outliers: Array.from(combined),
-    scores: values.map((v, i) => 
-      combined.has(i) ? Math.max(Math.abs(zScore.scores[i] ?? 0), Math.abs(iqr.scores[i] ?? 0)) : 0
+    scores: values.map((v, i) =>
+      combined.has(i)
+        ? Math.max(
+            Math.abs(zScore.scores[i] ?? 0),
+            Math.abs(iqr.scores[i] ?? 0)
+          )
+        : 0
     ),
     method: 'comprehensive',
   };
 }
 
 // Local Outlier Factor (simplified)
-export function localOutlierFactor(values: number[], k: number = 5): OutlierResult {
+export function localOutlierFactor(
+  values: number[],
+  k: number = 5
+): OutlierResult {
   // Simplified LOF implementation
   if (values.length < k + 1) {
     return {
@@ -256,32 +273,33 @@ export function localOutlierFactor(values: number[], k: number = 5): OutlierResu
       threshold: 1.5,
     };
   }
-  
+
   const scores: number[] = [];
   for (let i = 0; i < values.length; i++) {
-    const distances = values.map((v, j) => 
-      i === j ? Infinity : Math.abs(v - values[i]!)
-    ).sort((a, b) => a - b);
+    const distances = values
+      .map((v, j) => (i === j ? Infinity : Math.abs(v - values[i]!)))
+      .sort((a, b) => a - b);
     const kthDistance = distances[k] ?? 0;
-    const reachability = values.map((v, j) => 
+    const reachability = values.map((v, j) =>
       Math.max(kthDistance, Math.abs(v - values[i]!))
     );
     const lrd = k / reachability.reduce((s, r) => s + r, 0);
     scores.push(lrd);
   }
-  
+
   const avgLrd = scores.reduce((s, lrd) => s + lrd, 0) / scores.length;
-  const lofScores = scores.map(lrd => lrd === 0 ? 0 : avgLrd / lrd);
+  const lofScores = scores.map((lrd) => (lrd === 0 ? 0 : avgLrd / lrd));
   const threshold = 1.5;
   const outlierIndices = lofScores
     .map((score, idx) => ({ score, idx }))
     .filter(({ score }) => score > threshold)
     .map(({ idx }) => idx);
-  
+
   const avg = values.reduce((s, v) => s + v, 0) / values.length;
-  const variance = values.reduce((s, v) => s + Math.pow(v - avg, 2), 0) / values.length;
+  const variance =
+    values.reduce((s, v) => s + Math.pow(v - avg, 2), 0) / values.length;
   const stdDev = Math.sqrt(variance);
-  
+
   return {
     outlierIndices,
     scores: lofScores,
@@ -291,11 +309,15 @@ export function localOutlierFactor(values: number[], k: number = 5): OutlierResu
 }
 
 // Isolation Forest (simplified)
-export function isolationForest(values: number[], trees: number = 100, samples: number = 256): OutlierResult {
+export function isolationForest(
+  values: number[],
+  trees: number = 100,
+  samples: number = 256
+): OutlierResult {
   // Simplified isolation forest
   const scores: number[] = [];
   const sampleSize = Math.min(samples, values.length);
-  
+
   for (let i = 0; i < values.length; i++) {
     let pathLengthSum = 0;
     for (let t = 0; t < trees; t++) {
@@ -313,17 +335,18 @@ export function isolationForest(values: number[], trees: number = 100, samples:
     const anomalyScore = Math.pow(2, -avgPathLength / Math.log2(sampleSize));
     scores.push(anomalyScore);
   }
-  
+
   const threshold = 0.5;
   const outlierIndices = scores
     .map((score, idx) => ({ score, idx }))
     .filter(({ score }) => score > threshold)
     .map(({ idx }) => idx);
-  
+
   const avg = values.reduce((s, v) => s + v, 0) / values.length;
-  const variance = values.reduce((s, v) => s + Math.pow(v - avg, 2), 0) / values.length;
+  const variance =
+    values.reduce((s, v) => s + Math.pow(v - avg, 2), 0) / values.length;
   const stdDev = Math.sqrt(variance);
-  
+
   return {
     outlierIndices,
     scores,
@@ -333,16 +356,21 @@ export function isolationForest(values: number[], trees: number = 100, samples:
 }
 
 // CUSUM Chart
-export function cusumChart(values: number[], target: number, h: number = 5, k: number = 0.5): TimeSeriesAnomaly[] {
+export function cusumChart(
+  values: number[],
+  target: number,
+  h: number = 5,
+  k: number = 0.5
+): TimeSeriesAnomaly[] {
   const anomalies: TimeSeriesAnomaly[] = [];
   let sPos = 0;
   let sNeg = 0;
-  
+
   for (let i = 0; i < values.length; i++) {
     const deviation = values[i]! - target;
     sPos = Math.max(0, sPos + deviation - k);
     sNeg = Math.max(0, sNeg - deviation - k);
-    
+
     if (sPos > h || sNeg > h) {
       anomalies.push({
         index: i,
@@ -355,25 +383,31 @@ export function cusumChart(values: number[], target: number, h: number = 5, k: n
       });
     }
   }
-  
+
   return anomalies;
 }
 
 // EWMA Chart (Exponentially Weighted Moving Average)
-export function ewmaChart(values: number[], lambda: number = 0.2, lcl: number = -3, ucl: number = 3): TimeSeriesAnomaly[] {
+export function ewmaChart(
+  values: number[],
+  lambda: number = 0.2,
+  lcl: number = -3,
+  ucl: number = 3
+): TimeSeriesAnomaly[] {
   const anomalies: TimeSeriesAnomaly[] = [];
   if (values.length === 0) return anomalies;
-  
+
   let ewma = values[0]!;
   const mean = values.reduce((s, v) => s + v, 0) / values.length;
-  const variance = values.reduce((s, v) => s + Math.pow(v - mean, 2), 0) / values.length;
+  const variance =
+    values.reduce((s, v) => s + Math.pow(v - mean, 2), 0) / values.length;
   const stdDev = Math.sqrt(variance);
   const ewmaStdDev = stdDev * Math.sqrt(lambda / (2 - lambda));
-  
+
   for (let i = 1; i < values.length; i++) {
     ewma = lambda * values[i]! + (1 - lambda) * ewma;
     const zScore = (ewma - mean) / (ewmaStdDev || 1);
-    
+
     if (zScore < lcl || zScore > ucl) {
       anomalies.push({
         index: i,
@@ -386,6 +420,6 @@ export function ewmaChart(values: number[], lambda: number = 0.2, lcl: number =
       });
     }
   }
-  
+
   return anomalies;
 }

package/src/algorithms/ParticleSystem.ts

@@ -44,7 +44,15 @@ export class ParticleEffectManager {
     this.systems.set('default', new ParticleSystem());
   }
 
-  triggerEffect(effect: ParticleEffect, position: Vector2, options?: { count?: number; color?: [number, number, number]; velocity?: Vector2 }): void {
+  triggerEffect(
+    effect: ParticleEffect,
+    position: Vector2,
+    options?: {
+      count?: number;
+      color?: [number, number, number];
+      velocity?: Vector2;
+    }
+  ): void {
     const system = this.systems.get('default');
     if (!system) return;
     const count = options?.count ?? 1;
@@ -54,7 +62,9 @@ export class ParticleEffectManager {
         x: position.x,
         y: position.y,
         size: 4,
-        color: `rgb(${Math.round(color[0] * 255)}, ${Math.round(color[1] * 255)}, ${Math.round(color[2] * 255)})`,
+        color: `rgb(${Math.round(color[0] * 255)}, ${Math.round(
+          color[1] * 255
+        )}, ${Math.round(color[2] * 255)})`,
         alpha: 1,
       });
     }