Chuỗi (Series)

🇻🇳 Tiếng Việt
🇬🇧 English
🇰🇷 한국어
🇨🇳 中文

Chuỗi là một cột số theo nến (d.close, ta.rsi(d.close, 14)…). Mọi phép là phương thức viết sau dấu chấm và trả một chuỗi mới — nối tiếp được: d.high.sub(d.low).div(d.close).mul(100). Đối số x nhận chuỗi hoặc số.

Quy tắc chung:

NaN lan truyền: một vế NaN thì kết quả NaN. Chia cho 0 → NaN.
Điều kiện: 1 đúng, 0 sai, NaN chưa biết. Dấu / tô / cảnh báo / tín hiệu chỉ bật khi đúng.
So sánh làm tròn 12 chữ số có nghĩa trước khi so (tránh 0,1 + 0,2 ≠ 0,3).
Chỉ dùng quá khứ: không có phép nào đọc nến sau.
Toán tử JavaScript (+, >, &&) không dùng được giữa chuỗi — vì sao.

Số học

Phương thức	Kết quả	Ví dụ
`a.add(x)`	a + x	`d.high.add(d.low)`
`a.sub(x)`	a − x	`d.close.sub(d.open)` — thân nến
`a.mul(x)`	a × x	`ta.sma(d.volume, 20).mul(2)`
`a.div(x)`	a ÷ x (÷ 0 → NaN)	`d.close.div(ta.sma(d.close, 200))`
`a.pow(x)`	aˣ	`d.ret.pow(2)`
`a.min(x)`	Nhỏ hơn của a và x, từng nến	`d.open.min(d.close)` — cạnh dưới thân nến
`a.max(x)`	Lớn hơn của a và x	`d.open.max(d.close)`
`a.neg()`	−a	`d.ret.neg()`
`a.abs()`	\|a\|	`d.close.sub(d.open).abs()`
`a.log()`	ln a (a ≤ 0 → NaN)	`d.close.log().diff(1)` — lợi nhuận log
`a.exp()`	eᵃ
`a.sqrt()`	√a	`d.ret.rolling(20).var().sqrt()`
`a.sign()`	−1 / 0 / 1 theo dấu	`d.close.diff(1).sign()`
`a.round(chuSo = 0)`	Làm tròn tới `chuSo` chữ số thập phân	`ta.rsi(d.close, 14).round(1)`
`a.clip(lo, hi)`	Kẹp a vào [lo, hi]	`d.ret.clip(-0.07, 0.07)`

So sánh

Kết quả là điều kiện (1 / 0; một vế NaN → NaN).

Phương thức	Đúng khi	Ví dụ
`a.gt(x)`	a > x	`ta.rsi(d.close, 14).gt(70)`
`a.gte(x)`	a ≥ x	`d.close.gte(d.close.highest(250))` — đỉnh mới 250 nến
`a.lt(x)`	a < x
`a.lte(x)`	a ≤ x
`a.eq(x)`	a = x	`d.session.weekday.eq(5)` — thứ Sáu
`a.neq(x)`	a ≠ x
`a.between(lo, hi)`	lo ≤ a ≤ hi	`ta.rsi(d.close, 14).between(40, 60)`

Logic

Phương thức	Kết quả	Ghi chú
`a.and(x)`	Đúng khi cả hai đúng	Một vế sai → sai (kể cả vế kia NaN); không vế nào sai mà có NaN → NaN
`a.or(x)`	Đúng khi một trong hai đúng	Một vế đúng → đúng; không vế nào đúng mà có NaN → NaN
`a.not()`	Đảo đúng / sai	NaN → NaN. Muốn coi chưa biết là sai rồi đảo: `a.fillna(0).not()`
`a.where(dk, khac = NaN)`	a khi `dk` đúng, `khac` khi sai hoặc chưa biết	`st.line.where(st.dir.gt(0))` — chỉ giữ phần xu hướng tăng; `x.where(dk, 0)`
`a.isNaN()`	1 khi a là NaN
`a.notNaN()`	1 khi a có giá trị
`a.fillna(so)`	Thay NaN bằng `so`	`d.foreignNet.fillna(0)`; `so` phải là số (chuỗi chữ báo fillna(value) cần một số)
`a.ffill(gioiHan?)`	Lấp NaN bằng giá trị gần nhất trước đó (tối đa `gioiHan` nến)	`o.dinh.ffill()`

"Nếu – thì – không thì" cho chuỗi: d.const(1).where(dk, -1) (1 khi đúng, −1 khi sai), a.where(dk, b) (a hoặc b).

Theo thời gian

Phương thức	Kết quả	Ví dụ
`a.shift(n = 1)`	Giá trị `n` nến trước. `n` < 0 báo lỗi `lookahead`	`d.close.shift(1)` — đóng cửa hôm trước
`a.diff(n = 1)`	a − a[n]	`d.close.diff(5)`
`a.pct(n = 1)`	a ÷ a[n] − 1	`d.close.pct(20)` — % thay đổi 20 nến (dạng tỷ lệ)
`a.cumsum()`	Cộng dồn từ nến đầu (bỏ qua NaN)	`d.volume.mul(d.close.diff(1).sign()).cumsum()` — OBV tự viết
`a.cumprod()`	Nhân dồn	`d.ret.add(1).cumprod()` — tăng trưởng của 1 đồng
`a.cummax()`, `a.cummin()`	Lớn / nhỏ nhất từ nến đầu	`d.close.div(d.close.cummax()).sub(1)` — sụt giảm từ đỉnh lịch sử
`a.ewm(span)`	Trung bình hàm mũ, hệ số 2 ÷ (span + 1), khởi tạo bằng trung bình `span` giá trị đầu	Như `ta.ema(a, span)`
`a.highest(n)`	Lớn nhất `n` nến gần nhất kể cả nến này	`d.high.highest(20).shift(1)` — đỉnh 20 nến trước
`a.lowest(n)`	Nhỏ nhất `n` nến
`a.rolling(n)`	Cửa sổ trượt `n` nến — xem rolling	`d.close.rolling(20).std()`
`a.crossAbove(x)`	Cắt lên: nến trước a ≤ x, nến này a > x	`ta.ema(d.close, 20).crossAbove(ta.ema(d.close, 50))`
`a.crossBelow(x)`	Cắt xuống: nến trước a ≥ x, nến này a < x	`d.close.crossBelow(70)`
`a.cross(x)`	Cắt lên hoặc xuống
`dk.barsSince()`	Số nến kể từ lần `dk` đúng gần nhất (đúng ở nến này → 0; chưa từng → NaN)	`d.close.gte(d.close.highest(250)).barsSince()`
`dk.hold(n)`	Đúng ở nến `dk` đúng và thêm `n` nến sau đó	`cat.hold(3)` — "đã cắt trong 4 nến gần nhất"
`a.valueWhen(dk, thu = 0)`	Giá trị của a ở lần thứ `thu` (0 = gần nhất) `dk` đúng	`d.low.valueWhen(cat)` — đáy của nến tín hiệu gần nhất

