@vulcan-js/indicators 0.0.0

package/dist/index.js

@@ -0,0 +1,683 @@
+import { assert, createSignal } from "@vulcan-js/core";
+import { abs, add, div, divide, eq, equal, from, gt, lt, mul, multiply, sub, subtract } from "dnum";
+
+//#region src/trend/exponentialMovingAverage.ts
+const defaultExponentialMovingAverageOptions = { period: 12 };
+/**
+* Exponential Moving Average (EMA)
+*
+* EMA = Price * k + PrevEMA * (1 - k)
+* Where k = 2 / (period + 1)
+*/
+const ema = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	const k = divide(from(2, 18), from(1 + period, 18), 18);
+	const m = subtract(from(1, 18), k);
+	let prev;
+	return (value) => {
+		if (prev === void 0) {
+			prev = from(value, 18);
+			return prev;
+		}
+		prev = add(mul(value, k, 18), mul(prev, m, 18));
+		return prev;
+	};
+}, defaultExponentialMovingAverageOptions);
+
+//#endregion
+//#region src/momentum/absolutePriceOscillator.ts
+const defaultAbsolutePriceOscillatorOptions = {
+	fastPeriod: 12,
+	slowPeriod: 26
+};
+const apo = createSignal(({ fastPeriod, slowPeriod }) => {
+	assert(Number.isInteger(fastPeriod) && fastPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected fastPeriod to be a positive integer, got ${fastPeriod}`));
+	assert(Number.isInteger(slowPeriod) && slowPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected slowPeriod to be a positive integer, got ${slowPeriod}`));
+	const fastProc = ema.create({ period: fastPeriod });
+	const slowProc = ema.create({ period: slowPeriod });
+	return (value) => sub(fastProc(value), slowProc(value));
+}, defaultAbsolutePriceOscillatorOptions);
+
+//#endregion
+//#region src/trend/simpleMovingAverage.ts
+const defaultSMAOptions = { period: 2 };
+/**
+* Simple Moving Average (SMA)
+*
+* Calculates the arithmetic mean of a set of values over a specified period.
+* The SMA is calculated by summing all values in the period and dividing by the period length.
+*
+* Formula: SMA = (P1 + P2 + ... + Pn) / n
+* Where: P = Price values, n = Period
+*
+* @param source - Iterable of price values
+* @param options - Configuration options
+* @param options.period - The period for calculating the moving average (default: 2)
+* @returns Generator yielding SMA values
+*/
+const sma = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	const buffer = Array.from({ length: period });
+	let head = 0;
+	let count = 0;
+	let runningSum = from(0, 18);
+	return (value) => {
+		const v = from(value, 18);
+		if (count < period) {
+			buffer[count] = v;
+			runningSum = add(runningSum, v);
+			count++;
+		} else {
+			runningSum = subtract(runningSum, buffer[head]);
+			runningSum = add(runningSum, v);
+			buffer[head] = v;
+			head = (head + 1) % period;
+		}
+		return div(runningSum, count, 18);
+	};
+}, defaultSMAOptions);
+
+//#endregion
+//#region src/momentum/awesomeOscillator.ts
+const defaultAwesomeOscillatorOptions = {
+	fastPeriod: 5,
+	slowPeriod: 34
+};
+/**
+* Awesome Oscillator (AO)
+*
+* AO = SMA(median, fastPeriod) - SMA(median, slowPeriod)
+* Where median = (high + low) / 2
+*/
+const ao = createSignal(({ fastPeriod, slowPeriod }) => {
+	assert(Number.isInteger(fastPeriod) && fastPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected fastPeriod to be a positive integer, got ${fastPeriod}`));
+	assert(Number.isInteger(slowPeriod) && slowPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected slowPeriod to be a positive integer, got ${slowPeriod}`));
+	const fastProc = sma.create({ period: fastPeriod });
+	const slowProc = sma.create({ period: slowPeriod });
+	return (bar) => {
+		const median = div(add(from(bar.h, 18), from(bar.l, 18)), 2, 18);
+		return sub(fastProc(median), slowProc(median));
+	};
+}, defaultAwesomeOscillatorOptions);
+
+//#endregion
+//#region src/volume/accumulationDistribution.ts
+/**
+* Accumulation/Distribution Indicator (A/D). Cumulative indicator
+* that uses volume and price to assess whether a stock is
+* being accumulated or distributed.
+*
+* MFM = ((Closing - Low) - (High - Closing)) / (High - Low)
+* MFV = MFM * Period Volume
+* AD = Previous AD + CMFV
+*/
+const ad = createSignal(() => {
+	let prevAD = from(0, 18);
+	return (bar) => {
+		const h = from(bar.h, 18);
+		const l = from(bar.l, 18);
+		const c = from(bar.c, 18);
+		const v = from(bar.v, 18);
+		const range = subtract(h, l);
+		prevAD = add(multiply(equal(range, 0) ? from(0, 18) : divide(subtract(subtract(c, l), subtract(h, c)), range, 18), v), prevAD);
+		return prevAD;
+	};
+});
+
+//#endregion
+//#region src/momentum/chaikinOscillator.ts
+const defaultChaikinOscillatorOptions = {
+	fastPeriod: 3,
+	slowPeriod: 10
+};
+/**
+* The ChaikinOscillator function measures the momentum of the
+* Accumulation/Distribution (A/D) using the Moving Average
+* Convergence Divergence (MACD) formula. It takes the
+* difference between fast and slow periods EMA of the A/D.
+* Cross above the A/D line indicates bullish.
+*
+* CO = Ema(fastPeriod, AD) - Ema(slowPeriod, AD)
+*/
+const cmo = createSignal(({ fastPeriod, slowPeriod }) => {
+	assert(Number.isInteger(fastPeriod) && fastPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected fastPeriod to be a positive integer, got ${fastPeriod}`));
+	assert(Number.isInteger(slowPeriod) && slowPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected slowPeriod to be a positive integer, got ${slowPeriod}`));
+	const adProc = ad.create();
+	const fastProc = ema.create({ period: fastPeriod });
+	const slowProc = ema.create({ period: slowPeriod });
+	return (bar) => {
+		const adVal = adProc(bar);
+		return sub(fastProc(adVal), slowProc(adVal));
+	};
+}, defaultChaikinOscillatorOptions);
+
+//#endregion
+//#region src/trend/movingMax.ts
+const defaultMovingMaxOptions = { period: 4 };
+/**
+* Moving Maximum (MovingMax)
+*/
+const mmax = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	const buffer = [];
+	return (value) => {
+		buffer.push(from(value, 18));
+		if (buffer.length > period) buffer.shift();
+		return buffer.reduce((max, cur) => gt(max, cur) ? max : cur);
+	};
+}, defaultMovingMaxOptions);
+
+//#endregion
+//#region src/trend/movingMin.ts
+const defaultMovingMinOptions = { period: 4 };
+/**
+* Moving Minimum (MovingMin)
+*/
+const mmin = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	const buffer = [];
+	return (value) => {
+		buffer.push(from(value, 18));
+		if (buffer.length > period) buffer.shift();
+		return buffer.reduce((min, cur) => lt(min, cur) ? min : cur);
+	};
+}, defaultMovingMinOptions);
+
+//#endregion
+//#region src/momentum/ichimokuCloud.ts
+const defaultIchimokuCloudOptions = {
+	conversionPeriod: 9,
+	basePeriod: 26,
+	leadingBPeriod: 52
+};
+/**
+* Ichimoku Cloud (Ichimoku Kinko Hyo)
+*
+* Computes raw values for each component. Displacement (shifting
+* Leading Spans forward and Lagging Span backward on the chart)
+* is a presentation concern left to the consumer.
+*
+* - Conversion (Tenkan-sen): (highest high + lowest low) / 2 over conversionPeriod
+* - Base (Kijun-sen): (highest high + lowest low) / 2 over basePeriod
+* - Leading Span A (Senkou A): (conversion + base) / 2
+* - Leading Span B (Senkou B): (highest high + lowest low) / 2 over leadingBPeriod
+* - Lagging (Chikou): current close price
+*/
+const ichimokuCloud = createSignal(({ conversionPeriod, basePeriod, leadingBPeriod }) => {
+	assert(Number.isInteger(conversionPeriod) && conversionPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected conversionPeriod to be a positive integer, got ${conversionPeriod}`));
+	assert(Number.isInteger(basePeriod) && basePeriod >= 1, /* @__PURE__ */ new RangeError(`Expected basePeriod to be a positive integer, got ${basePeriod}`));
+	assert(Number.isInteger(leadingBPeriod) && leadingBPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected leadingBPeriod to be a positive integer, got ${leadingBPeriod}`));
+	const convHighProc = mmax.create({ period: conversionPeriod });
+	const convLowProc = mmin.create({ period: conversionPeriod });
+	const baseHighProc = mmax.create({ period: basePeriod });
+	const baseLowProc = mmin.create({ period: basePeriod });
+	const leadBHighProc = mmax.create({ period: leadingBPeriod });
+	const leadBLowProc = mmin.create({ period: leadingBPeriod });
+	return (bar) => {
+		const h = from(bar.h, 18);
+		const l = from(bar.l, 18);
+		const conversion = div(add(convHighProc(h), convLowProc(l)), 2, 18);
+		const base = div(add(baseHighProc(h), baseLowProc(l)), 2, 18);
+		return {
+			conversion,
+			base,
+			leadingA: div(add(conversion, base), 2, 18),
+			leadingB: div(add(leadBHighProc(h), leadBLowProc(l)), 2, 18),
+			lagging: from(bar.c, 18)
+		};
+	};
+}, defaultIchimokuCloudOptions);
+
+//#endregion
+//#region src/momentum/percentagePriceOscillator.ts
+const defaultPercentagePriceOscillatorOptions = {
+	fastPeriod: 12,
+	slowPeriod: 26,
+	signalPeriod: 9
+};
+/**
+* Percentage Price Oscillator (PPO)
+*
+* The Percentage Price Oscillator (PPO) is a momentum oscillator that measures the difference
+* between two moving averages as a percentage of the slower moving average. It consists of three components:
+* - PPO Line: ((Fast EMA - Slow EMA) / Slow EMA) * 100
+* - Signal Line: EMA of the PPO line
+* - Histogram: PPO - Signal
+*
+* Formula:
+* - PPO = ((EMA(fastPeriod, prices) - EMA(slowPeriod, prices)) / EMA(slowPeriod, prices)) * 100
+* - Signal = EMA(signalPeriod, PPO)
+* - Histogram = PPO - Signal
+*
+* @param source - Iterable of price values
+* @param options - Configuration options
+* @param options.fastPeriod - Period for the fast EMA (default: 12)
+* @param options.slowPeriod - Period for the slow EMA (default: 26)
+* @param options.signalPeriod - Period for the signal EMA (default: 9)
+* @returns Generator yielding PPO point objects
+*/
+const ppo = createSignal(({ fastPeriod, slowPeriod, signalPeriod }) => {
+	assert(Number.isInteger(fastPeriod) && fastPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected fastPeriod to be a positive integer, got ${fastPeriod}`));
+	assert(Number.isInteger(slowPeriod) && slowPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected slowPeriod to be a positive integer, got ${slowPeriod}`));
+	assert(Number.isInteger(signalPeriod) && signalPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected signalPeriod to be a positive integer, got ${signalPeriod}`));
+	const fastProc = ema.create({ period: fastPeriod });
+	const slowProc = ema.create({ period: slowPeriod });
+	const signalProc = ema.create({ period: signalPeriod });
+	return (value) => {
+		const fast = fastProc(from(value, 18));
+		const slow = slowProc(from(value, 18));
+		const ppoVal = eq(slow, 0) ? from(0, 18) : mul(div(sub(fast, slow), slow, 18), 100, 18);
+		const sig = signalProc(ppoVal);
+		return {
+			ppo: ppoVal,
+			signal: sig,
+			histogram: sub(ppoVal, sig)
+		};
+	};
+}, defaultPercentagePriceOscillatorOptions);
+
+//#endregion
+//#region src/trend/rollingMovingAverage.ts
+const defaultRMAOptions = { period: 4 };
+/**
+* Rolling moving average (RMA).
+*
+* R[0] to R[p-1] is SMA(values)
+*
+* R[p] and after is R[i] = ((R[i-1]*(p-1)) + v[i]) / p
+*/
+const rma = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	let count = 0;
+	let sum = from(0, 18);
+	let prev = from(0, 18);
+	return (value) => {
+		if (count < period) {
+			sum = add(sum, value);
+			count++;
+			prev = div(sum, count, 18);
+			return prev;
+		}
+		prev = div(add(mul(prev, period - 1, 18), value), period, 18);
+		return prev;
+	};
+}, defaultRMAOptions);
+
+//#endregion
+//#region src/momentum/relativeStrengthIndex.ts
+const defaultRSIOptions = { period: 14 };
+/**
+* Relative Strength Index (RSI). It is a momentum indicator that measures the magnitude of
+* recent price changes to evaluate overbought and oversold conditions
+* using the given window period.
+*
+* RS = Average Gain / Average Loss
+*
+* RSI = 100 - (100 / (1 + RS))
+*/
+const rsi = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	const gainProc = rma.create({ period });
+	const lossProc = rma.create({ period });
+	let prev;
+	return (value) => {
+		const price = from(value, 18);
+		if (prev === void 0) {
+			prev = price;
+			gainProc(from(0, 18));
+			lossProc(from(0, 18));
+			return from(0, 18);
+		}
+		const change = sub(price, prev);
+		prev = price;
+		const gain = gt(change, 0) ? change : from(0, 18);
+		const loss = gt(change, 0) ? from(0, 18) : mul(change, -1, 18);
+		const avgGain = gainProc(gain);
+		const avgLoss = lossProc(loss);
+		if (eq(avgLoss, 0)) return from(100, 18);
+		return sub(100, div(100, add(1, div(avgGain, avgLoss, 18)), 18));
+	};
+}, defaultRSIOptions);
+
+//#endregion
+//#region src/momentum/stochasticOscillator.ts
+const defaultStochasticOscillatorOptions = {
+	kPeriod: 14,
+	slowingPeriod: 1,
+	dPeriod: 3
+};
+/**
+* Stochastic Oscillator
+*
+* %K = ((Close - Lowest Low) / (Highest High - Lowest Low)) * 100
+* %D = SMA(%K, dPeriod)
+*/
+const stoch = createSignal(({ kPeriod, slowingPeriod, dPeriod }) => {
+	assert(Number.isInteger(kPeriod) && kPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected kPeriod to be a positive integer, got ${kPeriod}`));
+	assert(Number.isInteger(slowingPeriod) && slowingPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected slowingPeriod to be a positive integer, got ${slowingPeriod}`));
+	assert(Number.isInteger(dPeriod) && dPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected dPeriod to be a positive integer, got ${dPeriod}`));
+	const mmaxProc = mmax.create({ period: kPeriod });
+	const mminProc = mmin.create({ period: kPeriod });
+	const slowingProc = slowingPeriod > 1 ? sma.create({ period: slowingPeriod }) : null;
+	const dProc = sma.create({ period: dPeriod });
+	return (bar) => {
+		const h = from(bar.h, 18);
+		const l = from(bar.l, 18);
+		const c = from(bar.c, 18);
+		const highestHigh = mmaxProc(h);
+		const lowestLow = mminProc(l);
+		const range = sub(highestHigh, lowestLow, 18);
+		const rawK = eq(range, 0) ? from(0, 18) : mul(div(sub(c, lowestLow, 18), range, 18), 100, 18);
+		const k = slowingProc ? slowingProc(rawK) : rawK;
+		return {
+			k,
+			d: dProc(k)
+		};
+	};
+}, defaultStochasticOscillatorOptions);
+
+//#endregion
+//#region src/trend/aroon.ts
+const defaultAroonOptions = { period: 25 };
+/**
+* Aroon Indicator
+*
+* Aroon Up = ((period - days since highest high) / period) * 100
+* Aroon Down = ((period - days since lowest low) / period) * 100
+* Oscillator = Aroon Up - Aroon Down
+*/
+const aroon = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	const highBuffer = [];
+	const lowBuffer = [];
+	return (bar) => {
+		const h = from(bar.h, 18);
+		const l = from(bar.l, 18);
+		highBuffer.push(h);
+		lowBuffer.push(l);
+		if (highBuffer.length > period + 1) highBuffer.shift();
+		if (lowBuffer.length > period + 1) lowBuffer.shift();
+		let highestIdx = 0;
+		let lowestIdx = 0;
+		for (let j = 1; j < highBuffer.length; j++) {
+			if (!gt(highBuffer[highestIdx], highBuffer[j])) highestIdx = j;
+			if (!lt(lowBuffer[lowestIdx], lowBuffer[j])) lowestIdx = j;
+		}
+		const daysSinceHigh = highBuffer.length - 1 - highestIdx;
+		const daysSinceLow = lowBuffer.length - 1 - lowestIdx;
+		const periodDnum = from(period, 18);
+		const up = divide(multiply(from(period - daysSinceHigh, 18), 100, 18), periodDnum, 18);
+		const down = divide(multiply(from(period - daysSinceLow, 18), 100, 18), periodDnum, 18);
+		return {
+			up,
+			down,
+			oscillator: subtract(up, down)
+		};
+	};
+}, defaultAroonOptions);
+
+//#endregion
+//#region src/trend/balanceOfPower.ts
+const bop = createSignal(() => {
+	return (bar) => {
+		const o = from(bar.o, 18);
+		const h = from(bar.h, 18);
+		const l = from(bar.l, 18);
+		const c = from(bar.c, 18);
+		const range = subtract(h, l);
+		if (equal(range, 0)) return from(0, 18);
+		return divide(subtract(c, o), range, 18);
+	};
+});
+
+//#endregion
+//#region src/trend/chandeForecastOscillator.ts
+const defaultCFOOptions = { period: 14 };
+/**
+* Chande Forecast Oscillator (CFO)
+*
+* Measures the percentage difference between the actual close price and the
+* n-period linear regression forecast price. Positive values indicate bullish
+* momentum (price above forecast), negative values indicate bearish momentum.
+*
+* Formula: CFO = ((Close - Forecast) / Close) * 100
+* Where: Forecast = Linear regression value at current point
+*
+* @param source - Iterable of price values
+* @param options - Configuration options
+* @param options.period - The period for linear regression (default: 14)
+* @returns Generator yielding CFO values as percentages
+*/
+const cfo = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	const buffer = [];
+	return (value) => {
+		buffer.push(from(value, 18));
+		if (buffer.length > period) buffer.shift();
+		const n = buffer.length;
+		if (n < 2) return from(0, 18);
+		const xSum = n * (n + 1) / 2;
+		const denom = n * (n * (n + 1) * (2 * n + 1) / 6) - xSum * xSum;
+		let sumY = from(0, 18);
+		let sumXY = from(0, 18);
+		for (let i = 0; i < n; i++) {
+			sumY = add(sumY, buffer[i]);
+			sumXY = add(sumXY, multiply(buffer[i], i + 1));
+		}
+		const slope = divide(subtract(multiply(sumXY, n), multiply(sumY, xSum)), denom, 18);
+		const intercept = divide(subtract(sumY, multiply(slope, xSum)), n, 18);
+		const forecast = add(multiply(slope, n), intercept);
+		const close = buffer[n - 1];
+		if (equal(close, 0)) return from(0, 18);
+		return divide(multiply(subtract(close, forecast), 100), close, 18);
+	};
+}, defaultCFOOptions);
+
+//#endregion
+//#region src/trend/commodityChannelIndex.ts
+const defaultCCIOptions = { period: 20 };
+/**
+* Commodity Channel Index (CCI)
+*
+* Developed by Donald Lambert in 1980, CCI measures the deviation of the
+* typical price from its simple moving average, normalized by mean deviation.
+* The constant 0.015 ensures approximately 70-80% of CCI values fall between
+* +100 and -100.
+*
+* Formula:
+*   TP = (High + Low + Close) / 3
+*   CCI = (TP - SMA(TP, period)) / (0.015 * Mean Deviation)
+*   Mean Deviation = SUM(|TP_i - SMA|) / period
+*
+* @param source - Iterable of OHLC candle data
+* @param options - Configuration options
+* @param options.period - The period for CCI calculation (default: 20)
+* @returns Generator yielding CCI values
+*/
+const cci = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	const buffer = [];
+	return (bar) => {
+		const h = from(bar.h, 18);
+		const l = from(bar.l, 18);
+		const c = from(bar.c, 18);
+		const tp = divide(add(add(h, l), c), 3, 18);
+		buffer.push(tp);
+		if (buffer.length > period) buffer.shift();
+		const n = buffer.length;
+		if (n < period) return from(0, 18);
+		let sum = from(0, 18);
+		for (const v of buffer) sum = add(sum, v);
+		const smaVal = divide(sum, n, 18);
+		let devSum = from(0, 18);
+		for (const v of buffer) devSum = add(devSum, abs(subtract(v, smaVal)));
+		const meanDev = divide(devSum, n, 18);
+		if (equal(meanDev, 0)) return from(0, 18);
+		const currentTP = buffer[n - 1];
+		return divide(subtract(currentTP, smaVal), divide([meanDev[0] * 15n, meanDev[1]], [1000n, 0], 18), 18);
+	};
+}, defaultCCIOptions);
+
+//#endregion
+//#region src/trend/doubleExponentialMovingAverage.ts
+const defaultDoubleExponentialMovingAverageOptions = { period: 12 };
+/**
+* Double Exponential Moving Average (DEMA)
+*
+* DEMA reduces lag compared to a traditional EMA by applying the formula:
+* DEMA = 2 * EMA(data, period) - EMA(EMA(data, period), period)
+*
+* @param source - Iterable of input values
+* @param options - Configuration options
+* @param options.period - The lookback period (default: 12)
+* @returns Generator yielding DEMA values
+*/
+const dema = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	const ema1 = ema.create({ period });
+	const ema2 = ema.create({ period });
+	return (value) => {
+		const e1 = ema1(value);
+		const e2 = ema2(e1);
+		return sub(mul(e1, 2, 18), e2);
+	};
+}, defaultDoubleExponentialMovingAverageOptions);
+
+//#endregion
+//#region src/trend/macd.ts
+const defaultMACDOptions = {
+	fastPeriod: 12,
+	slowPeriod: 26,
+	signalPeriod: 9
+};
+/**
+* Moving Average Convergence Divergence (MACD)
+*
+* MACD is a trend-following momentum indicator that shows the relationship
+* between two exponential moving averages of prices. It consists of three components:
+* - MACD Line: Fast EMA - Slow EMA
+* - Signal Line: EMA of the MACD line
+* - Histogram: MACD - Signal
+*
+* Formula:
+* - MACD = EMA(fastPeriod, prices) - EMA(slowPeriod, prices)
+* - Signal = EMA(signalPeriod, MACD)
+* - Histogram = MACD - Signal
+*
+* @param source - Iterable of price values
+* @param options - Configuration options
+* @param options.fastPeriod - Period for the fast EMA (default: 12)
+* @param options.slowPeriod - Period for the slow EMA (default: 26)
+* @param options.signalPeriod - Period for the signal EMA (default: 9)
+* @returns Generator yielding MACDPoint objects
+*/
+const macd = createSignal(({ fastPeriod, slowPeriod, signalPeriod }) => {
+	assert(Number.isInteger(fastPeriod) && fastPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected fastPeriod to be a positive integer, got ${fastPeriod}`));
+	assert(Number.isInteger(slowPeriod) && slowPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected slowPeriod to be a positive integer, got ${slowPeriod}`));
+	assert(Number.isInteger(signalPeriod) && signalPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected signalPeriod to be a positive integer, got ${signalPeriod}`));
+	const fastProc = ema.create({ period: fastPeriod });
+	const slowProc = ema.create({ period: slowPeriod });
+	const signalProc = ema.create({ period: signalPeriod });
+	return (value) => {
+		const m = sub(fastProc(value), slowProc(value));
+		const sig = signalProc(m);
+		return {
+			macd: m,
+			signal: sig,
+			histogram: sub(m, sig)
+		};
+	};
+}, defaultMACDOptions);
+
+//#endregion
+//#region src/trend/movingSum.ts
+const defaultMovingSumOptions = { period: 4 };
+/**
+* Moving Sum
+*
+* Calculates the sum of values in a sliding window of the specified period.
+*/
+const msum = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	const buffer = Array.from({ length: period });
+	let head = 0;
+	let count = 0;
+	let runningSum = from(0, 18);
+	return (value) => {
+		const v = from(value, 18);
+		if (count < period) {
+			buffer[count] = v;
+			runningSum = add(runningSum, v);
+			count++;
+		} else {
+			runningSum = subtract(runningSum, buffer[head]);
+			runningSum = add(runningSum, v);
+			buffer[head] = v;
+			head = (head + 1) % period;
+		}
+		return runningSum;
+	};
+}, defaultMovingSumOptions);
+
+//#endregion
+//#region src/trend/massIndex.ts
+const defaultMassIndexOptions = {
+	emaPeriod: 9,
+	miPeriod: 25
+};
+/**
+* Mass Index (MI)
+*
+* Developed by Donald Dorsey, the Mass Index uses the high-low range
+* to identify trend reversals based on range expansions. A "reversal bulge"
+* occurs when the Mass Index rises above 27 and then falls below 26.5.
+*
+* Formula:
+*   Range = High - Low
+*   EMA1 = EMA(Range, emaPeriod)
+*   EMA2 = EMA(EMA1, emaPeriod)
+*   Ratio = EMA1 / EMA2
+*   MI = MovingSum(Ratio, miPeriod)
+*
+* @param source - Iterable of OHLC candle data (requires high and low)
+* @param options - Configuration options
+* @param options.emaPeriod - The EMA smoothing period (default: 9)
+* @param options.miPeriod - The moving sum period (default: 25)
+* @returns Generator yielding Mass Index values
+*/
+const mi = createSignal(({ emaPeriod, miPeriod }) => {
+	assert(Number.isInteger(emaPeriod) && emaPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected emaPeriod to be a positive integer, got ${emaPeriod}`));
+	assert(Number.isInteger(miPeriod) && miPeriod >= 1, /* @__PURE__ */ new RangeError(`Expected miPeriod to be a positive integer, got ${miPeriod}`));
+	const ema1Proc = ema.create({ period: emaPeriod });
+	const ema2Proc = ema.create({ period: emaPeriod });
+	const msumProc = msum.create({ period: miPeriod });
+	return (bar) => {
+		const e1 = ema1Proc(subtract(from(bar.h, 18), from(bar.l, 18)));
+		return msumProc(divide(e1, ema2Proc(e1), 18));
+	};
+}, defaultMassIndexOptions);
+
+//#endregion
+//#region src/trend/triangularMovingAverage.ts
+const defaultTriangularMovingAverageOptions = { period: 4 };
+const trima = createSignal(({ period }) => {
+	assert(Number.isInteger(period) && period >= 1, /* @__PURE__ */ new RangeError(`Expected period to be a positive integer, got ${period}`));
+	let n1;
+	let n2;
+	if (period % 2 === 0) {
+		n1 = period / 2;
+		n2 = n1 + 1;
+	} else {
+		n1 = (period + 1) / 2;
+		n2 = n1;
+	}
+	const sma1 = sma.create({ period: n2 });
+	const sma2 = sma.create({ period: n1 });
+	return (value) => {
+		return sma2(sma1(value));
+	};
+}, defaultTriangularMovingAverageOptions);
+
+//#endregion
+export { apo as absolutePriceOscillator, apo, ad as accumulationDistribution, ad, ao, ao as awesomeOscillator, aroon, bop as balanceOfPower, bop, cci, cci as commodityChannelIndex, cfo, cfo as chandeForecastOscillator, cmo as chaikinOscillator, cmo, defaultAbsolutePriceOscillatorOptions, defaultAroonOptions, defaultAwesomeOscillatorOptions, defaultCCIOptions, defaultCFOOptions, defaultChaikinOscillatorOptions, defaultDoubleExponentialMovingAverageOptions, defaultExponentialMovingAverageOptions, defaultIchimokuCloudOptions, defaultMACDOptions, defaultMassIndexOptions, defaultMovingMaxOptions, defaultMovingMinOptions, defaultMovingSumOptions, defaultPercentagePriceOscillatorOptions, defaultRMAOptions, defaultRSIOptions, defaultSMAOptions, defaultStochasticOscillatorOptions, defaultTriangularMovingAverageOptions, dema, dema as doubleExponentialMovingAverage, ema, ema as exponentialMovingAverage, ichimokuCloud, macd, macd as movingAverageConvergenceDivergence, mi as massIndex, mi, mmax, mmax as movingMax, mmin, mmin as movingMin, msum, ppo as percentagePriceOscillator, ppo, rsi as relativeStrengthIndex, rsi, rma, rma as rollingMovingAverage, sma as simpleMovingAverage, sma, stoch, stoch as stochasticOscillator, trima as triangularMovingAverage, trima };
+//# sourceMappingURL=index.js.map