@ch20026103/anysis 0.0.17-alpha2 → 0.0.19-alpha

package/dist/esm/stockSkills/mfi.js

@@ -0,0 +1,164 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var Mfi = /** @class */ (function () {
+    function Mfi() {
+    }
+    // 計算典型價格 (Typical Price)
+    Object.defineProperty(Mfi.prototype, "getTypicalPrice", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data) {
+            return (data.h + data.l + data.c) / 3;
+        }
+    });
+    // 計算原始資金流量 (Raw Money Flow)
+    Object.defineProperty(Mfi.prototype, "getRawMoneyFlow", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data) {
+            return this.getTypicalPrice(data) * data.v;
+        }
+    });
+    Object.defineProperty(Mfi.prototype, "init", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data, type) {
+            return {
+                dataset: [data],
+                mfi: null,
+                type: type,
+                sumPositiveMF: 0,
+                sumNegativeMF: 0,
+            };
+        }
+    });
+    Object.defineProperty(Mfi.prototype, "next", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (data, preList, type) {
+            preList.dataset.push(data);
+            // 資料不足，不計算 MFI
+            if (preList.dataset.length < type + 1) {
+                return __assign(__assign({}, preList), { mfi: null, type: type, sumPositiveMF: 0, sumNegativeMF: 0 });
+            }
+            var sumPositiveMF = preList.sumPositiveMF;
+            var sumNegativeMF = preList.sumNegativeMF;
+            if (preList.dataset.length === type + 1) {
+                // 第一次達到計算條件，初始化計算
+                sumPositiveMF = 0;
+                sumNegativeMF = 0;
+                for (var i = 1; i <= type; i++) {
+                    var currentTP = this.getTypicalPrice(preList.dataset[i]);
+                    var prevTP = this.getTypicalPrice(preList.dataset[i - 1]);
+                    var rawMF = this.getRawMoneyFlow(preList.dataset[i]);
+                    if (currentTP > prevTP) {
+                        sumPositiveMF += rawMF;
+                    }
+                    else if (currentTP < prevTP) {
+                        sumNegativeMF += rawMF;
+                    }
+                }
+            }
+            else {
+                // 增量更新：移除最舊的影響，加上最新的影響
+                // 移除最舊的資料影響
+                var oldestTP = this.getTypicalPrice(preList.dataset[0]);
+                var secondOldestTP = this.getTypicalPrice(preList.dataset[1]);
+                var oldestRawMF = this.getRawMoneyFlow(preList.dataset[1]);
+                if (secondOldestTP > oldestTP) {
+                    sumPositiveMF -= oldestRawMF;
+                }
+                else if (secondOldestTP < oldestTP) {
+                    sumNegativeMF -= oldestRawMF;
+                }
+                // 移除最舊的資料
+                preList.dataset.shift();
+                // 加上最新的資料影響
+                var newTP = this.getTypicalPrice(preList.dataset[preList.dataset.length - 1]);
+                var prevTP = this.getTypicalPrice(preList.dataset[preList.dataset.length - 2]);
+                var newRawMF = this.getRawMoneyFlow(preList.dataset[preList.dataset.length - 1]);
+                if (newTP > prevTP) {
+                    sumPositiveMF += newRawMF;
+                }
+                else if (newTP < prevTP) {
+                    sumNegativeMF += newRawMF;
+                }
+            }
+            // 計算 MFI
+            var mfi;
+            if (sumNegativeMF === 0) {
+                mfi = 100;
+            }
+            else {
+                var moneyFlowRatio = sumPositiveMF / sumNegativeMF;
+                mfi = 100 - (100 / (1 + moneyFlowRatio));
+            }
+            return {
+                dataset: preList.dataset,
+                type: type,
+                mfi: mfi,
+                sumPositiveMF: sumPositiveMF,
+                sumNegativeMF: sumNegativeMF
+            };
+        }
+    });
+    Object.defineProperty(Mfi.prototype, "calculateMFI", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (prices, period) {
+            if (period === void 0) { period = 14; }
+            if (prices.length < period + 1) {
+                return [];
+            }
+            var mfis = [];
+            // 從 period 開始，確保有足夠的資料進行比較
+            for (var endIdx = period; endIdx < prices.length; endIdx++) {
+                var sumPositiveMF = 0;
+                var sumNegativeMF = 0;
+                // 計算 period 個交易日的資金流量
+                // 從 endIdx - period + 1 到 endIdx，共 period 個資料點
+                // 但比較是從 endIdx - period + 2 開始（因為要跟前一天比）
+                for (var i = endIdx - period + 1; i <= endIdx; i++) {
+                    // 確保 i-1 >= 0，避免溢位
+                    if (i === 0)
+                        continue;
+                    var currentTP = this.getTypicalPrice(prices[i]);
+                    var prevTP = this.getTypicalPrice(prices[i - 1]);
+                    var rawMF = this.getRawMoneyFlow(prices[i]);
+                    if (currentTP > prevTP) {
+                        sumPositiveMF += rawMF;
+                    }
+                    else if (currentTP < prevTP) {
+                        sumNegativeMF += rawMF;
+                    }
+                }
+                // 計算 MFI
+                if (sumNegativeMF === 0) {
+                    mfis.push(100);
+                }
+                else {
+                    var moneyFlowRatio = sumPositiveMF / sumNegativeMF;
+                    var mfi = 100 - (100 / (1 + moneyFlowRatio));
+                    mfis.push(mfi);
+                }
+            }
+            return mfis;
+        }
+    });
+    return Mfi;
+}());
+export default Mfi;