crossAbove / crossBelow với một vế NaN cho 0 (không cắt), nên an toàn ở đoạn khởi động.

Cửa sổ trượt: rolling

a.rolling(n) trả một cửa sổ n nến; gọi tiếp một phép để ra chuỗi. Cửa sổ nghiêm ngặt: chưa đủ n giá trị thì NaN.

Phép	Kết quả
`.sum()`	Tổng
`.mean()`	Trung bình (= `ta.sma`)
`.std(mau = false)`	Độ lệch chuẩn tổng thể; `std(true)` độ lệch chuẩn mẫu
`.var(mau = false)`	Phương sai
`.min()`, `.max()`	Nhỏ / lớn nhất (= `lowest` / `highest`)
`.count()`	Số giá trị có (không NaN) trong cửa sổ
`.rank()`	Hạng 0…1 của giá trị cuối trong cửa sổ (1 = cao nhất cửa sổ)
`.zscore()`	(a − trung bình) ÷ độ lệch chuẩn
`.median()`	Trung vị
`.quantile(q)`	Phân vị `q` (0 ≤ q ≤ 1)

Hàm tự viết

Khi không có phép sẵn, viết hàm JavaScript trên số của từng nến. Hàm phải thuần: chỉ dùng đối số, không nhớ gì giữa các nến (cần nhớ → dùng onBar).

Phương thức	Kết quả	Ví dụ
`a.map((x, i) => số)`	Biến đổi từng giá trị (`i`: chỉ số nến)	`d.close.map((x) => Math.floor(x / 5) * 5)` — làm tròn xuống bội 5
`a.zip(b, (x, y) => số)`	Ghép hai chuỗi từng nến	`d.close.zip(d.open, (c, o) => (c > o ? 1 : -1))`
`combine([a, b, c], (vs, i) => số)`	Ghép nhiều chuỗi — Tiện ích
`a.named("tên")`	Đặt tên cho chuỗi (hiện trong giá trị tại con trỏ của trình soạn); trả chính chuỗi đó	`ta.rsi(d.close, 14).named("RSI")`

Script có hàm tự viết chạy chậm hơn một chút và chỉ chạy được nơi có bộ chạy JavaScript (biểu đồ, trình duyệt).

Phép chỉ có ở Quant AI Studio

Các phép dưới cần nhiều mã hoặc đọc giá trị ngay lúc dựng; trên biểu đồ chúng báo lỗi:

Phép	Lỗi trên biểu đồ
`rank()`, `zscore()`, `demean()`, `bucket(q)`, `topN(n)`, `bottomN(n)`, `sumAcross()`, `meanAcross()`, `countAcross()` — so giữa các mã trong một phiên	`universe-only`: rank() là phép cắt ngang giữa các mã — chỉ dùng được ở dạng rổ (Studio)
`resample("week" \| "month" \| …)`	`universe-only` — trên biểu đồ dùng `d.tf("1W")`
`.data`, `.get(s, t)`, `.row(s)`, `.values()`, `.last()`, `.at(ngay)`, `.mean()`, `.days`, `.symbols`, `.rows`, `.cols`, `.pick()`, `.sliceCols()`, `.range()` — đọc giá trị ngay	`eager-in-stream`: data: đọc giá trị lúc dựng chỉ có ở dạng rổ (Studio) — ở biểu đồ dùng onBar(ctx, state)
`rowMap(fn)`	Dùng `onBar`

Chú ý a.rolling(n).rank() / .zscore() (theo thời gian, một mã) khác a.rank() / a.zscore() (cắt ngang giữa các mã).

Ví dụ tổng hợp

Mọi phép chạy được trên biểu đồ trong một chỉ báo (để kiểm tên phép, xem giá trị ở cột Tại nến):

indicator({
  name: "Mọi phép của chuỗi",
  plot: (d) => {
    const c = d.close;
    const so = c.add(1).sub(1).mul(2).div(2).pow(1).min(c.add(1)).max(c.sub(1)).neg().neg().abs()
      .log().exp().sqrt().pow(2).sign().mul(c).round(2).clip(c.mul(0.5), c.mul(2));
    const sosanh = c.gt(c.shift(1)).or(c.gte(c.shift(1))).and(c.lt(c.add(1))).and(c.lte(c)).and(c.eq(c)).and(c.neq(0))
      .and(ta.rsi(c, 14).between(0, 100));
    const logic = sosanh.not().not().where(c.notNaN(), 0).fillna(0).ffill(5).add(c.isNaN());
    const thoiGian = c.shift(2).diff(1).add(c.pct(1)).add(d.ret.cumsum()).add(d.ret.add(1).cumprod())
      .add(c.cummax()).sub(c.cummin()).add(c.ewm(10)).sub(c.highest(10)).add(c.lowest(10));
    const cuaSo = c.rolling(20);
    const tk = cuaSo.sum().div(20).sub(cuaSo.mean()).add(cuaSo.std()).add(cuaSo.std(true)).add(cuaSo.var()).add(cuaSo.min())
      .add(cuaSo.max()).add(cuaSo.count()).add(cuaSo.rank()).add(cuaSo.zscore()).add(cuaSo.median()).add(cuaSo.quantile(0.9));
    const cat = c.crossAbove(ta.sma(c, 20)).or(c.crossBelow(ta.sma(c, 20))).or(c.cross(ta.sma(c, 50)));
    const suKien = cat.barsSince().add(cat.hold(3)).add(d.low.valueWhen(cat)).add(d.low.valueWhen(cat, 1));
    const tuViet = c.map((x) => Math.floor(x / 5) * 5).add(c.zip(d.open, (a, b) => (a > b ? 1 : -1))).named("Tự viết");
    return {
      "Số học": line(so, { hidden: true }),
      "Logic": line(logic, { hidden: true }),
      "Thời gian": line(thoiGian, { hidden: true }),
      "Cửa sổ": line(tk, { hidden: true }),
      "Sự kiện": line(suKien, { hidden: true }),
      "Tự viết": line(tuViet, { color: "accent" }),
    };
  },
});

