openalgo-script 0.1.0-alpha.1 → 0.2.0

package/src/core/stdlib/series/totals.ts

@@ -0,0 +1,164 @@
+/**
+ * Totals and counts over a lookback, and the three functions that deliberately
+ * ignore absent bars.
+ *
+ * `sum` propagates absence, as every lookback function does. `sumSkip`,
+ * `avgSkip` and `countPresent` do not, and they say so in their names because
+ * a function that quietly ignored a gap would report a total over a lookback it
+ * never had.
+ */
+import type { Flag, Flags, Series, StateRecord, Tail, Value } from '../values/index.js';
+import { NONE, fold, isPresent, result, ring, slot, tailOf } from '../values/index.js';
+
+/** `sum(src, len)`: the total over the lookback, from bar `len - 1`. */
+export function sumStep(
+  state: StateRecord,
+  key: string,
+  value: Value,
+  len: number | null,
+): Value {
+  const lookback = ring(state, key, len);
+  lookback.push(value);
+  return lookback.sum();
+}
+
+/** `sum(src, len)` as a tail. */
+export function sumTail(len: number): Tail<Value, Value> {
+  return tailOf((state, value: Value) => sumStep(state, 'q', value, len));
+}
+
+/** `sum(src, len)` over a whole series. */
+export function sum(src: Series, len: number): Value[] {
+  return fold(sumTail(len), src);
+}
+
+/**
+ * `cum(src)`: the running total from the first bar, from bar 0.
+ *
+ * An absent bar produces an absent bar out and leaves the total where it was.
+ * The alternatives are both wrong: treating absence as zero would report a
+ * total over bars that had no value, and propagating it into the total would
+ * end the series permanently at the first gap.
+ */
+export function cumStep(state: StateRecord, key: string, value: Value): Value {
+  if (!isPresent(value)) return NONE;
+  const total = slot(state, key, 0) + value;
+  state[key] = total;
+  return result(total);
+}
+
+/** `cum(src)` as a tail. */
+export function cumTail(): Tail<Value, Value> {
+  return tailOf((state, value: Value) => cumStep(state, 't', value));
+}
+
+/** `cum(src)` over a whole series. */
+export function cum(src: Series): Value[] {
+  return fold(cumTail(), src);
+}
+
+/**
+ * `count(cond, len)`: how many of the last `len` bars the condition held on,
+ * from bar `len - 1`.
+ *
+ * An absent condition is a condition that did not hold, matching the rule that
+ * absence is false at a branch (`language.md` section 6). Propagating it
+ * instead would make a count over a condition built from an average absent for
+ * a second warmup on top of the average's own.
+ */
+export function countStep(
+  state: StateRecord,
+  key: string,
+  cond: Flag,
+  len: number | null,
+): Value {
+  const lookback = ring(state, key, len);
+  lookback.push(cond === true ? 1 : 0);
+  return lookback.sum();
+}
+
+/** `count(cond, len)` as a tail. */
+export function countTail(len: number): Tail<Flag, Value> {
+  return tailOf((state, cond: Flag) => countStep(state, 'q', cond, len));
+}
+
+/** `count(cond, len)` over a whole series. */
+export function count(cond: Flags, len: number): Value[] {
+  return fold(countTail(len), cond);
+}
+
+/** `sumSkip(src, len)`: the total over the lookback, ignoring absent bars. */
+export function sumSkipStep(
+  state: StateRecord,
+  key: string,
+  value: Value,
+  len: number | null,
+): Value {
+  const lookback = ring(state, key, len);
+  lookback.push(value);
+  return lookback.sumPresent();
+}
+
+/** `sumSkip(src, len)` as a tail. */
+export function sumSkipTail(len: number): Tail<Value, Value> {
+  return tailOf((state, value: Value) => sumSkipStep(state, 'q', value, len));
+}
+
+/** `sumSkip(src, len)` over a whole series. */
+export function sumSkip(src: Series, len: number): Value[] {
+  return fold(sumSkipTail(len), src);
+}
+
+/** `countPresent(src, len)`: how many bars of the lookback had a value. */
+export function countPresentStep(
+  state: StateRecord,
+  key: string,
+  value: Value,
+  len: number | null,
+): Value {
+  const lookback = ring(state, key, len);
+  lookback.push(value);
+  return lookback.filled() ? lookback.presentCount() : NONE;
+}
+
+/** `countPresent(src, len)` as a tail. */
+export function countPresentTail(len: number): Tail<Value, Value> {
+  return tailOf((state, value: Value) => countPresentStep(state, 'q', value, len));
+}
+
+/** `countPresent(src, len)` over a whole series. */
+export function countPresent(src: Series, len: number): Value[] {
+  return fold(countPresentTail(len), src);
+}
+
+/**
+ * `avgSkip(src, len)`: the mean over the lookback, ignoring absent bars.
+ *
+ * A lookback with nothing present in it is absent, not zero: there is no mean of
+ * no values, and a division by zero is absence by the rule of `stdlib.md`
+ * section 2.4.
+ */
+export function avgSkipStep(
+  state: StateRecord,
+  key: string,
+  value: Value,
+  len: number | null,
+): Value {
+  const lookback = ring(state, key, len);
+  lookback.push(value);
+  if (!lookback.filled()) return NONE;
+  const counted = lookback.presentCount();
+  const total = lookback.sumPresent();
+  if (counted === 0 || !isPresent(total)) return NONE;
+  return result(total / counted);
+}
+
+/** `avgSkip(src, len)` as a tail. */
+export function avgSkipTail(len: number): Tail<Value, Value> {
+  return tailOf((state, value: Value) => avgSkipStep(state, 'q', value, len));
+}
+
+/** `avgSkip(src, len)` over a whole series. */
+export function avgSkip(src: Series, len: number): Value[] {
+  return fold(avgSkipTail(len), src);
+}