package/dist/esm/stockSkills/mfi.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/stockSkills/mfi.test.js

@@ -0,0 +1,191 @@
+import Mfi from './mfi';
+describe('MFI (Money Flow Index) Algorithm', function () {
+    var mfi;
+    beforeEach(function () {
+        mfi = new Mfi();
+    });
+    // 測試用的股票資料
+    var createStockData = function (high, low, close, volume) { return ({
+        h: high,
+        l: low,
+        c: close,
+        v: volume,
+        o: close,
+        t: Date.now()
+    }); };
+    describe('init method', function () {
+        it('should initialize with correct default values', function () {
+            var stockData = createStockData(100, 95, 98, 1000);
+            var result = mfi.init(stockData, 14);
+            expect(result).toEqual({
+                dataset: [stockData],
+                mfi: null,
+                type: 14,
+                sumPositiveMF: 0,
+                sumNegativeMF: 0,
+            });
+        });
+        it('should work with different period types', function () {
+            var stockData = createStockData(100, 95, 98, 1000);
+            var result = mfi.init(stockData, 5);
+            expect(result.type).toBe(5);
+            expect(result.dataset).toHaveLength(1);
+        });
+    });
+    describe('next method - insufficient data', function () {
+        it('should return null MFI when data is insufficient', function () {
+            var result = mfi.init(createStockData(100, 95, 98, 1000), 3);
+            // 第二個資料點
+            result = mfi.next(createStockData(102, 97, 100, 1200), result, 3);
+            expect(result.mfi).toBeNull();
+            expect(result.dataset).toHaveLength(2);
+            // 第三個資料點
+            result = mfi.next(createStockData(105, 99, 103, 1500), result, 3);
+            expect(result.mfi).toBeNull();
+            expect(result.dataset).toHaveLength(3);
+        });
+    });
+    describe('next method - sufficient data', function () {
+        it('should calculate MFI correctly when reaching minimum period', function () {
+            var period = 3;
+            var result = mfi.init(createStockData(100, 95, 98, 1000), period);
+            // 添加資料直到滿足計算條件
+            result = mfi.next(createStockData(102, 97, 100, 1200), result, period); // TP上升
+            result = mfi.next(createStockData(105, 99, 103, 1500), result, period); // TP上升  
+            result = mfi.next(createStockData(103, 98, 101, 1300), result, period); // TP下降
+            expect(result.mfi).not.toBeNull();
+            expect(typeof result.mfi).toBe('number');
+            expect(result.mfi).toBeGreaterThanOrEqual(0);
+            expect(result.mfi).toBeLessThanOrEqual(100);
+            expect(result.dataset).toHaveLength(period + 1);
+        });
+        it('should handle all positive money flows (MFI = 100)', function () {
+            var period = 2;
+            var result = mfi.init(createStockData(100, 95, 98, 1000), period);
+            // 所有後續價格都上升
+            result = mfi.next(createStockData(102, 97, 100, 1200), result, period);
+            result = mfi.next(createStockData(105, 99, 103, 1500), result, period);
+            expect(result.mfi).toBe(100);
+        });
+        it('should maintain sliding window correctly', function () {
+            var period = 2;
+            var result = mfi.init(createStockData(100, 95, 98, 1000), period);
+            result = mfi.next(createStockData(102, 97, 100, 1200), result, period);
+            result = mfi.next(createStockData(105, 99, 103, 1500), result, period);
+            // 新增第五個資料點，應該移除第一個
+            var oldFirstData = result.dataset[0];
+            result = mfi.next(createStockData(103, 98, 101, 1300), result, period);
+            expect(result.dataset).toHaveLength(period + 1);
+            expect(result.dataset[0]).not.toEqual(oldFirstData);
+        });
+    });
+    describe('calculateMFI method', function () {
+        it('should return empty array for insufficient data', function () {
+            var prices = [
+                createStockData(100, 95, 98, 1000),
+                createStockData(102, 97, 100, 1200),
+            ];
+            var result = mfi.calculateMFI(prices, 14);
+            expect(result).toEqual([]);
+        });
+        it('should calculate MFI for sufficient data', function () {
+            // 創建測試資料：期間為3，需要4個資料點
+            var prices = [
+                createStockData(100, 95, 98, 1000),
+                createStockData(102, 97, 100, 1200),
+                createStockData(105, 99, 103, 1500),
+                createStockData(103, 98, 101, 1300), // TP = 100.67 (下降)
+            ];
+            var result = mfi.calculateMFI(prices, 3);
+            expect(result).toHaveLength(1); // 只能計算一個MFI值
+            expect(result[0]).toBeGreaterThanOrEqual(0);
+            expect(result[0]).toBeLessThanOrEqual(100);
+        });
+        it('should calculate multiple MFI values for longer data series', function () {
+            var prices = [];
+            // 創建6個資料點，期間為3，應該能計算3個MFI值
+            for (var i = 0; i < 6; i++) {
+                prices.push(createStockData(100 + i * 2, 95 + i * 2, 98 + i * 2 + (i % 2 === 0 ? 1 : -1), // 交替上下
+                1000 + i * 100));
+            }
+            var result = mfi.calculateMFI(prices, 3);
+            expect(result).toHaveLength(3); // 6 - 3 = 3個MFI值
+            result.forEach(function (mfiValue) {
+                expect(mfiValue).toBeGreaterThanOrEqual(0);
+                expect(mfiValue).toBeLessThanOrEqual(100);
+            });
+        });
+        it('should handle edge case with no negative money flow', function () {
+            // 創建持續上升的價格資料
+            var prices = [];
+            for (var i = 0; i < 5; i++) {
+                prices.push(createStockData(100 + i * 5, 95 + i * 5, 98 + i * 5, 1000));
+            }
+            var result = mfi.calculateMFI(prices, 3);
+            expect(result).toHaveLength(2);
+            result.forEach(function (mfiValue) {
+                expect(mfiValue).toBe(100); // 全部正向資金流量
+            });
+        });
+        it('should handle equal typical prices correctly', function () {
+            var prices = [
+                createStockData(100, 95, 98, 1000),
+                createStockData(102, 97, 99, 1200),
+                createStockData(101, 96, 99, 1500),
+                createStockData(103, 98, 100, 1300),
+                createStockData(102, 97, 99, 1100), // TP = 99.33 (相等)
+            ];
+            var result = mfi.calculateMFI(prices, 3);
+            expect(result).toHaveLength(2);
+            result.forEach(function (mfiValue) {
+                expect(mfiValue).toBeGreaterThanOrEqual(0);
+                expect(mfiValue).toBeLessThanOrEqual(100);
+                expect(Number.isNaN(mfiValue)).toBe(false);
+            });
+        });
+    });
+    describe('typical price calculation', function () {
+        it('should calculate typical price correctly', function () {
+            var stockData = createStockData(105, 95, 100, 1000);
+            var mfiInstance = new Mfi();
+            // 使用反射來測試私有方法（僅用於測試）
+            var typicalPrice = mfiInstance.getTypicalPrice(stockData);
+            expect(typicalPrice).toBeCloseTo((105 + 95 + 100) / 3, 2);
+        });
+    });
+    describe('raw money flow calculation', function () {
+        it('should calculate raw money flow correctly', function () {
+            var stockData = createStockData(105, 95, 100, 1500);
+            var mfiInstance = new Mfi();
+            var typicalPrice = (105 + 95 + 100) / 3;
+            var expectedMF = typicalPrice * 1500;
+            var rawMF = mfiInstance.getRawMoneyFlow(stockData);
+            expect(rawMF).toBeCloseTo(expectedMF, 2);
+        });
+    });
+    describe('consistency between methods', function () {
+        it('should produce same results using next() and calculateMFI()', function () {
+            var prices = [];
+            for (var i = 0; i < 8; i++) {
+                prices.push(createStockData(100 + i * 3, 95 + i * 2, 98 + i * 2.5, 1000 + i * 50));
+            }
+            var period = 3;
+            // 使用 calculateMFI
+            var batchResult = mfi.calculateMFI(prices, period);
+            // 使用 next 方法逐步計算
+            var result = mfi.init(prices[0], period);
+            var nextResults = [];
+            for (var i = 1; i < prices.length; i++) {
+                result = mfi.next(prices[i], result, period);
+                nextResults.push(result.mfi);
+            }
+            // 過濾掉 null 值
+            var validNextResults = nextResults.filter(function (val) { return val !== null; });
+            expect(validNextResults).toHaveLength(batchResult.length);
+            // 比較結果（允許小的浮點誤差）
+            for (var i = 0; i < batchResult.length; i++) {
+                expect(validNextResults[i]).toBeCloseTo(batchResult[i], 6);
+            }
+        });
+    });
+});