GatedStats

• Five window types: the whole history, since a reset, the last N samples, the last N bars, and a rolling span of time.
• Gate and na aware: a bar is a sample only if the gate is true AND the value is not na. Missing data never pollutes a result and never shifts a window.
• Time windows keep sliding: expired samples are evicted on every bar, including bars where the gate is false, so a "last hour" window really is the last hour.
• Drift-safe: running totals are rebuilt from the stored samples periodically, so add/subtract float error cannot accumulate over long histories.
• Gated moving averages: gatedMa() offers SMA, EMA, RMA, WMA, SWMA and VWMA whose length counts samples, not bars.
• Weighted standard deviation: gatedVwapTime() returns a true window-wide VWAP and weighted standard deviation, not a per-bar running estimate.
• No repainting of closed bars: every function depends only on the current and past bars.

• A window of N samples always contains exactly N values, however many bars back the oldest one is.
• A window of N bars covers a fixed stretch of the chart and may contain anywhere from zero to N samples.
• A window of time covers a fixed span of clock time, measured from each sample's bar opening time to the current bar's opening time.

• Whole history: everything since the first bar.
• Anchored: everything since the most recent reset bar (new day, new session, your own event).
• Last N samples: count-based.
• Last N bars: bar-based, with a minimum-sample guard.
• Rolling time: a span in milliseconds, with a minimum-sample guard.

• I want one running average of everything that qualifies: gatedMean()
• I want an average that restarts each day, session or event: gatedMeanSince()
• I want the average of the most recent N qualifying bars: gatedMeanLast()
• I want the average of qualifying bars inside the last N bars: gatedMeanInBars()
• I want a smoothed average of qualifying bars (EMA, RMA, WMA...): gatedMa()
• I want a total over the last hour, day or week: gatedSumTime()
• I want an average over the last hour, day or week: gatedMeanTime()
• I want to count events per hour, day or week: gatedCountTime()
• I want a VWAP and standard deviation over a rolling time span: gatedVwapTime()

• source: values to average.
• gate: optional, default true. Only bars where this is true are sampled.
• Returns: the mean, or na until the first sampled bar.
• Memory: constant. Keeps only a running total and a count.
• Use for: long-run baselines, such as the lifetime average volume of up bars.

• source: values to average.
• reset: true restarts the average on that bar.
• Returns: the mean, or na before the first reset (and while no non-na value has arrived since it).
• Memory: constant.
• Use for: session-anchored or day-anchored averages. Example: reset = timeframe.change("D").

• source: values to average.
• gate: only bars where this is true are sampled.
• count: number of sampled values to average.
• Returns: the mean, or na until count samples exist, or if count is below 1.
• Memory: stores up to count samples.
• Use for: "average of the last 20 up bars", "mean of the last 50 breakouts". Because the window is count-based, it can reach far back on rare events.

• source: values to average.
• gate: only bars where this is true are sampled.
• length: window size, in bars.
• minSamples: optional, default 1. Minimum sampled bars the window must hold.
• Returns: the mean, or na while the window holds fewer than minSamples sampled bars.
• Memory: none beyond Pine's own rolling sums. No arrays.
• Use for: "average volume on up bars over the last 20 bars, but only if at least 5 of them were up bars".

• source: values to average.
• gate: only bars where this is true are sampled.
• length: number of samples in the average, or the smoothing period for ema and rma. Ignored by swma, which always uses 4 samples.
• maType: optional, default MaType.ema. See the MaType section.
• weight: optional, default volume. Weights for vwma. Ignored by all other types.
• Returns: the moving average, or na until enough samples exist (length, or 4 for swma).
• Seeding: ema and rma are seeded with the SMA of the first length samples, then continue recursively. This matches the standard seeding convention and avoids a long warm-up skew.
• Memory: stores up to length samples (and their weights).

• source: values to sum.
• ms: window span in milliseconds.
• gate: optional, default true.
• minBars: optional, default 1. Minimum samples to retain regardless of age.
• Returns: the sum, or na while fewer than minBars samples exist. With minBars = 0 an empty window returns 0.
• Use for: rolling traded volume over the last hour or day, rolling P&L-style sums, rolling range totals.

• source, ms, gate, minBars: as for gatedSumTime().
• Returns: the mean, or na while fewer than minBars samples exist.

• gate: the event to count.
• ms: window span in milliseconds.
• Returns: the number of true bars whose opening time is less than ms milliseconds before this bar. It returns 0 (not na) when there are none. The result is a float so it can be plotted directly.

vwap = sum(w * p) / sum(w), sd = sqrt(sum(w * (p - vwap)^2) / sum(w))

• price: price source, for example hlc3.
• weight: non-negative weights, for example volume.
• ms: window span in milliseconds.
• gate: optional, default true.
• minBars: optional, default 1.
• Returns: a tuple [vwap, standard deviation], or [na, na] while fewer than minBars samples exist or the total weight is zero.
• Cost: both passes loop over the window on every bar, so cost grows with the number of bars in the window.

• MaType.sma: simple. Equal-weighted mean of the last length samples.
• MaType.ema: exponential. Smoothing factor 2 / (length + 1).
• MaType.rma: Wilder's. Smoothing factor 1 / length.
• MaType.wma: linearly weighted. The newest sample has the largest weight.
• MaType.swma: symmetrically weighted over the last 4 samples (weights 1, 2, 2, 1). Ignores length.
• MaType.vwma: weighted by the weight argument (volume by default) over the last length samples.

• Windows use bar opening times, and a sample is evicted when it is at least ms old. A one-hour window therefore covers the half-open span (now - 1 hour, now], and always includes the current bar.
• Eviction runs on every bar, including bars where the gate is false, so a time window keeps sliding while the gate is inactive.
• Windows measure wall-clock time, not trading time. On a symbol with sessions, a 24-hour window on a 1-hour chart will include the overnight gap, so it may hold fewer samples than 24 bars. Use a count-based function if you need "the last N bars".
• ms is a simple int. It must be known on the first bar: use a literal, an input, or an expression built from constants and timeframe.in_seconds(). It cannot change from bar to bar.

• Array size: Pine arrays cannot hold more than 100,000 elements. The time-window functions store one entry per sample, so a window that would hold more than that many samples will produce a runtime error. This only matters for very long spans on very small timeframes (for example weeks of one-second bars). Shorten the span or raise the timeframe.
• gatedVwapTime() cost: it runs two passes over the whole window on every bar. For typical spans (minutes to a day) this is fine. For very large windows on low timeframes, expect noticeably longer calculation time.
• Constant-memory functions: gatedMean(), gatedMeanSince() and gatedMeanInBars() do not store arrays, so they are the cheapest choice when they fit your need.
• Execution budget: every call contributes to your script's loop and time limits. Use only the functions you need, and avoid duplicating identical calls: compute once, reuse the variable.
• History and warm-up: results are na until a window has enough samples. The amount of history needed depends on how rarely the gate is true.

• A volume histogram, colored by bar direction (teal for up bars, red for down bars, gray for flat bars).
• Whole-history and anchored lines: gatedMean() and gatedMeanSince() (reset each day).
• Count and bar windows: gatedMeanLast() for up and for down bars, and gatedMeanInBars().
• Moving averages: gatedMa() with a type selector in the script settings, and an SWMA line that always uses 4 samples.
• Time windows: gatedMeanTime() over one day.
• gatedSumTime() and gatedCountTime() plot at the top of the pane as characters, because their scale differs from volume and would stretch the price axis. Read their values in the Data Window.
• gatedVwapTime() draws on the main chart: a 30-minute VWAP, 1-hour VWAPs of highs and lows, and standard-deviation bands.