package/src/core/stdlib/trend/directional.ts

@@ -0,0 +1,196 @@
+/**
+ * `adx(diLen, adxLen)`, `aroon(len)` and `ichimoku(convLen, baseLen, spanLen)`:
+ * how strong the trend is, which side owns it, and the five line frame.
+ *
+ * Each is written once, as a step over a state region, and its tail is that
+ * step over a region of its own. An engine calls the same step against the
+ * region it holds for the call site, so there is no second arrangement of the
+ * arithmetic anywhere for the two to drift apart in.
+ */
+import type { Bar, StateRecord, Tail, Value } from '../values/index.js';
+import { NONE, fold, held, isPresent, result, ring, tailOf } from '../values/index.js';
+import { rmaStep } from '../averages/index.js';
+import { extremeStep } from '../series/index.js';
+import type { Gap } from '../volatility/index.js';
+import { gapOf, trueRangeOf } from '../volatility/index.js';
+
+/**
+ * `adx(diLen, adxLen)`: `[adx, plusDI, minusDI]`, elements 1 and 2 from bar
+ * `diLen` and element 0 from bar `diLen + adxLen - 1`.
+ *
+ * Directional movement is the part of this bar's range that lies outside the
+ * previous bar's, on whichever side is larger. It needs the bar before it, so
+ * the smoothing's lookback is bars 1 to `diLen` and the first reading is at bar
+ * `diLen`. The true range in the denominator uses the gap-aware form for the
+ * same reason, so all three smoothed quantities cover the same bars: seeding
+ * one of them a bar earlier than the other two would bias every reading after
+ * it while still looking entirely plausible.
+ *
+ * The previous bar's two extremes are held in the region, because they are the
+ * arithmetic's own history. The previous close is not: it arrives with the gap,
+ * for the reason `range.ts` sets out.
+ */
+export function adxStep(
+  state: StateRecord,
+  key: string,
+  gap: Gap,
+  diLen: number | null,
+  adxLen: number | null,
+): Value[] {
+  const highKey = `${key}h`;
+  const lowKey = `${key}l`;
+  const seenKey = `${key}k`;
+  const beforeHigh = held(state, highKey);
+  const beforeLow = held(state, lowKey);
+  const started = state[seenKey] === true;
+  state[seenKey] = true;
+  state[highKey] = gap.high;
+  state[lowKey] = gap.low;
+
+  let upMove: Value = NONE;
+  let downMove: Value = NONE;
+  if (
+    started &&
+    isPresent(gap.high) &&
+    isPresent(gap.low) &&
+    isPresent(beforeHigh) &&
+    isPresent(beforeLow)
+  ) {
+    const up = gap.high - beforeHigh;
+    const down = beforeLow - gap.low;
+    upMove = up > down && up > 0 ? result(up) : 0;
+    downMove = down > up && down > 0 ? result(down) : 0;
+  }
+
+  const trueRange = rmaStep(state, `${key}r`, trueRangeOf(gap, false), diLen);
+  const rise = rmaStep(state, `${key}u`, upMove, diLen);
+  const fall = rmaStep(state, `${key}d`, downMove, diLen);
+
+  let plus: Value = NONE;
+  let minus: Value = NONE;
+  if (isPresent(trueRange) && trueRange !== 0) {
+    if (isPresent(rise)) plus = result((rise / trueRange) * 100);
+    if (isPresent(fall)) minus = result((fall / trueRange) * 100);
+  }
+
+  let spread: Value = NONE;
+  if (isPresent(plus) && isPresent(minus)) {
+    const total = plus + minus;
+    spread = total > 0 ? result((Math.abs(plus - minus) / total) * 100) : 0;
+  }
+
+  return [rmaStep(state, `${key}x`, spread, adxLen), plus, minus];
+}
+
+/** `adx(diLen, adxLen)` as a tail. */
+export function adxTail(diLen = 14, adxLen = 14): Tail<Bar, Value[]> {
+  return tailOf((state, bar: Bar) => adxStep(state, '', gapOf(state, 'g', bar), diLen, adxLen));
+}
+
+/** `adx(diLen, adxLen)` over a run of bars. */
+export function adx(bars: readonly Bar[], diLen = 14, adxLen = 14): Value[][] {
+  return fold(adxTail(diLen, adxLen), bars);
+}
+
+/**
+ * `aroon(len)`: `[up, down]`, both from bar `len`.
+ *
+ * How recently the lookback's high and low were set, as a percentage: 100 when it
+ * was this bar, 0 when it was `len` bars ago. The lookback is `len + 1` bars
+ * wide, because a reading of 0 has to be reachable and an extreme `len` bars
+ * back has to still be inside the lookback for that. That extra bar is where the
+ * declared warmup of bar `len` rather than bar `len - 1` comes from.
+ */
+export function aroonStep(
+  state: StateRecord,
+  key: string,
+  high: Value,
+  low: Value,
+  len: number | null,
+): Value[] {
+  const wide = len === null ? null : len + 1;
+  const highAge = extremeStep(state, `${key}h`, high, wide, true, true);
+  const lowAge = extremeStep(state, `${key}l`, low, wide, false, true);
+  if (len === null) return [NONE, NONE];
+  const up = isPresent(highAge) ? result((100 * (len - highAge)) / len) : NONE;
+  const down = isPresent(lowAge) ? result((100 * (len - lowAge)) / len) : NONE;
+  return [up, down];
+}
+
+/** `aroon(len)` as a tail. */
+export function aroonTail(len = 14): Tail<Bar, Value[]> {
+  return tailOf((state, bar: Bar) => aroonStep(state, '', bar.high, bar.low, len));
+}
+
+/** `aroon(len)` over a run of bars. */
+export function aroon(bars: readonly Bar[], len = 14): Value[][] {
+  return fold(aroonTail(len), bars);
+}
+
+/**
+ * `ichimoku(convLen, baseLen, spanLen)`: `[conversion, base, spanA, spanB,
+ * lagging]`, at bars `convLen - 1`, `baseLen - 1`, `baseLen - 1`,
+ * `spanLen - 1` and `baseLen - 1`.
+ *
+ * Each of the first four lines is the midpoint of a lookback's outright high and
+ * low, over a different length. **The spans are returned undisplaced, at the
+ * bar they are computed on**, per `stdlib.md` section 4: a study draws them
+ * forward with the plot's `offset` argument, because a series that has already
+ * been shifted cannot be compared with anything else in the script without
+ * shifting it back.
+ *
+ * The lagging line is this bar's close, and it is drawn backward by the same
+ * plot argument. It is absent until bar `baseLen - 1`, which is the warmup the
+ * specification declares for it, and which is the first bar there is enough
+ * history for the displacement to land on.
+ */
+export function ichimokuStep(
+  state: StateRecord,
+  key: string,
+  bar: Bar,
+  convLen: number | null,
+  baseLen: number | null,
+  spanLen: number | null,
+): Value[] {
+  const near = midpointStep(state, `${key}c`, bar, convLen);
+  const middle = midpointStep(state, `${key}b`, bar, baseLen);
+  const leading = isPresent(near) && isPresent(middle) ? result((near + middle) / 2) : NONE;
+  const behind = midpointStep(state, `${key}s`, bar, spanLen);
+  const closes = ring(state, `${key}g`, baseLen);
+  closes.push(bar.close);
+  const lagging = closes.filled() ? closes.at(0) : NONE;
+  return [near, middle, leading, behind, lagging];
+}
+
+/** `ichimoku(convLen, baseLen, spanLen)` as a tail. */
+export function ichimokuTail(convLen = 9, baseLen = 26, spanLen = 52): Tail<Bar, Value[]> {
+  return tailOf((state, bar: Bar) => ichimokuStep(state, '', bar, convLen, baseLen, spanLen));
+}
+
+/** `ichimoku(convLen, baseLen, spanLen)` over a run of bars. */
+export function ichimoku(
+  bars: readonly Bar[],
+  convLen = 9,
+  baseLen = 26,
+  spanLen = 52,
+): Value[][] {
+  return fold(ichimokuTail(convLen, baseLen, spanLen), bars);
+}
+
+/** The midpoint of a lookback's outright high and low. */
+function midpointStep(state: StateRecord, key: string, bar: Bar, len: number | null): Value {
+  const highs = ring(state, `${key}h`, len);
+  const lows = ring(state, `${key}l`, len);
+  highs.push(bar.high);
+  lows.push(bar.low);
+  if (len === null || !highs.complete() || !lows.complete()) return NONE;
+  let top = highs.at(len - 1) as number;
+  let bottom = lows.at(len - 1) as number;
+  for (let back = len - 2; back >= 0; back -= 1) {
+    const high = highs.at(back) as number;
+    const low = lows.at(back) as number;
+    if (high > top) top = high;
+    if (low < bottom) bottom = low;
+  }
+  return result((top + bottom) / 2);
+}