Các đầu ra đặt hidden: true vẫn có trong chú giải và cột Tại nến — bật lên để xem.

A series is a column of numbers by bar (d.close, ta.rsi(d.close, 14)…). Every operation is a method written after a dot and returns a new series — so they can be chained: d.high.sub(d.low).div(d.close).mul(100). The argument x accepts a series or a number.

General rules:

NaN propagates: if one side is NaN the result is NaN. Division by 0 → NaN.
Conditions: 1 is true, 0 is false, NaN is unknown. Markers / fills / alerts / signals only fire when true.
Comparisons round to 12 significant digits before comparing (avoiding 0.1 + 0.2 ≠ 0.3).
Only the past is used: no operation reads later bars.
JavaScript operators (+, >, &&) cannot be used between series — why.

Arithmetic

Method	Result	Example
`a.add(x)`	a + x	`d.high.add(d.low)`
`a.sub(x)`	a − x	`d.close.sub(d.open)` — candle body
`a.mul(x)`	a × x	`ta.sma(d.volume, 20).mul(2)`
`a.div(x)`	a ÷ x (÷ 0 → NaN)	`d.close.div(ta.sma(d.close, 200))`
`a.pow(x)`	aˣ	`d.ret.pow(2)`
`a.min(x)`	The smaller of a and x, per bar	`d.open.min(d.close)` — bottom edge of the candle body
`a.max(x)`	The larger of a and x	`d.open.max(d.close)`
`a.neg()`	−a	`d.ret.neg()`
`a.abs()`	\|a\|	`d.close.sub(d.open).abs()`
`a.log()`	ln a (a ≤ 0 → NaN)	`d.close.log().diff(1)` — log return
`a.exp()`	eᵃ
`a.sqrt()`	√a	`d.ret.rolling(20).var().sqrt()`
`a.sign()`	−1 / 0 / 1 by sign	`d.close.diff(1).sign()`
`a.round(chuSo = 0)`	Rounds to `chuSo` decimal places	`ta.rsi(d.close, 14).round(1)`
`a.clip(lo, hi)`	Clamps a to [lo, hi]	`d.ret.clip(-0.07, 0.07)`

Comparison

The result is a condition (1 / 0; one side NaN → NaN).

Method	True when	Example
`a.gt(x)`	a > x	`ta.rsi(d.close, 14).gt(70)`
`a.gte(x)`	a ≥ x	`d.close.gte(d.close.highest(250))` — new 250-bar high
`a.lt(x)`	a < x
`a.lte(x)`	a ≤ x
`a.eq(x)`	a = x	`d.session.weekday.eq(5)` — Friday
`a.neq(x)`	a ≠ x
`a.between(lo, hi)`	lo ≤ a ≤ hi	`ta.rsi(d.close, 14).between(40, 60)`

Logic

Method	Result	Notes
`a.and(x)`	True when both are true	One side false → false (even if the other is NaN); no side false but a NaN present → NaN
`a.or(x)`	True when either is true	One side true → true; no side true but a NaN present → NaN
`a.not()`	Flips true / false	NaN → NaN. To treat unknown as false and then flip: `a.fillna(0).not()`
`a.where(dk, khac = NaN)`	a when `dk` is true, `khac` when false or unknown	`st.line.where(st.dir.gt(0))` — keeps only the uptrend part; `x.where(dk, 0)`
`a.isNaN()`	1 when a is NaN
`a.notNaN()`	1 when a has a value
`a.fillna(so)`	Replaces NaN with `so`	`d.foreignNet.fillna(0)`; `so` must be a number (text triggers fillna(value) cần một số (fillna(value) needs a number))
`a.ffill(gioiHan?)`	Fills NaN with the most recent earlier value (up to `gioiHan` bars)	`o.dinh.ffill()`

"If – then – else" for series: d.const(1).where(dk, -1) (1 when true, −1 when false), a.where(dk, b) (a or b).

Over time

Method	Result	Example
`a.shift(n = 1)`	The value `n` bars ago. `n` < 0 raises a `lookahead` error	`d.close.shift(1)` — previous day's close
`a.diff(n = 1)`	a − a[n]	`d.close.diff(5)`
`a.pct(n = 1)`	a ÷ a[n] − 1	`d.close.pct(20)` — % change over 20 bars (as a ratio)
`a.cumsum()`	Cumulative sum from the first bar (NaN skipped)	`d.volume.mul(d.close.diff(1).sign()).cumsum()` — hand-written OBV
`a.cumprod()`	Cumulative product	`d.ret.add(1).cumprod()` — growth of 1 dong
`a.cummax()`, `a.cummin()`	Highest / lowest since the first bar	`d.close.div(d.close.cummax()).sub(1)` — drawdown from the all-time high
`a.ewm(span)`	Exponential average, factor 2 ÷ (span + 1), seeded with the mean of the first `span` values	Like `ta.ema(a, span)`
`a.highest(n)`	Highest of the last `n` bars including this bar	`d.high.highest(20).shift(1)` — high of the previous 20 bars
`a.lowest(n)`	Lowest of `n` bars
`a.rolling(n)`	An `n`-bar rolling window — see rolling	`d.close.rolling(20).std()`
`a.crossAbove(x)`	Crosses above: on the previous bar a ≤ x, on this bar a > x	`ta.ema(d.close, 20).crossAbove(ta.ema(d.close, 50))`
`a.crossBelow(x)`	Crosses below: on the previous bar a ≥ x, on this bar a < x	`d.close.crossBelow(70)`
`a.cross(x)`	Crosses above or below
`dk.barsSince()`	Bars since `dk` was last true (true on this bar → 0; never → NaN)	`d.close.gte(d.close.highest(250)).barsSince()`
`dk.hold(n)`	True on the bar where `dk` is true and for `n` more bars after it	`cat.hold(3)` — "crossed within the last 4 bars"
`a.valueWhen(dk, thu = 0)`	The value of a at the `thu`-th (0 = most recent) time `dk` was true	`d.low.valueWhen(cat)` — the low of the most recent signal bar

crossAbove / crossBelow with one side NaN give 0 (no cross), so they are safe during the warm-up period.

Rolling window: rolling

a.rolling(n) returns an n-bar window; call another operation on it to get a series. The window is strict: fewer than n values gives NaN.

