ama failed test but working prototype

Author: BusinessDuck

src/ama.ts

@@ -3,67 +3,51 @@ import { CircularBuffer } from './providers/circular-buffer';
 export class AMA {
     private circular: CircularBuffer;
     private sumNoise = 0;
-    private prevAMA: number | null = null;
+    private prevPrice: number;
+    private prevAMA: number;
     private nfastend: number;
     private nslowend: number;
 
     constructor(length: number, fastend: number = 4, slowend: number = 30) {
         this.circular = new CircularBuffer(length);
         this.nfastend = 2 / (fastend + 1);
         this.nslowend = 2 / (slowend + 1);
+        this.prevPrice = 0; // Можно инициализировать значением, например, первым полученным значением цены
+        this.prevAMA = 0; // Аналогично
     }
 
     nextValue(price: number) {
         // Add the new value to the circular buffer and get the noise
-        const noise = this.circular.push(Math.abs(price - (this.circular.peek() ?? price)));
-
-        // Sum of absolute price differences (noise)
-        this.sumNoise += noise;
+        const prevPrice = this.prevPrice;
+        const priceChange = Math.abs(price - prevPrice);
+        const prevChange = this.circular.push(priceChange) ?? 0;
+        this.sumNoise += priceChange - (this.circular.filled ? prevChange : 0);
 
         if (!this.circular.filled) {
-            // Not enough data to calculate yet
+            // Not enough data to calculate yet, return undefined
+            this.prevAMA = price;
+            this.prevPrice = price; // Update prevPrice
             return;
         }
 
-        this.nextValue = (price: number) => {
-            const prevPrice = this.circular.peek() ?? price;
-            const priceChange = Math.abs(price - prevPrice);
-            this.sumNoise = this.sumNoise - this.circular.push(priceChange) + priceChange;
-
-            // Efficiency Ratio (ER)
-            const signal = Math.abs(price - prevPrice);
-            const noiseSum = this.sumNoise;
-            const er = noiseSum !== 0 ? signal / noiseSum : 0;
-
-            // Smoothing Constant (SC)
-            const smooth = Math.pow(er * (this.nfastend - this.nslowend) + this.nslowend, 2);
-
-            // AMA Calculation
-            const currentAMA = this.prevAMA !== null
-                ? this.prevAMA + smooth * (price - this.prevAMA)
-                : price; // Initialize with the price if first value
-
-            this.prevAMA = currentAMA;
-            return currentAMA;
-        };
+        // Efficiency Ratio (ER)
+        const signal = Math.abs(price - prevPrice);
+        const noiseSum = this.sumNoise;
+        const er = noiseSum !== 0 ? signal / noiseSum : 0;
 
-        this.momentValue = (price: number) => {
-            const prevPrice = this.circular.peek() ?? price;
-            const signal = Math.abs(price - prevPrice);
-            const noiseSum = this.sumNoise;
-            const er = noiseSum !== 0 ? signal / noiseSum : 0;
-            const smooth = Math.pow(er * (this.nfastend - this.nslowend) + this.nslowend, 2);
+        // Smoothing Constant (SC)
+        const smooth = Math.pow(er * (this.nfastend - this.nslowend) + this.nslowend, 2);
 
-            return this.prevAMA !== null
-                ? this.prevAMA + smooth * (price - this.prevAMA)
-                : price; // Use price as initial value if no previous AMA
-        };
+        // AMA Calculation
+        const currentAMA = this.prevAMA + smooth * (price - this.prevAMA);
 
-        // Calculate the initial AMA value when enough data is available
-        return price;
+        this.prevAMA = currentAMA;
+        this.prevPrice = price; // Update prevPrice
+        return currentAMA;
     }
 
-    momentValue(price: number): number {
-        return price; // Placeholder until `nextValue` is fully initialized
+    momentValue(): number {
+        // Return the last calculated AMA value
+        return this.prevAMA;
     }
 }

tests/.DS_Store

@@ -3,16 +3,17 @@ import { data } from './data';
 
 describe('Adaptive Moving Average', () => {
     const ama = new AMA(15, 2, 30);
-    const EPSILON = 0.0001;
+    const EPSILON = 0.01;
 
     it('Excel validate', () => {
         data.forEach((tick, idx) => {
-            const amaValue = ama.nextValue(Number(tick.Close));
-            const expected = Number(tick.AMA);
+            const amaValue = ama.nextValue(tick.c);
+            const expected = Number(tick.ama);
 
-            console.log(amaValue, expected);
+            if (amaValue) {
+                expect(Math.abs(amaValue - expected)).toBeLessThan(EPSILON);
+            }
 
-            // expect(amaValue).toBe(Number(expected));
         });
     });
 });