package/src/core/stdlib/trend/index.ts

@@ -0,0 +1,13 @@
+export { supertrend, supertrendStep, supertrendTail } from './supertrend.js';
+export { psar, psarStep, psarTail } from './psar.js';
+export {
+  adx,
+  adxStep,
+  adxTail,
+  aroon,
+  aroonStep,
+  aroonTail,
+  ichimoku,
+  ichimokuStep,
+  ichimokuTail,
+} from './directional.js';

package/src/core/stdlib/trend/psar.ts

@@ -0,0 +1,131 @@
+/**
+ * `psar(start, step, max)`: `[sar, direction]`, both from bar 1.
+ *
+ * A stop that accelerates toward price. It sits below price in an uptrend and
+ * above it in a downtrend, moves a fraction of the way to the extreme reached
+ * so far on every bar, and that fraction grows each time a new extreme is set,
+ * up to a ceiling. When price reaches the stop the trend flips and the stop
+ * restarts at the extreme the old trend had reached.
+ *
+ * Seeded from bar 0's range, per `stdlib.md` section 4: the direction at bar 1
+ * is taken from whether that bar closed above bar 0, and the stop starts at bar
+ * 0's low in an uptrend or its high in a downtrend.
+ *
+ * `direction` is -1 long and 1 short, the same convention `supertrend` uses.
+ *
+ * **What this does not include**, said plainly rather than left to be
+ * discovered: the clamp some published versions apply, which forbids the stop
+ * from entering the previous two bars' range. `stdlib.md` section 20.3 fixes
+ * its absence, so a stop drawn with the clamp is a different function rather
+ * than a different arrangement of this one.
+ *
+ * Everything the algorithm carries between bars is a number or a flag in a
+ * state region, which is what lets an engine advance one bar at a time over the
+ * same step this file's tail folds over a run.
+ */
+import type { Bar, StateRecord, Tail, Value } from '../values/index.js';
+import { NONE, flag, fold, held, isPresent, result, slot, tailOf } from '../values/index.js';
+
+/** `psar(start, step, max)`. */
+export function psarStep(
+  state: StateRecord,
+  key: string,
+  bar: Bar,
+  start: number | null,
+  step: number | null,
+  ceiling: number | null,
+): Value[] {
+  const seenKey = `${key}k`;
+  const beforeHigh = held(state, `${key}h`);
+  const beforeLow = held(state, `${key}l`);
+  const beforeClose = held(state, `${key}c`);
+  const started = state[seenKey] === true;
+  state[seenKey] = true;
+  state[`${key}h`] = bar.high;
+  state[`${key}l`] = bar.low;
+  state[`${key}c`] = bar.close;
+
+  if (start === null || step === null || ceiling === null) return [NONE, NONE];
+  if (!isPresent(bar.high) || !isPresent(bar.low) || !isPresent(bar.close)) {
+    return [NONE, NONE];
+  }
+
+  const seededKey = `${key}s`;
+  const longKey = `${key}g`;
+  const extremeKey = `${key}e`;
+  const stopKey = `${key}p`;
+  const rateKey = `${key}a`;
+
+  // Seeding waits for a pair of complete bars rather than for bar 1 by
+  // number. On clean data that is bar 1, which is the declared warmup; on
+  // data with a hole at the start it is the first bar the seed can honestly
+  // be taken from, rather than a stop placed at whatever the state happened
+  // to hold.
+  if (!flag(state, seededKey)) {
+    if (!started) return [NONE, NONE];
+    if (!isPresent(beforeHigh) || !isPresent(beforeLow) || !isPresent(beforeClose)) {
+      return [NONE, NONE];
+    }
+    const up = bar.close > beforeClose;
+    const seed = up ? beforeLow : beforeHigh;
+    state[longKey] = up;
+    state[extremeKey] = up ? bar.high : bar.low;
+    state[stopKey] = seed;
+    state[rateKey] = start;
+    state[seededKey] = true;
+    return [result(seed), up ? -1 : 1];
+  }
+
+  let long = flag(state, longKey);
+  let extreme = slot(state, extremeKey, 0);
+  let acceleration = slot(state, rateKey, start);
+  let stop = slot(state, stopKey, 0);
+
+  stop = stop + acceleration * (extreme - stop);
+
+  if (long) {
+    if (stop > bar.low) {
+      long = false;
+      stop = extreme;
+      extreme = bar.low;
+      acceleration = start;
+    }
+  } else if (stop < bar.high) {
+    long = true;
+    stop = extreme;
+    extreme = bar.high;
+    acceleration = start;
+  }
+
+  if (long) {
+    if (bar.high > extreme) {
+      extreme = bar.high;
+      acceleration = Math.min(acceleration + step, ceiling);
+    }
+  } else if (bar.low < extreme) {
+    extreme = bar.low;
+    acceleration = Math.min(acceleration + step, ceiling);
+  }
+
+  state[longKey] = long;
+  state[extremeKey] = extreme;
+  state[stopKey] = stop;
+  state[rateKey] = acceleration;
+
+  return [result(stop), long ? -1 : 1];
+}
+
+/** `psar(start, step, max)` as a tail. */
+export function psarTail(start = 0.02, step = 0.02, ceiling = 0.2): Tail<Bar, Value[]> {
+  return tailOf((state, bar: Bar) => psarStep(state, '', bar, start, step, ceiling));
+}
+
+/** `psar(start, step, max)` over a run of bars. */
+export function psar(
+  bars: readonly Bar[],
+  start = 0.02,
+  step = 0.02,
+  ceiling = 0.2,
+): Value[][] {
+  return fold(psarTail(start, step, ceiling), bars);
+}