Operation	Result
`.sum()`	Sum
`.mean()`	Mean (= `ta.sma`)
`.std(mau = false)`	Population standard deviation; `std(true)` for sample standard deviation
`.var(mau = false)`	Variance
`.min()`, `.max()`	Lowest / highest (= `lowest` / `highest`)
`.count()`	Number of available (non-NaN) values in the window
`.rank()`	Rank 0…1 of the last value in the window (1 = highest in the window)
`.zscore()`	(a − mean) ÷ standard deviation
`.median()`	Median
`.quantile(q)`	Quantile `q` (0 ≤ q ≤ 1)

Custom functions

When no built-in operation exists, write a JavaScript function over each bar's numbers. The function must be pure: it uses only its arguments and remembers nothing between bars (if you need memory → use onBar).

Method	Result	Example
`a.map((x, i) => số)`	Transforms each value (`i`: bar index)	`d.close.map((x) => Math.floor(x / 5) * 5)` — round down to a multiple of 5
`a.zip(b, (x, y) => số)`	Combines two series bar by bar	`d.close.zip(d.open, (c, o) => (c > o ? 1 : -1))`
`combine([a, b, c], (vs, i) => số)`	Combines several series — Utilities
`a.named("tên")`	Names the series (shown in the editor's value-at-cursor); returns the same series	`ta.rsi(d.close, 14).named("RSI")`

Scripts with custom functions run slightly slower and only run where a JavaScript runtime is available (the chart, the browser).

Operations only available in Quant AI Studio

The operations below need many tickers or read values immediately at build time; on the chart they raise errors:

Operation	Error on the chart
`rank()`, `zscore()`, `demean()`, `bucket(q)`, `topN(n)`, `bottomN(n)`, `sumAcross()`, `meanAcross()`, `countAcross()` — compare across tickers within a session	`universe-only`: rank() là phép cắt ngang giữa các mã — chỉ dùng được ở dạng rổ (Studio) (rank() is a cross-sectional operation across tickers — only available in basket mode (Studio))
`resample("week" \| "month" \| …)`	`universe-only` — on the chart use `d.tf("1W")`
`.data`, `.get(s, t)`, `.row(s)`, `.values()`, `.last()`, `.at(ngay)`, `.mean()`, `.days`, `.symbols`, `.rows`, `.cols`, `.pick()`, `.sliceCols()`, `.range()` — read values immediately	`eager-in-stream`: data: đọc giá trị lúc dựng chỉ có ở dạng rổ (Studio) — ở biểu đồ dùng onBar(ctx, state) (data: reading values at build time is only available in basket mode (Studio) — on the chart use onBar(ctx, state))
`rowMap(fn)`	Use `onBar`

Note that a.rolling(n).rank() / .zscore() (over time, one ticker) differ from a.rank() / a.zscore() (cross-sectional across tickers).

Combined example

Every operation that runs on the chart, in one indicator (to check operation names and see values in the Tại nến (At bar) column):

indicator({
  name: "Mọi phép của chuỗi",
  plot: (d) => {
    const c = d.close;
    const so = c.add(1).sub(1).mul(2).div(2).pow(1).min(c.add(1)).max(c.sub(1)).neg().neg().abs()
      .log().exp().sqrt().pow(2).sign().mul(c).round(2).clip(c.mul(0.5), c.mul(2));
    const sosanh = c.gt(c.shift(1)).or(c.gte(c.shift(1))).and(c.lt(c.add(1))).and(c.lte(c)).and(c.eq(c)).and(c.neq(0))
      .and(ta.rsi(c, 14).between(0, 100));
    const logic = sosanh.not().not().where(c.notNaN(), 0).fillna(0).ffill(5).add(c.isNaN());
    const thoiGian = c.shift(2).diff(1).add(c.pct(1)).add(d.ret.cumsum()).add(d.ret.add(1).cumprod())
      .add(c.cummax()).sub(c.cummin()).add(c.ewm(10)).sub(c.highest(10)).add(c.lowest(10));
    const cuaSo = c.rolling(20);
    const tk = cuaSo.sum().div(20).sub(cuaSo.mean()).add(cuaSo.std()).add(cuaSo.std(true)).add(cuaSo.var()).add(cuaSo.min())
      .add(cuaSo.max()).add(cuaSo.count()).add(cuaSo.rank()).add(cuaSo.zscore()).add(cuaSo.median()).add(cuaSo.quantile(0.9));
    const cat = c.crossAbove(ta.sma(c, 20)).or(c.crossBelow(ta.sma(c, 20))).or(c.cross(ta.sma(c, 50)));
    const suKien = cat.barsSince().add(cat.hold(3)).add(d.low.valueWhen(cat)).add(d.low.valueWhen(cat, 1));
    const tuViet = c.map((x) => Math.floor(x / 5) * 5).add(c.zip(d.open, (a, b) => (a > b ? 1 : -1))).named("Tự viết");
    return {
      "Số học": line(so, { hidden: true }),
      "Logic": line(logic, { hidden: true }),
      "Thời gian": line(thoiGian, { hidden: true }),
      "Cửa sổ": line(tk, { hidden: true }),
      "Sự kiện": line(suKien, { hidden: true }),
      "Tự viết": line(tuViet, { color: "accent" }),
    };
  },
});

Outputs set to hidden: true still appear in the legend and the Tại nến (At bar) column — turn them on to view them.

시리즈는 봉 단위의 숫자 열입니다(d.close, ta.rsi(d.close, 14)…). 모든 연산은 점 뒤에 쓰는 메서드이며 새 시리즈를 반환하므로 이어 붙일 수 있습니다: d.high.sub(d.low).div(d.close).mul(100). 인수 x는 시리즈 또는 숫자를 받습니다.

공통 규칙:

NaN 전파: 한쪽이 NaN이면 결과도 NaN입니다. 0으로 나누면 NaN입니다.
조건: 1은 참, 0은 거짓, NaN은 미정입니다. 마커 / 색칠 / 알림 / 신호는 참일 때만 켜집니다.
비교 전에 유효숫자 12자리로 반올림합니다(0.1 + 0.2 ≠ 0.3 문제 방지).
과거만 사용합니다. 다음 봉을 읽는 연산은 없습니다.
JavaScript 연산자(+, >, &&)는 시리즈 사이에 사용할 수 없습니다 — 이유.

산술

메서드	결과	예시
`a.add(x)`	a + x	`d.high.add(d.low)`
`a.sub(x)`	a − x	`d.close.sub(d.open)` — 봉의 몸통
`a.mul(x)`	a × x	`ta.sma(d.volume, 20).mul(2)`
`a.div(x)`	a ÷ x(÷ 0 → NaN)	`d.close.div(ta.sma(d.close, 200))`
`a.pow(x)`	aˣ	`d.ret.pow(2)`
`a.min(x)`	봉마다 a와 x 중 작은 값	`d.open.min(d.close)` — 몸통의 아래쪽 끝
`a.max(x)`	a와 x 중 큰 값	`d.open.max(d.close)`
`a.neg()`	−a	`d.ret.neg()`
`a.abs()`	\|a\|	`d.close.sub(d.open).abs()`
`a.log()`	ln a(a ≤ 0 → NaN)	`d.close.log().diff(1)` — 로그 수익률
`a.exp()`	eᵃ
`a.sqrt()`	√a	`d.ret.rolling(20).var().sqrt()`
`a.sign()`	부호에 따라 −1 / 0 / 1	`d.close.diff(1).sign()`
`a.round(chuSo = 0)`	소수점 `chuSo`자리로 반올림	`ta.rsi(d.close, 14).round(1)`
`a.clip(lo, hi)`	a를 [lo, hi] 안으로 제한	`d.ret.clip(-0.07, 0.07)`

비교

결과는 조건입니다(1 / 0; 한쪽이 NaN → NaN).

메서드	참인 경우	예시
`a.gt(x)`	a > x	`ta.rsi(d.close, 14).gt(70)`
`a.gte(x)`	a ≥ x	`d.close.gte(d.close.highest(250))` — 250개 봉 신고점
`a.lt(x)`	a < x
`a.lte(x)`	a ≤ x
`a.eq(x)`	a = x	`d.session.weekday.eq(5)` — 금요일
`a.neq(x)`	a ≠ x
`a.between(lo, hi)`	lo ≤ a ≤ hi	`ta.rsi(d.close, 14).between(40, 60)`

논리

메서드	결과	참고
`a.and(x)`	둘 다 참이면 참	한쪽이 거짓 → 거짓(다른 쪽이 NaN이어도); 거짓인 쪽 없이 NaN이 있으면 → NaN
`a.or(x)`	둘 중 하나가 참이면 참	한쪽이 참 → 참; 참인 쪽 없이 NaN이 있으면 → NaN
`a.not()`	참 / 거짓 반전	NaN → NaN. 미정을 거짓으로 보고 반전하려면: `a.fillna(0).not()`
`a.where(dk, khac = NaN)`	`dk`가 참이면 a, 거짓 또는 미정이면 `khac`	`st.line.where(st.dir.gt(0))` — 상승 추세 구간만 유지; `x.where(dk, 0)`
`a.isNaN()`	a가 NaN이면 1
`a.notNaN()`	a에 값이 있으면 1
`a.fillna(so)`	NaN을 `so`로 대체	`d.foreignNet.fillna(0)`; `so`는 숫자여야 함(문자열을 넣으면 fillna(value) cần một số(fillna(value)에는 숫자가 필요) 오류)
`a.ffill(gioiHan?)`	NaN을 직전의 가장 가까운 값으로 채움(최대 `gioiHan`개 봉)	`o.dinh.ffill()`

시리즈용 "만약 – 이면 – 아니면": d.const(1).where(dk, -1)(참이면 1, 거짓이면 −1), a.where(dk, b)(a 또는 b).

시간 기준

메서드	결과	예시
`a.shift(n = 1)`	`n`개 봉 전의 값. `n` < 0이면 `lookahead` 오류	`d.close.shift(1)` — 전일 종가
`a.diff(n = 1)`	a − a[n]	`d.close.diff(5)`
`a.pct(n = 1)`	a ÷ a[n] − 1	`d.close.pct(20)` — 20개 봉 변화율(비율 형태)
`a.cumsum()`	첫 봉부터 누적 합(NaN 무시)	`d.volume.mul(d.close.diff(1).sign()).cumsum()` — 직접 작성한 OBV
`a.cumprod()`	누적 곱	`d.ret.add(1).cumprod()` — 1동의 성장
`a.cummax()`, `a.cummin()`	첫 봉부터의 최댓값 / 최솟값	`d.close.div(d.close.cummax()).sub(1)` — 역사적 고점 대비 낙폭
`a.ewm(span)`	지수 평균, 계수 2 ÷ (span + 1), 처음 `span`개 값의 평균으로 초기화	`ta.ema(a, span)`과 같음
`a.highest(n)`	이 봉을 포함한 최근 `n`개 봉의 최댓값	`d.high.highest(20).shift(1)` — 이전 20개 봉의 고점
`a.lowest(n)`	`n`개 봉의 최솟값
`a.rolling(n)`	`n`개 봉 이동 창 — rolling 참고	`d.close.rolling(20).std()`
`a.crossAbove(x)`	상향 돌파: 이전 봉 a ≤ x, 이번 봉 a > x	`ta.ema(d.close, 20).crossAbove(ta.ema(d.close, 50))`
`a.crossBelow(x)`	하향 돌파: 이전 봉 a ≥ x, 이번 봉 a < x	`d.close.crossBelow(70)`
`a.cross(x)`	상향 또는 하향 돌파
`dk.barsSince()`	`dk`가 마지막으로 참이었던 이후의 봉 수(이번 봉에서 참 → 0; 한 번도 없음 → NaN)	`d.close.gte(d.close.highest(250)).barsSince()`
`dk.hold(n)`	`dk`가 참인 봉과 그 뒤 `n`개 봉 동안 참	`cat.hold(3)` — "최근 4개 봉 안에 돌파함"
`a.valueWhen(dk, thu = 0)`	`dk`가 `thu`번째로(0 = 가장 최근) 참이었을 때의 a 값	`d.low.valueWhen(cat)` — 가장 최근 신호 봉의 저가

crossAbove / crossBelow는 한쪽이 NaN이면 0(돌파 아님)을 내므로 워밍업 구간에서도 안전합니다.

이동 창: rolling

a.rolling(n)은 n개 봉의 창을 반환합니다. 이어서 연산을 하나 호출해야 시리즈가 됩니다. 창은 엄격합니다: n개 값이 차지 않으면 NaN입니다.

연산	결과
`.sum()`	합계
`.mean()`	평균(= `ta.sma`)
`.std(mau = false)`	모표준편차; `std(true)`는 표본표준편차
`.var(mau = false)`	분산
`.min()`, `.max()`	최솟값 / 최댓값(= `lowest` / `highest`)
`.count()`	창 안에 있는(NaN이 아닌) 값의 수
`.rank()`	창 안에서 마지막 값의 0…1 순위(1 = 창에서 가장 높음)
`.zscore()`	(a − 평균) ÷ 표준편차
`.median()`	중앙값
`.quantile(q)`	`q` 분위수(0 ≤ q ≤ 1)

직접 작성하는 함수

기본 제공 연산이 없을 때는 봉마다의 숫자에 대해 JavaScript 함수를 작성하세요. 함수는 순수해야 합니다. 인수만 사용하고 봉 사이에 아무것도 기억하지 않아야 합니다(기억이 필요하면 → onBar 사용).

메서드	결과	예시
`a.map((x, i) => số)`	값을 하나씩 변환(`i`: 봉 인덱스)	`d.close.map((x) => Math.floor(x / 5) * 5)` — 5의 배수로 내림
`a.zip(b, (x, y) => số)`	두 시리즈를 봉마다 결합	`d.close.zip(d.open, (c, o) => (c > o ? 1 : -1))`
`combine([a, b, c], (vs, i) => số)`	여러 시리즈 결합 — 유틸리티
`a.named("tên")`	시리즈에 이름을 붙임(편집기의 커서 위치 값에 표시); 같은 시리즈를 반환	`ta.rsi(d.close, 14).named("RSI")`

직접 작성한 함수가 있는 스크립트는 조금 느리게 실행되며, JavaScript 실행기가 있는 곳(차트, 브라우저)에서만 실행됩니다.

Quant AI Studio에만 있는 연산

아래 연산은 여러 종목이 필요하거나 구성 시점에 값을 바로 읽어야 하므로, 차트에서는 오류가 납니다.

연산	차트에서의 오류
`rank()`, `zscore()`, `demean()`, `bucket(q)`, `topN(n)`, `bottomN(n)`, `sumAcross()`, `meanAcross()`, `countAcross()` — 한 세션 안에서 종목 간 비교	`universe-only`: rank() là phép cắt ngang giữa các mã — chỉ dùng được ở dạng rổ (Studio)(rank()는 종목 간 횡단면 연산이므로 바스켓 형태(Studio)에서만 사용 가능)
`resample("week" \| "month" \| …)`	`universe-only` — 차트에서는 `d.tf("1W")` 사용
`.data`, `.get(s, t)`, `.row(s)`, `.values()`, `.last()`, `.at(ngay)`, `.mean()`, `.days`, `.symbols`, `.rows`, `.cols`, `.pick()`, `.sliceCols()`, `.range()` — 값을 즉시 읽음	`eager-in-stream`: data: đọc giá trị lúc dựng chỉ có ở dạng rổ (Studio) — ở biểu đồ dùng onBar(ctx, state)(구성 시점에 값을 읽는 것은 바스켓 형태(Studio)에서만 가능 — 차트에서는 onBar(ctx, state) 사용)
`rowMap(fn)`	`onBar` 사용

a.rolling(n).rank() / .zscore()(시간 기준, 한 종목)는 a.rank() / a.zscore()(종목 간 횡단면)와 다르다는 점에 주의하세요.

종합 예제

차트에서 실행할 수 있는 모든 연산을 지표 하나에 담았습니다(연산 이름을 확인하고 Tại nến(해당 봉) 열에서 값을 보세요).

indicator({
  name: "Mọi phép của chuỗi",
  plot: (d) => {
    const c = d.close;
    const so = c.add(1).sub(1).mul(2).div(2).pow(1).min(c.add(1)).max(c.sub(1)).neg().neg().abs()
      .log().exp().sqrt().pow(2).sign().mul(c).round(2).clip(c.mul(0.5), c.mul(2));
    const sosanh = c.gt(c.shift(1)).or(c.gte(c.shift(1))).and(c.lt(c.add(1))).and(c.lte(c)).and(c.eq(c)).and(c.neq(0))
      .and(ta.rsi(c, 14).between(0, 100));
    const logic = sosanh.not().not().where(c.notNaN(), 0).fillna(0).ffill(5).add(c.isNaN());
    const thoiGian = c.shift(2).diff(1).add(c.pct(1)).add(d.ret.cumsum()).add(d.ret.add(1).cumprod())
      .add(c.cummax()).sub(c.cummin()).add(c.ewm(10)).sub(c.highest(10)).add(c.lowest(10));
    const cuaSo = c.rolling(20);
    const tk = cuaSo.sum().div(20).sub(cuaSo.mean()).add(cuaSo.std()).add(cuaSo.std(true)).add(cuaSo.var()).add(cuaSo.min())
      .add(cuaSo.max()).add(cuaSo.count()).add(cuaSo.rank()).add(cuaSo.zscore()).add(cuaSo.median()).add(cuaSo.quantile(0.9));
    const cat = c.crossAbove(ta.sma(c, 20)).or(c.crossBelow(ta.sma(c, 20))).or(c.cross(ta.sma(c, 50)));
    const suKien = cat.barsSince().add(cat.hold(3)).add(d.low.valueWhen(cat)).add(d.low.valueWhen(cat, 1));
    const tuViet = c.map((x) => Math.floor(x / 5) * 5).add(c.zip(d.open, (a, b) => (a > b ? 1 : -1))).named("Tự viết");
    return {
      "Số học": line(so, { hidden: true }),
      "Logic": line(logic, { hidden: true }),
      "Thời gian": line(thoiGian, { hidden: true }),
      "Cửa sổ": line(tk, { hidden: true }),
      "Sự kiện": line(suKien, { hidden: true }),
      "Tự viết": line(tuViet, { color: "accent" }),
    };
  },
});

hidden: true로 설정한 출력도 범례와 Tại nến(해당 봉) 열에는 남아 있습니다. 켜서 확인하세요.

序列是按 K 线排列的一列数字（d.close、ta.rsi(d.close, 14)…）。所有运算都是写在点号之后的方法，返回一个新序列——可以链式调用：d.high.sub(d.low).div(d.close).mul(100)。参数 x 接受序列或数字。

通用规则：

NaN 会传播：任一边为 NaN，结果就是 NaN。除以 0 → NaN。
条件：1 为真，0 为假，NaN 为未知。标记 / 着色 / 提醒 / 信号只在为真时触发。
比较前先四舍五入到 12 位有效数字（避免 0.1 + 0.2 ≠ 0.3）。
只使用过去的数据：没有任何运算读取之后的 K 线。
JavaScript 运算符（+、>、&&）不能用于序列之间——原因。

算术

方法	结果	示例
`a.add(x)`	a + x	`d.high.add(d.low)`
`a.sub(x)`	a − x	`d.close.sub(d.open)`——K 线实体
`a.mul(x)`	a × x	`ta.sma(d.volume, 20).mul(2)`
`a.div(x)`	a ÷ x（÷ 0 → NaN）	`d.close.div(ta.sma(d.close, 200))`
`a.pow(x)`	aˣ	`d.ret.pow(2)`
`a.min(x)`	逐根 K 线取 a 与 x 中较小者	`d.open.min(d.close)`——K 线实体的下沿
`a.max(x)`	a 与 x 中较大者	`d.open.max(d.close)`
`a.neg()`	−a	`d.ret.neg()`
`a.abs()`	\|a\|	`d.close.sub(d.open).abs()`
`a.log()`	ln a（a ≤ 0 → NaN）	`d.close.log().diff(1)`——对数收益率
`a.exp()`	eᵃ
`a.sqrt()`	√a	`d.ret.rolling(20).var().sqrt()`
`a.sign()`	按符号取 −1 / 0 / 1	`d.close.diff(1).sign()`
`a.round(chuSo = 0)`	四舍五入到 `chuSo` 位小数	`ta.rsi(d.close, 14).round(1)`
`a.clip(lo, hi)`	将 a 限制在 [lo, hi] 内	`d.ret.clip(-0.07, 0.07)`

比较

结果是条件（1 / 0；任一边为 NaN → NaN）。

方法	何时为真	示例
`a.gt(x)`	a > x	`ta.rsi(d.close, 14).gt(70)`
`a.gte(x)`	a ≥ x	`d.close.gte(d.close.highest(250))`——250 根 K 线新高
`a.lt(x)`	a < x
`a.lte(x)`	a ≤ x
`a.eq(x)`	a = x	`d.session.weekday.eq(5)`——星期五
`a.neq(x)`	a ≠ x
`a.between(lo, hi)`	lo ≤ a ≤ hi	`ta.rsi(d.close, 14).between(40, 60)`

逻辑

方法	结果	说明
`a.and(x)`	两者都为真时为真	任一边为假 → 假（即使另一边为 NaN）；没有一边为假但有 NaN → NaN
`a.or(x)`	其中之一为真时为真	任一边为真 → 真；没有一边为真但有 NaN → NaN
`a.not()`	真 / 假取反	NaN → NaN。想把未知视为假再取反：`a.fillna(0).not()`
`a.where(dk, khac = NaN)`	`dk` 为真时取 a，为假或未知时取 `khac`	`st.line.where(st.dir.gt(0))`——只保留上升趋势部分；`x.where(dk, 0)`
`a.isNaN()`	a 为 NaN 时为 1
`a.notNaN()`	a 有值时为 1
`a.fillna(so)`	用 `so` 替换 NaN	`d.foreignNet.fillna(0)`；`so` 必须是数字（传入文本会提示 fillna(value) cần một số（fillna(value) 需要一个数字））
`a.ffill(gioiHan?)`	用之前最近的值填充 NaN（最多 `gioiHan` 根 K 线）	`o.dinh.ffill()`

序列的“如果——则——否则”：d.const(1).where(dk, -1)（为真时 1，为假时 −1），a.where(dk, b)（a 或 b）。

按时间

方法	结果	示例
`a.shift(n = 1)`	`n` 根 K 线之前的值。`n` < 0 报 `lookahead` 错误	`d.close.shift(1)`——前一天收盘价
`a.diff(n = 1)`	a − a[n]	`d.close.diff(5)`
`a.pct(n = 1)`	a ÷ a[n] − 1	`d.close.pct(20)`——20 根 K 线的变化百分比（比例形式）
`a.cumsum()`	从第一根 K 线开始累加（跳过 NaN）	`d.volume.mul(d.close.diff(1).sign()).cumsum()`——自己编写的 OBV
`a.cumprod()`	累乘	`d.ret.add(1).cumprod()`——1 越南盾的增长
`a.cummax()`、`a.cummin()`	从第一根 K 线以来的最大 / 最小值	`d.close.div(d.close.cummax()).sub(1)`——相对历史高点的回撤
`a.ewm(span)`	指数平均，系数 2 ÷ (span + 1)，以前 `span` 个值的平均值初始化	同 `ta.ema(a, span)`
`a.highest(n)`	最近 `n` 根 K 线（含当前 K 线）的最大值	`d.high.highest(20).shift(1)`——之前 20 根 K 线的高点
`a.lowest(n)`	`n` 根 K 线的最小值
`a.rolling(n)`	`n` 根 K 线的滑动窗口——见 rolling	`d.close.rolling(20).std()`
`a.crossAbove(x)`	上穿：前一根 K 线 a ≤ x，当前 K 线 a > x	`ta.ema(d.close, 20).crossAbove(ta.ema(d.close, 50))`
`a.crossBelow(x)`	下穿：前一根 K 线 a ≥ x，当前 K 线 a < x	`d.close.crossBelow(70)`
`a.cross(x)`	上穿或下穿
`dk.barsSince()`	自 `dk` 最近一次为真以来的 K 线数（当前 K 线为真 → 0；从未为真 → NaN）	`d.close.gte(d.close.highest(250)).barsSince()`
`dk.hold(n)`	在 `dk` 为真的 K 线及其后 `n` 根 K 线上为真	`cat.hold(3)`——“最近 4 根 K 线内发生过交叉”
`a.valueWhen(dk, thu = 0)`	第 `thu` 次（0 = 最近一次）`dk` 为真时 a 的值	`d.low.valueWhen(cat)`——最近一根信号 K 线的低点

crossAbove / crossBelow 任一边为 NaN 时结果为 0（不交叉），因此在预热段是安全的。

滑动窗口：rolling

a.rolling(n) 返回一个 n 根 K 线的窗口；再调用一个运算即可得到序列。窗口是严格的：不足 n 个值时为 NaN。

运算	结果
`.sum()`	总和
`.mean()`	平均值（= `ta.sma`）
`.std(mau = false)`	总体标准差；`std(true)` 为样本标准差
`.var(mau = false)`	方差
`.min()`、`.max()`	最小 / 最大值（= `lowest` / `highest`）
`.count()`	窗口内有值（非 NaN）的个数
`.rank()`	最后一个值在窗口中的排名 0…1（1 = 窗口内最高）
`.zscore()`	(a − 平均值) ÷ 标准差
`.median()`	中位数
`.quantile(q)`	分位数 `q`（0 ≤ q ≤ 1）

自定义函数

没有现成运算时，可以针对每根 K 线的数字编写 JavaScript 函数。函数必须是纯函数：只使用参数，不在 K 线之间记忆任何东西（需要记忆 → 使用 onBar）。

方法	结果	示例
`a.map((x, i) => số)`	变换每个值（`i`：K 线索引）	`d.close.map((x) => Math.floor(x / 5) * 5)`——向下取整到 5 的倍数
`a.zip(b, (x, y) => số)`	逐根 K 线合并两个序列	`d.close.zip(d.open, (c, o) => (c > o ? 1 : -1))`
`combine([a, b, c], (vs, i) => số)`	合并多个序列——工具函数
`a.named("tên")`	为序列命名（显示在编辑器的光标处取值中）；返回序列本身	`ta.rsi(d.close, 14).named("RSI")`

含自定义函数的脚本运行稍慢，并且只能在有 JavaScript 运行器的地方运行（图表、浏览器）。

仅在 Quant AI Studio 中可用的运算

以下运算需要多只股票或在构建时立即读取值；在图表上会报错：

运算	图表上的错误
`rank()`、`zscore()`、`demean()`、`bucket(q)`、`topN(n)`、`bottomN(n)`、`sumAcross()`、`meanAcross()`、`countAcross()`——在同一交易时段内跨股票比较	`universe-only`：rank() là phép cắt ngang giữa các mã — chỉ dùng được ở dạng rổ (Studio)（rank() 是跨股票的横截面运算——只能在股票池形式（Studio）中使用）
`resample("week" \| "month" \| …)`	`universe-only`——在图表上请用 `d.tf("1W")`
`.data`、`.get(s, t)`、`.row(s)`、`.values()`、`.last()`、`.at(ngay)`、`.mean()`、`.days`、`.symbols`、`.rows`、`.cols`、`.pick()`、`.sliceCols()`、`.range()`——立即读取值	`eager-in-stream`：data: đọc giá trị lúc dựng chỉ có ở dạng rổ (Studio) — ở biểu đồ dùng onBar(ctx, state)（data：构建时读取值只在股票池形式（Studio）中可用——图表上请用 onBar(ctx, state)）
`rowMap(fn)`	使用 `onBar`

注意 a.rolling(n).rank() / .zscore()（按时间，单只股票）不同于 a.rank() / a.zscore()（跨股票横截面）。

综合示例

在一个指标中运行图表上可用的所有运算（用于检查运算名称，在 Tại nến（当前 K 线）列中查看取值）：

indicator({
  name: "Mọi phép của chuỗi",
  plot: (d) => {
    const c = d.close;
    const so = c.add(1).sub(1).mul(2).div(2).pow(1).min(c.add(1)).max(c.sub(1)).neg().neg().abs()
      .log().exp().sqrt().pow(2).sign().mul(c).round(2).clip(c.mul(0.5), c.mul(2));
    const sosanh = c.gt(c.shift(1)).or(c.gte(c.shift(1))).and(c.lt(c.add(1))).and(c.lte(c)).and(c.eq(c)).and(c.neq(0))
      .and(ta.rsi(c, 14).between(0, 100));
    const logic = sosanh.not().not().where(c.notNaN(), 0).fillna(0).ffill(5).add(c.isNaN());
    const thoiGian = c.shift(2).diff(1).add(c.pct(1)).add(d.ret.cumsum()).add(d.ret.add(1).cumprod())
      .add(c.cummax()).sub(c.cummin()).add(c.ewm(10)).sub(c.highest(10)).add(c.lowest(10));
    const cuaSo = c.rolling(20);
    const tk = cuaSo.sum().div(20).sub(cuaSo.mean()).add(cuaSo.std()).add(cuaSo.std(true)).add(cuaSo.var()).add(cuaSo.min())
      .add(cuaSo.max()).add(cuaSo.count()).add(cuaSo.rank()).add(cuaSo.zscore()).add(cuaSo.median()).add(cuaSo.quantile(0.9));
    const cat = c.crossAbove(ta.sma(c, 20)).or(c.crossBelow(ta.sma(c, 20))).or(c.cross(ta.sma(c, 50)));
    const suKien = cat.barsSince().add(cat.hold(3)).add(d.low.valueWhen(cat)).add(d.low.valueWhen(cat, 1));
    const tuViet = c.map((x) => Math.floor(x / 5) * 5).add(c.zip(d.open, (a, b) => (a > b ? 1 : -1))).named("Tự viết");
    return {
      "Số học": line(so, { hidden: true }),
      "Logic": line(logic, { hidden: true }),
      "Thời gian": line(thoiGian, { hidden: true }),
      "Cửa sổ": line(tk, { hidden: true }),
      "Sự kiện": line(suKien, { hidden: true }),
      "Tự viết": line(tuViet, { color: "accent" }),
    };
  },
});

设置了 hidden: true 的输出仍会出现在图例和 Tại nến（当前 K 线）列中——打开即可查看。

Số học​

So sánh​

Logic​

Theo thời gian​

Cửa sổ trượt: rolling​

Hàm tự viết​

Phép chỉ có ở Quant AI Studio​

Ví dụ tổng hợp​

Arithmetic​

Comparison​

Logic​

Over time​

Rolling window: rolling​

Custom functions​

Operations only available in Quant AI Studio​

Combined example​

산술​

비교​

논리​

시간 기준​

이동 창: rolling​

직접 작성하는 함수​

Quant AI Studio에만 있는 연산​

종합 예제​

算术​

比较​

逻辑​

按时间​

滑动窗口：rolling​

自定义函数​

仅在 Quant AI Studio 中可用的运算​

综合示例​

Số học

So sánh

Logic

Theo thời gian

Cửa sổ trượt: rolling

Hàm tự viết

Phép chỉ có ở Quant AI Studio

Ví dụ tổng hợp

Arithmetic

Comparison

Logic

Over time

Rolling window: rolling

Custom functions

Operations only available in Quant AI Studio

Combined example

산술

비교

논리

시간 기준

이동 창: rolling

직접 작성하는 함수

Quant AI Studio에만 있는 연산

종합 예제

算术

比较

逻辑

按时间

滑动窗口：rolling

自定义函数

仅在 Quant AI Studio 中可用的运算

综合示例