package/src/core/stdlib/trend/supertrend.ts

@@ -0,0 +1,100 @@
+/**
+ * `supertrend(factor, atrLen)`: `[line, direction]`, both from bar `atrLen`.
+ *
+ * A trailing band built from average true range, which ratchets in the
+ * direction of the trend and never gives ground: the upper band may only fall
+ * while price stays below it, the lower band may only rise while price stays
+ * above it, and the line flips to the other band when price closes through the
+ * one it was following.
+ *
+ * **The first value is at bar `atrLen`, one bar after `atr` has one.** The band
+ * carry-forward and the flip test both read the previous bar's close and the
+ * previous bar's bands, and on the bar average true range first exists there is
+ * no previous bar of either. That bar seeds the state and reports nothing,
+ * which is what `stdlib.md` section 4 declares. An implementation that reported
+ * it would be reporting a direction chosen by its own seeding rule rather than
+ * by the data.
+ *
+ * `direction` is -1 long and 1 short, the sign of the side the band is
+ * protecting against, and it is a number rather than a bool so that
+ * `direction != direction[1]` reads as the flip test.
+ */
+import type { Bar, StateRecord, Tail, Value } from '../values/index.js';
+import { NONE, flag, fold, hl2, isPresent, result, slot, tailOf } from '../values/index.js';
+import type { Gap } from '../volatility/index.js';
+import { atrStep, gapOf } from '../volatility/index.js';
+
+/** `supertrend(factor, atrLen)`. */
+export function supertrendStep(
+  state: StateRecord,
+  key: string,
+  gap: Gap,
+  close: Value,
+  factor: number | null,
+  atrLen: number | null,
+): Value[] {
+  const width = atrStep(state, key, gap, atrLen);
+  const midpoint = hl2(gap);
+  if (!isPresent(width) || !isPresent(midpoint) || !isPresent(close) || factor === null) {
+    return [NONE, NONE];
+  }
+
+  const rawUpper = midpoint + factor * width;
+  const rawLower = midpoint - factor * width;
+  const seeded = flag(state, `${key}k`);
+  const previousUpper = slot(state, `${key}pu`, 0);
+  const previousLower = slot(state, `${key}pl`, 0);
+  const previousClose = slot(state, `${key}pc`, 0);
+  let followingUpper = state[`${key}fu`] !== false;
+
+  // The band holds where it is unless price broke it or it moved inward.
+  const upper = !seeded
+    ? rawUpper
+    : rawUpper < previousUpper || previousClose > previousUpper
+      ? rawUpper
+      : previousUpper;
+  const lower = !seeded
+    ? rawLower
+    : rawLower > previousLower || previousClose < previousLower
+      ? rawLower
+      : previousLower;
+
+  let line: number;
+  if (!seeded || followingUpper) {
+    if (close <= upper) {
+      line = upper;
+      followingUpper = true;
+    } else {
+      line = lower;
+      followingUpper = false;
+    }
+  } else if (close >= lower) {
+    line = lower;
+    followingUpper = false;
+  } else {
+    line = upper;
+    followingUpper = true;
+  }
+
+  const first = !seeded;
+  state[`${key}k`] = true;
+  state[`${key}pu`] = upper;
+  state[`${key}pl`] = lower;
+  state[`${key}pc`] = close;
+  state[`${key}fu`] = followingUpper;
+
+  if (first) return [NONE, NONE];
+  return [result(line), followingUpper ? 1 : -1];
+}
+
+/** `supertrend(factor, atrLen)` as a tail. */
+export function supertrendTail(factor = 3, atrLen = 10): Tail<Bar, Value[]> {
+  return tailOf((state, bar: Bar) =>
+    supertrendStep(state, '', gapOf(state, 'g', bar), bar.close, factor, atrLen),
+  );
+}
+
+/** `supertrend(factor, atrLen)` over a run of bars. */
+export function supertrend(bars: readonly Bar[], factor = 3, atrLen = 10): Value[][] {
+  return fold(supertrendTail(factor, atrLen), bars);
+}

package/src/core/stdlib/values/bar.ts

@@ -0,0 +1,54 @@
+/**
+ * A bar, and the derived prices a study reaches for by name.
+ *
+ * The functions `stdlib.md` writes without a source argument, `atr(len)` and
+ * `cci(len)` among them, read the bar rather than a series. This library is
+ * pure, so it takes the bar explicitly and an engine binds it; the function
+ * names and the arithmetic are the specification's, the plumbing is not.
+ *
+ * `volume` is absent, not zero, on an instrument the host has no volume for
+ * (`stdlib.md` section 3.1). Zero is a real reading meaning nobody traded, and
+ * conflating the two would make a volume study draw a flat line where it should
+ * draw nothing.
+ */
+import type { Value } from './value.js';
+import { NONE, isPresent, result } from './value.js';
+
+/** One bar of price and quantity. */
+export interface Bar {
+  readonly open: Value;
+  readonly high: Value;
+  readonly low: Value;
+  readonly close: Value;
+  readonly volume: Value;
+}
+
+/**
+ * `(high + low) / 2`, the bar's midpoint.
+ *
+ * It takes the two extremes rather than the whole bar, because the studies
+ * built on a range hold those two and the close before them rather than a bar.
+ */
+export function hl2(bar: { readonly high: Value; readonly low: Value }): Value {
+  if (!isPresent(bar.high) || !isPresent(bar.low)) return NONE;
+  return result((bar.high + bar.low) / 2);
+}
+
+/** `(high + low + close) / 3`, the typical price. */
+export function hlc3(bar: Bar): Value {
+  if (!isPresent(bar.high) || !isPresent(bar.low) || !isPresent(bar.close)) return NONE;
+  return result((bar.high + bar.low + bar.close) / 3);
+}
+
+/** `(open + high + low + close) / 4`, the average price. */
+export function ohlc4(bar: Bar): Value {
+  if (!isPresent(bar.open) || !isPresent(bar.high)) return NONE;
+  if (!isPresent(bar.low) || !isPresent(bar.close)) return NONE;
+  return result((bar.open + bar.high + bar.low + bar.close) / 4);
+}
+
+/** `(high + low + close + close) / 4`, the close-weighted average price. */
+export function hlcc4(bar: Bar): Value {
+  if (!isPresent(bar.high) || !isPresent(bar.low) || !isPresent(bar.close)) return NONE;
+  return result((bar.high + bar.low + bar.close + bar.close) / 4);
+}

package/src/core/stdlib/values/index.ts

@@ -0,0 +1,14 @@
+export type { Flag, Flags, Series, Value } from './value.js';
+export { NONE, at, isLength, isPresent, result } from './value.js';
+
+export type { StateField, StateRecord, StateSlot } from './region.js';
+export { copyState, flag, held, newState, queue, slot } from './region.js';
+
+export type { Tail } from './tail.js';
+export { fold, tailOf } from './tail.js';
+
+export type { Lookback, Recurrence } from './lookback.js';
+export { makeLookback, ring, smoothed } from './lookback.js';
+
+export type { Bar } from './bar.js';
+export { hl2, hlc3, hlcc4, ohlc4 } from './bar.js';