메뉴
Use when converting or porting code between MultiCharts PowerLanguage and Rust in either direction — Strategy trait scaffold, concept mapping tables, semantic differences, ta-rs indicators, conversion checklists.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
Use when converting or porting code between MultiCharts PowerLanguage and C++ in either direction — Strategy base-class scaffold, concept mapping tables, semantic differences, TA-Lib indicators, conversion checklists.
Use when converting or porting code between MultiCharts PowerLanguage and TradingView Pine Script in either direction — concept mapping tables, semantic differences, conversion checklists.
Use when converting or porting code between MultiCharts PowerLanguage and Python in either direction — Strategy ABC scaffold, concept mapping tables, semantic differences, pandas-ta/TA-Lib indicators, conversion checklists.
Use when orienting on the MultiCharts platform — choosing Indicator vs Signal vs Function, bar-close vs intra-bar-order-generation execution, multi-data references (data1, data2), Buy/Sell/SellShort/BuyToCover orders, and the unique-signal-name compile rule.
Use when writing Pine Script logic with built-in namespaces — ta.* (averages, oscillators, crossovers), strategy.* (orders, position info), request.* (multi-timeframe), math.*, str.*, array.*, color.*, bar state, symbol info.
Use when writing or reading Pine Script language fundamentals — @version, script types (indicator/strategy/library), type system (series/simple/const), var/varip/input.*, control flow, user-defined functions/types, gotchas (repainting, na handling, max_bars_back).
SOC 직업 분류 기준
| name | powerlanguage-rust-conversion |
| description | Use when converting or porting code between MultiCharts PowerLanguage and Rust in either direction — Strategy trait scaffold, concept mapping tables, semantic differences, ta-rs indicators, conversion checklists. |
This skill covers the structural and semantic differences between MultiCharts PowerLanguage and Rust for algorithmic trading. It does not duplicate the syntax rules of PowerLanguage — for declarations, bar references, control flow, and built-in function signatures use the powerlanguage-syntax skill. When performing a conversion in either direction, work through Part 0 (structural template) to set up the boilerplate, then Part 1 (concept mapping) for line-by-line translation, then review Part 2 (semantic differences and gotchas), and finally run through the relevant checklist in Part 3 before calling the output complete.
PowerLanguage runs the entire script top-to-bottom on each bar close automatically. Rust has no implicit bar loop, no built-in OHLCV type, and no order submission mechanism. Every PL-to-Rust conversion targets the framework-agnostic scaffold below.
#[derive(Debug, Clone, Copy)]
pub struct Bar {
pub open: f64,
pub high: f64,
pub low: f64,
pub close: f64,
pub volume: f64,
pub time: i64, // Unix epoch seconds
pub bar_number: usize, // 1-based to match PL convention
}
#[derive(Debug, Clone)]
pub enum Side { Long, Short }
#[derive(Debug, Clone)]
pub enum OrderType {
Market,
Limit(f64),
Stop(f64),
}
#[derive(Debug, Clone)]
pub struct Order {
pub label: String,
pub side: Side,
pub order_type: OrderType,
pub qty: f64,
}
pub trait Strategy {
fn on_bar(&mut self, bars: &[Bar], orders: &mut Vec<Order>);
}
use ta::indicators::{SimpleMovingAverage, RelativeStrengthIndex};
use ta::Next;
pub struct MyStrategy {
// Inputs (PL: Inputs: Length(20))
length: usize,
// Variables (PL: Variables: my_var(0))
my_var: f64,
// Indicators — create once, call .next() per bar
sma: SimpleMovingAverage,
// Position state (PL: MarketPosition, EntryPrice, etc.)
position: i32, // -1, 0, +1
entry_price: f64,
bars_since_entry: usize,
current_contracts: f64,
}
fn main() {
let bars: Vec<Bar> = load_bars("data.csv"); // user-provided
let mut strategy = MyStrategy::new(/* inputs */);
let mut orders = Vec::new();
for i in 0..bars.len() {
orders.clear();
strategy.on_bar(&bars[..=i], &mut orders);
// execute orders against simulated book...
}
}
The slice &bars[..=i] gives the strategy access to full history; bars.last().unwrap() is the current bar. This mirrors PL's implicit bar-by-bar execution.
| PowerLanguage | Rust | Notes |
|---|---|---|
Inputs: Length(20) | length: usize field + constructor param | Inputs become immutable struct fields set at construction |
Variables: myVar(0) | my_var: f64 field (initialized in new()) | Mutable struct fields; set initial value in the constructor |
Value1 .. Value99 | named field (e.g., rsi_val: f64) | Must rename to meaningful identifiers; Rust has no pre-declared variables |
Condition1 .. Condition99 | named field (e.g., is_oversold: bool) | Same: rename to typed bool fields |
Arrays: buf[10](0) | buf: [f64; 11] or Vec<f64> | PL [10] means last index is 10 (11 elements); use [0.0; 11] for fixed or vec![0.0; 11] for heap |
IntraBarPersist myVar(0) | my_var: f64 field (same as Variables) | Rust has no bar-close vs intra-bar distinction; all struct fields persist across calls |
| PowerLanguage | Rust | Notes |
|---|---|---|
Open, High, Low, Close, Volume | bar.open, bar.high, bar.low, bar.close, bar.volume | let bar = bars.last().unwrap(); for current bar |
Close[1] | bars[bars.len() - 2].close | Lookback N: bars[bars.len() - 1 - n].close. Guard with bars.len() > n to avoid panic. |
Close of Data2 | separate bars2: &[Bar] parameter or struct field | PL Data2 is a second chart feed; pass a second bar slice to on_bar() |
Date | chrono::DateTime::from_timestamp(bar.time, 0).unwrap().naive_utc() | PL Date is YYYMMDD integer (YYY = years since 1900, e.g., 2024 = 124); Rust uses the chrono crate |
Time | chrono::DateTime::from_timestamp(bar.time, 0).unwrap().naive_utc().time() | PL Time is HHMM integer; extract hour/minute from timestamp |
BarNumber / CurrentBar | bar.bar_number or i + 1 (loop index) | PL is 1-based; if using loop index i, add 1 |
| PowerLanguage | Rust (ta-rs) | Notes |
|---|---|---|
Average(Close, Length) | SimpleMovingAverage::new(length).unwrap() → .next(bar.close) | Create once in new(), call next() in on_bar() |
XAverage(Close, Length) | ExponentialMovingAverage::new(length).unwrap() → .next(bar.close) | Same streaming pattern |
RSI(Close, Length) | RelativeStrengthIndex::new(length).unwrap() → .next(bar.close) | Returns 0–100 range matching PL |
Stochastic(...) | SlowStochastic::new(k_period, d_period).unwrap() → .next(&data_item) | Accepts f64 but needs OHLC DataItem for correct stochastic formula; PL takes 11 params — map k_period and d_period |
ADX(Length) | Not in ta-rs; use yata::indicators::ADX or implement manually | ta-rs lacks ADX; yata crate covers it |
CCI(Length) | CommodityChannelIndex::new(length).unwrap() → .next(&data_item) | PL CCI takes only length (uses HLC internally); ta-rs requires a type implementing Close + High + Low |
AvgTrueRange(Length) | TrueRange::new() → .next(&data_item), feed each value into SimpleMovingAverage::new(length) | PL AvgTrueRange is a SIMPLE average of TrueRange. ta-rs AverageTrueRange is EMA-based — NOT equivalent; the smoothed (Wilder-style) PL match is SmoothedAverage(TrueRange, Len). Needs OHLC DataItem for correct true range |
BollingerBand(Close, Length, 2) | BollingerBands::new(length, 2.0).unwrap() → .next(bar.close) | Returns BollingerBandsOutput { average, upper, lower }. Note: ta-rs may use EMA internally — verify output matches PL's SMA-based Bollinger Bands |
Close Crosses Over MA | prev_close <= prev_ma && close > ma | No built-in crossover in ta-rs; store previous-bar values yourself |
Close Crosses Under MA | prev_close >= prev_ma && close < ma | Same pattern, reversed inequality |
Highest(Close, Length) | Maximum::new(length).unwrap() → .next(bar.close) | ta-rs Maximum indicator |
Lowest(Close, Length) | Minimum::new(length).unwrap() → .next(bar.close) | ta-rs Minimum indicator |
Momentum(Close, Length) | close - bars[bars.len() - 1 - length].close | No ta-rs built-in; compute directly from bar slice. Guard with bars.len() > length. |
TSI(Close, LongLen, ShortLen) | Manual: double-EMA of momentum / double-EMA of abs(momentum) | No ta-rs built-in; use two nested ExponentialMovingAverage pairs — one for EMA(EMA(mtm, long), short), one for EMA(EMA(abs(mtm), long), short), then 100 * ratio |
AverageFC(Close, Length) | SimpleMovingAverage::new(length).unwrap() → .next(bar.close) | FC = "fast calculation": AverageFC = SummationFC/Len (running-sum SMA), numerically identical to Average — use SimpleMovingAverage |
WAverage(Close, Length) | Manual: weighted sum Σ(close[i] * (length - i)) / Σ(1..=length) | No ta-rs built-in; iterate bars[len-length..len], weight newest bar highest |
AdaptiveMovAvg(Close, Length) | EfficiencyRatio::new(length) + manual AMA smoothing | Use ta-rs EfficiencyRatio; smoothing constant sc = (er * (fast_sc - slow_sc) + slow_sc)^2 with fast_sc = 2/(2+1), slow_sc = 2/(30+1), then AMA = prev + sc * (close - prev) (Kaufman formula — NOT er^2) |
MidPoint(Close, Length) | (Maximum::new(length).next(c) + Minimum::new(length).next(c)) / 2.0 | Combine ta-rs Maximum and Minimum |
MACD(Close, FastLen, SlowLen) | ta::indicators::MovingAverageConvergenceDivergence::new(fast, slow, signal).unwrap() → .next(bar.close) | Returns MACDOutput { macd, signal, histogram } |
KeltnerChannel(Close, Length, Factor) | KeltnerChannel::new(length, factor).unwrap() → .next(&data_item) | Returns KeltnerChannelOutput { average, upper, lower }; needs OHLC DataItem |
DMIPlus(Length) | Manual or yata; +DI = 100 × smoothed(+DM) / smoothed(TR) | Not in ta-rs; compute +DM = max(high - prev_high, 0) when > −DM, else 0 |
DMIMinus(Length) | Manual or yata; −DI = 100 × smoothed(−DM) / smoothed(TR) | Not in ta-rs; compute −DM = max(prev_low - low, 0) when > +DM, else 0 |
RateOfChange(Close, Length) | RateOfChange::new(length).unwrap() → .next(bar.close) | ta-rs RateOfChange; returns percentage change |
PercentR(Length) | Manual: 100 × (close − lowest) / (highest − lowest) | PL PercentR is POSITIVE 0..100 (= Williams %R + 100; thresholds 80/20). Use ta-rs Maximum/Minimum over length bars for highest-high/lowest-low |
MoneyFlow(Length) | Manual: MFI = 100 − 100/(1 + pos_flow/neg_flow) | Classify each bar's typical-price × volume as positive or negative, sum over length |
Parabolic(AFStep, AFMax) | Manual state machine tracking AF and EP | No crate built-in; maintain af, ep, sar, flip on new extreme; complex — ~40 lines |
Volatility(Length) | TrueRange::new() → .next(&data_item), feed each value into ExponentialMovingAverage::new(length) | PL Volatility is a smoothed average of TrueRange weighted toward the most recent bar — NOT a standard deviation of closes (that is StandardDev) |
UltimateOscillator(Fast, Mid, Slow) | Manual: weighted average of BP/TR ratios over three periods | BP = close − min(low, prev_close); sum BP and TR over 7/14/28, weight 4:2:1 |
ChaikinOsc(FastLen, SlowLen) | Manual: EMA(fast, ADL) − EMA(slow, ADL) | ADL = cum sum of ((close−low)−(high−close))/(high−low) × volume; apply two EMAs |
PriceOscillator(FastLen, SlowLen) | Manual: EMA(fast) − EMA(slow) | Two ExponentialMovingAverage instances; subtract slow from fast |
DirMovement(Length, oADX, oDIP, oDIM) | Manual or yata: computes ADX, +DI, −DI together | Multi-output; return a struct { adx, di_plus, di_minus } |
Extremes(Length, oHi, oHiBar, oLo, oLoBar) | Manual: scan bars[len-length..len] for max/min and their offsets | Multi-output; return { highest, highest_bar, lowest, lowest_bar } |
TrueRange | TrueRange::new() → .next(&data_item) | ta-rs TrueRange; needs OHLC DataItem |
StandardDev(Close, Length) | StandardDeviation::new(length).unwrap() → .next(bar.close) | ta-rs StandardDeviation |
TrueHigh | Manual: bar.high.max(prev_bar.close) | Max of current high and previous close; guard bars.len() > 1 |
TrueLow | Manual: bar.low.min(prev_bar.close) | Min of current low and previous close; guard bars.len() > 1 |
Range | Manual: bar.high - bar.low | Current bar's high minus low |
HighestBar(Close, Length) | Manual: index of max in bars[len-length..len] | Returns bars-ago offset (0 = current bar); scan with enumerate() + max_by() |
LowestBar(Close, Length) | Manual: index of min in bars[len-length..len] | Returns bars-ago offset; scan with enumerate() + min_by() |
NthHighest(N, Close, Length) | Manual: sort last length closes descending, take index N-1 | Collect into Vec, sort_by() descending, return [n-1] |
NthLowest(N, Close, Length) | Manual: sort last length closes ascending, take index N-1 | Collect into Vec, sort_by() ascending, return [n-1] |
NthHighestBar(N, Close, Length) | Manual: sort with indices, return bars-ago of Nth highest | Pair (value, offset), sort descending, return offset at N-1 |
NthLowestBar(N, Close, Length) | Manual: sort with indices, return bars-ago of Nth lowest | Pair (value, offset), sort ascending, return offset at N-1 |
SwingHigh(Occur, Price, Strength, Length) | Manual: bars[pivot] > all Strength bars on each side, scanning the last Length bars | Occurrence is the FIRST PL arg (Occur selects Nth most recent swing); returns −1 when none found; Length must exceed Strength; confirmed only after Strength bars pass |
SwingLow(Occur, Price, Strength, Length) | Manual: bars[pivot] < all Strength bars on each side, scanning the last Length bars | Same pivot logic, reversed comparison; −1 when none found |
SwingHighBar(Occur, Price, Strength, Length) | Manual: bars-ago offset of the detected swing high | Same detection as SwingHigh; return bars.len() - 1 - pivot_index |
SwingLowBar(Occur, Price, Strength, Length) | Manual: bars-ago offset of the detected swing low | Same detection as SwingLow; return offset |
Summation(Close, Length) | Manual: bars[len-length..len].iter().map(|b| b.close).sum::<f64>() | Rolling sum over last length bars |
Cum(Close) | Manual: self.cum_val += bar.close; | Cumulative sum from bar 1; store running total in struct field |
LinearRegValue(Close, Length, Offset) | Manual: least-squares fit over length bars, evaluate at Offset | Compute slope/intercept via Σxy, Σx²; project forward by Offset bars |
LinearRegAngle(Close, Length) | Manual: slope.atan().to_degrees() | Angle in degrees of the regression line slope |
LinearRegSlope(Close, Length) | Manual: (n*Σxy − Σx*Σy) / (n*Σx² − (Σx)²) | Standard least-squares slope formula over length bars |
Correlation(Close1, Close2, Length) | Manual: Pearson r over length bars | r = (nΣxy − ΣxΣy) / sqrt((nΣx²−(Σx)²)(nΣy²−(Σy)²)) |
RSquared(Close, Length) | Manual: correlation(close, 1..=length)² | R² of close vs bar index; square the Pearson r |
StdError(Close, Length) | Manual: std error of estimate around regression line | sqrt(Σ(close − predicted)² / (length − 2)) |
Median(Close, Length) | Manual: collect last length values, sort, pick middle | let mut v: Vec<f64> = ...; v.sort_by(|a,b| a.partial_cmp(b).unwrap()); v[length/2] |
ELDate(dt) | NaiveDate::from_ymd_opt(year, month, day) (chrono crate) | PL returns YYYMMDD integer (YYY = year − 1900); Rust uses chrono::NaiveDate |
MinutesToTime(mins) | Manual: let hhmm = (mins / 60) * 100 + mins % 60; | PL returns HHMM integer; Rust can also use NaiveTime::from_hms_opt(h, m, 0) |
TimeToMinutes(hhmm) | Manual: let mins = (hhmm / 100) * 60 + hhmm % 100; | Inverse of MinutesToTime; converts HHMM integer to total minutes |
AvgPrice | Manual: (bar.open + bar.high + bar.low + bar.close) / 4.0 | Average of OHLC |
MedianPrice | Manual: (bar.high + bar.low) / 2.0 | Midpoint of high and low |
TypicalPrice | Manual: (bar.high + bar.low + bar.close) / 3.0 | HLC average |
WeightedClose | Manual: (bar.high + bar.low + bar.close * 2.0) / 4.0 | Close-weighted HLC |
CountIF(Cond, Length) | Manual: bars[len-length..len].iter().filter(|b| cond(b)).count() | Count bars satisfying condition over last length bars |
MRO(Cond, Length, Instance) | Manual: scan backward from current bar for Instance-th true | Returns bars-ago offset; iterate (1..=length).rev(), decrement instance counter on match |
AccumDist | Manual: self.ad += ((close−low)−(high−close))/(high−low) * volume | Cumulative; guard division by zero when high == low |
IFF(Cond, TrueVal, FalseVal) | if cond { true_val } else { false_val } | Direct Rust if/else expression; returns a value |
TriAverage(Close, Length) | Manual: two SimpleMovingAverage instances of HALVED length (length + 2) / 2 (= ceil((Length+1)*0.5)) | Triangular MA = SMA of SMA with the halved length, not the full length applied twice; feed output of first into second |
FastK(StochLength) | Manual: (close - min) / (max - min) * 100 using Minimum/Maximum | Raw %K from default H/L/C; no ta-rs helper |
FastD(StochLength) | Manual: SimpleMovingAverage::new(3) applied to FastK values | Smoothed Fast %K |
SlowK(StochLength) | SlowStochastic::new(StochLength, 3).unwrap() → .next(&data_item) | Same as SlowStochastic output |
SlowD(StochLength) | Manual: SimpleMovingAverage::new(3) applied to SlowK values | Double-smoothed |
FastKCustom(H, L, C, StochLen) | Manual: (c - lowest_l) / (highest_h - lowest_l) * 100 | Custom prices; use Maximum/Minimum on custom series |
FastDCustom(H, L, C, StochLen) | Manual: SMA(3) of FastKCustom | Same pattern |
SlowKCustom(H, L, C, StochLen) | Manual: SMA(3) of FastKCustom | Same as FastDCustom |
SlowDCustom(H, L, C, StochLen) | Manual: SMA(3) of FastKCustom | Slow %D with custom prices |
StochasticExp(H, L, C, StochLen, S1, S2, ...) | Manual: EMA smoothing of FastKCustom | Use ExponentialMovingAverage instead of SMA for smoothing |
ADXR(Length) | Manual: (adx + adx_n_bars_ago) / 2.0 | Store ADX history; average current with N-bar-ago value |
ADXCustom(H, L, C, Length) | Manual or yata::indicators::ADX with custom prices | Same as ADX but with custom H/L/C inputs |
DMI(Length) | Manual or yata; same as ADX | Wrapper; same computation |
DMIPlusCustom(H, L, C, Length) | Manual: +DI using custom highs/lows | Compute +DM from custom price series |
DMIMinusCustom(H, L, C, Length) | Manual: −DI using custom highs/lows | Compute −DM from custom price series |
ParabolicCustom(AfStep, AfLimit) | Manual SAR state machine with custom limit | Same as Parabolic but cap AF at AfLimit |
TRIX(Close, Length) | Manual: ROC of triple ExponentialMovingAverage | Three nested EMA, then (ema3 - prev_ema3) / prev_ema3 * 100 |
MassIndex(SmoothLen, SumLen) | Manual: sum of EMA(H-L) / EMA(EMA(H-L)) over SumLen | Two nested EMAs, compute ratio, rolling sum |
EaseOfMovement | Manual: ((h + l) / 2 - (prev_h + prev_l) / 2) / (volume / (h - l)) | No crate built-in; uses current + previous bar |
SwingIndex | Manual: Wilder swing index formula using OHLC | Complex ~20-line formula with limit move |
AccumSwingIndex | Manual: self.accum_si += swing_index | Running cumulative sum of SwingIndex |
Detrend(Close, Length) | Manual: close - sma_value_offset | SMA offset by Length/2 bars |
PercentChange(Close, Length) | Manual: (close - bars[len-1-length].close) / bars[len-1-length].close * 100.0 | Simple percent change formula |
UlcerIndex(Close, Length) | Manual: (sum_of_squared_drawdown_pct / length).sqrt() | Track highest close in window, compute drawdown pct |
ParabolicSAR(AfStep, AfLimit, ...) | Manual SAR with direction/transition tracking | Extend SAR state machine to track position changes |
LinearReg(Close, Length, TgtBar, ...) | Manual: least-squares returning (value, slope, angle, intercept) | Full regression output as struct |
TrueRangeCustom(H, L, C) | Manual: (h - l).max((h - prev_c).abs()).max((l - prev_c).abs()) | Same formula as TrueRange with custom prices |
VolatilityStdDev(NumDays) | Manual: stdev of log returns × (252.0_f64).sqrt() | Annualized historical volatility |
StandardDevAnnual(Close, Length, DataType) | Manual: StandardDeviation::new(length).next(close) * (252.0_f64).sqrt() | Annualize the ta-rs StandardDeviation output |
HighestFC(Close, Length) | Maximum::new(length).unwrap() → .next(bar.close) | Same as Highest; ta-rs Maximum |
LowestFC(Close, Length) | Minimum::new(length).unwrap() → .next(bar.close) | Same as Lowest; ta-rs Minimum |
PivotHighVS(Inst, Price, LStr, RStr, Len) | Manual: scan for bar higher than LStr bars left and RStr bars right | Asymmetric left/right strength; return price or -1.0 |
PivotLowVS(Inst, Price, LStr, RStr, Len) | Manual: scan for bar lower than LStr bars left and RStr bars right | Same pattern for lows |
PivotHighVSBar(Inst, Price, LStr, RStr, Len) | Manual: bars-ago offset of pivot high | Same detection, return bars.len() - 1 - pivot_index |
PivotLowVSBar(Inst, Price, LStr, RStr, Len) | Manual: bars-ago offset of pivot low | Same detection, return offset |
Divergence(P1, P2, Str, Len, HiLo) | Manual: compare pivot highs/lows of price vs indicator | Return 1 if divergence found between two series |
TimeSeriesForecast(Close, Length) | Manual: linear_reg_value + slope | Uses same slope/intercept as LinearRegValue |
SummationFC(Close, Length) | Manual: bars[len-length..len].iter().map(|b| b.close).sum::<f64>() | Same as Summation; fast calc variant |
OpenD(N) | Manual: aggregate bars into daily periods, return daily_bars[daily_bars.len()-1-N].open | Requires daily bar aggregation from intraday data |
HighD(N) | Manual: daily_bars[..].high | Aggregate highs per day |
LowD(N) | Manual: daily_bars[..].low | Aggregate lows per day |
CloseD(N) | Manual: daily_bars[..].close | Last close per day |
OpenW(N) | Manual: aggregate to weekly | Same pattern, weekly periods |
HighW(N) | Manual: aggregate to weekly | Weekly high |
LowW(N) | Manual: aggregate to weekly | Weekly low |
CloseW(N) | Manual: aggregate to weekly | Weekly close |
OpenM(N) | Manual: aggregate to monthly | Monthly open |
HighM(N) | Manual: aggregate to monthly | Monthly high |
LowM(N) | Manual: aggregate to monthly | Monthly low |
CloseM(N) | Manual: aggregate to monthly | Monthly close |
OpenY(N) | Manual: aggregate to yearly | Yearly open |
HighY(N) | Manual: aggregate to yearly | Yearly high |
LowY(N) | Manual: aggregate to yearly | Yearly low |
CloseY(N) | Manual: aggregate to yearly | Yearly close |
LRO(Cond, Length, N) | Manual: scan from length bars ago forward, find Nth true | Least recent occurrence; returns bars-ago offset |
SummationIf(Cond, Price, Length) | Manual: sum price over last length bars where cond is true | Conditional rolling sum |
IFFString(Cond, TrueStr, FalseStr) | if cond { true_str.to_string() } else { false_str.to_string() } | Rust if expression returning String |
OBV | Manual: self.obv += if close > prev_close { vol } else if close < prev_close { -vol } else { 0.0 } | On Balance Volume; running total |
VolumeROC(Length) | RateOfChange::new(length).unwrap() → .next(bar.volume) | ta-rs RateOfChange on volume |
VolumeOsc(ShortLen, LongLen) | Manual: SMA(volume, short) - SMA(volume, long) | Two SimpleMovingAverage on volume, subtract |
PriceVolTrend | Manual: self.pvt += (close - prev_close) / prev_close * volume | Cumulative price-volume trend |
LWAccDis | Manual: self.lwad += (close - open) / (high - low) * volume | Larry Williams A/D; running total |
Fisher(Price) | Manual: normalize to −0.999..0.999, then 0.5 * ((1.0 + norm) / (1.0 - norm)).ln() | Fisher transformation |
FisherINV(Price) | Manual: ((2.0 * price).exp() - 1.0) / ((2.0 * price).exp() + 1.0) | Inverse Fisher |
C_Doji(Pct) | Manual: (close - open).abs() <= (high - low) * pct / 100.0 | Doji detection |
C_Hammer_HangingMan(Len, Factor, ...) | Manual: check body/shadow ratios | Lower shadow ≥ 2× body |
C_BullEng_BearEng(Len, ...) | Manual: current body engulfs previous | Compare current and previous OHLC |
C_BullHar_BearHar(Len, ...) | Manual: current body inside previous | Opposite of engulfing |
C_MornDoji_EveDoji(Len, Pct, ...) | Manual: 3-bar pattern with middle doji | Check 3 consecutive bars |
C_MornStar_EveStar(Len, ...) | Manual: 3-bar reversal | Down-small-up or up-small-down |
C_PierceLine_DkCloud(Len, ...) | Manual: 2-bar piercing pattern | Gap + close past midpoint |
C_ShootingStar(Len, Factor) | Manual: small body, long upper shadow | Upper shadow ≥ 2× body |
C_3WhSolds_3BlkCrows(Len, Factor, ...) | Manual: 3 consecutive trend bars | Three ascending or descending closes |
| Statistical extended | ||
AvgDeviation(Close, N) | Manual: mean absolute deviation over window | MAD |
Variance(Close, N) | Manual: sum((x - mean)^2) / N | Population variance |
Kurtosis(Close, N) | Manual: 4th moment calculation | Excess kurtosis |
Skew(Close, N) | Manual: 3rd moment calculation | Skewness |
PercentRank(ValToRank, Price, N) | Manual: count values ≤ target / N | Percent rank |
Covariance(P1, P2, N) | Manual: sum((P1-mean1)*(P2-mean2)) / N | Covariance |
Quartile(Close, N, Q) | Manual: sort window, pick percentile | Quartile value |
TrimMean(Close, N, Pct) | Manual: sort, trim edges, average | Trimmed mean |
Mode(Close, N, Type) | Manual: frequency count over window | Modal value |
HarmonicMean(Close, N) | Manual: N / sum(1/x) | Harmonic mean |
| Moving averages extended | ||
SmoothedAverage(Close, N) | Manual: Wilder smoothing prev*(N-1)/N + val/N | Same as RMA |
| Miscellaneous | ||
BarAnnualization | Manual: compute from bar frequency | Bars-per-year factor |
LastBarOnChart | bar_index == data.len() - 1 | True on last bar |
| Custom functions | ||
StochRSI(Close, N, M) | Manual: compute RSI, then (rsi - lowest(rsi, M)) / (highest(rsi, M) - lowest(rsi, M)) | Stochastic RSI |
supertrend(N, Mult) | Manual: ATR bands + direction flip logic | Supertrend |
NVI(Start) | Manual: accumulate on volume-down bars | Negative Volume Index |
PVI(Start) | Manual: accumulate on volume-up bars | Positive Volume Index |
Coppo(N1, N2, N3) | Manual: WMA of two ROC periods | Coppock Curve |
LWTI(Close, P, N) | Manual: (sma(diff, N) / sma(range, N)) * 50 + 50 | Larry Williams TI |
TVI(Close, Vol, Tick) | Manual: cumulative directional volume | Trade Volume Index |
SharpeRatio(Period, Rate, Calc, Cap) | Manual: (avg_return - rf) / std_return | Portfolio Sharpe |
WRSI(N, Close) | Manual: Wilder smoothing RSI (same formula as standard RSI) | Wilder RSI |
NewMA(Close, N) | Manual: Heikin-Ashi + triple EMA hybrid | Hybrid MA |
| PowerLanguage | Rust | Notes |
|---|---|---|
Buy("label") next bar market | orders.push(Order { label: "label".into(), side: Side::Long, order_type: OrderType::Market, qty: 1.0 }) | Push to the orders vec |
SellShort("label") next bar market | Order { side: Side::Short, order_type: OrderType::Market, .. } | Side::Short for short entry |
Sell("label") next bar market | Close long: set self.position = 0 or push a close-position variant | WARNING: PL Sell exits a long — do NOT map to Side::Short |
BuyToCover("label") next bar market | Close short: set self.position = 0 | PL BuyToCover exits an existing short |
Buy("label") next bar at price limit | Order { order_type: OrderType::Limit(price), .. } | Use the Limit variant |
Buy("label") next bar at price stop | Order { order_type: OrderType::Stop(price), .. } | Use the Stop variant |
SetStopLoss(dollars) | stop_price = entry_price - dollars / (qty * point_value) | PL takes a dollar amount; Rust must convert to price level |
SetProfitTarget(dollars) | target_price = entry_price + dollars / (qty * point_value) | Same dollar-to-price conversion |
| PowerLanguage | Rust | Notes |
|---|---|---|
Plot1(value, "label") | println!("{}: {}", label, value) or log to file | No chart in Rust; output to stdout, log crate, or a results Vec |
SetPlotColor(1, Red) | N/A | No visual output; skip or store as metadata |
SetPlotWidth(1, 2) | N/A | Skip |
NoPlot(1) | skip output for that bar | Conditional: don't push to results |
| PowerLanguage | Rust | Notes |
|---|---|---|
If cond Then Begin ... End; | if cond { ... } | Direct mapping |
If cond Then ... Else ... | if cond { ... } else { ... } | Direct mapping |
For idx = 1 to n Begin ... End; | for i in 1..=n { ... } | PL For is inclusive; Rust ..= is inclusive. PL side uses idx because i is reserved (alias for OpenInterest) |
While cond Begin ... End; | while cond { ... } | Direct mapping |
Switch (expr) Begin Case 1: ... End; | match expr { 1 => { ... }, _ => {} } | Rust match requires exhaustive arms; add _ => {} default; PL empty case body is a compile error — use Value1 = Value1; as no-op |
Once Begin ... End; | if self.first_bar { ... self.first_bar = false; } | Use a bool field; PL Once runs on first bar only |
| PowerLanguage | Rust | Notes |
|---|---|---|
MarketPosition | self.position (i32: −1/0/+1) | Track manually; update on order fills |
EntryPrice | self.entry_price (f64) | Track manually; set when position opens |
CurrentContracts | self.current_contracts (f64) | Track manually; absolute contract count |
BarsSinceEntry | self.bars_since_entry (usize) | Increment each bar while position != 0; reset on new entry |
Print("text") | println!("text") or log::info!("text") | Use the log crate for structured logging |
#BeginCmtry ... #EndCmtry | No equivalent | PL expert commentary; skip or log |
Alert("msg") | eprintln!("ALERT: msg") or custom callback | No built-in alert mechanism |
PL Buy next bar at market fills at the NEXT bar's OPEN, and next bar at X Stop / Limit fills intrabar on the next bar at the stop/limit price (or at the open if the bar gaps through it). A converted simulator that flips position on the signal bar (same-bar close fill) is one bar early and uses the wrong price.
The executor must queue orders produced on bar N and fill them against bar N+1:
for i in 0..bars.len() - 1 {
orders.clear();
strategy.on_bar(&bars[..=i], &mut orders); // orders queued on bar i...
let next = &bars[i + 1];
for order in &orders { // ...filled on bar i+1
match order.order_type {
OrderType::Market => fill(order, next.open), // next bar's OPEN
OrderType::Stop(p) if next.high >= p => // buy stop
fill(order, p.max(next.open)), // intrabar at the stop price
_ => {} // sell stop: next.low <= p; limit orders mirror with reversed comparisons
}
}
}
EMA seeding/warmup gotcha: PL XAverage seeds recursively from the first bar's price; ta-rs ExponentialMovingAverage also seeds with the first value, so the two match — but pandas-ta (SMA seed by default), TA-Lib (SMA-of-first-Length seed), and Pine (na during warmup) all differ. Early-history signals diverge across targets — discard roughly the first 3×Length bars before comparing backtests.
Sell does not mean "go short". In PowerLanguage, Sell exits an existing long position. The Rust equivalent is closing the position (setting position to 0 and recording the exit). Do not create a new short entry as a translation of Sell.
PL is implicitly bar-driven; Rust requires an explicit loop. PowerLanguage executes the entire script top-to-bottom on each bar close automatically. In Rust, you must write the for i in 0..bars.len() loop yourself and call on_bar() on each iteration. Forgetting the loop wrapper means the strategy logic runs only once.
Bar lookback can panic on insufficient history. PL uses MaxBarsBack to prevent execution on bars with insufficient history — the script simply does not run on those early bars. Rust bars[bars.len() - 6] will panic with an index-out-of-bounds error. Always guard lookback access with if bars.len() > n before indexing. When the guard fails, either skip the bar with an early return (matching PL's MaxBarsBack behavior) or use a default value.
ta-rs indicators are stateful and must be created once. Each ta-rs indicator (SMA, EMA, RSI, etc.) maintains internal state via its struct. Create the indicator in new() and call .next() on each bar. Creating a new indicator inside on_bar() resets the calculation and produces wrong values.
Some ta-rs indicators need OHLC data for correct results. ATR, Stochastic, and CCI all accept plain f64 via Next<f64>, but passing only close prices produces incorrect values — ATR needs high-low range, Stochastic needs high/low/close, CCI needs typical price. Pass a DataItem (via ta::DataItem::builder().open(o).high(h).low(l).close(c).volume(v).build().unwrap()) or implement the High + Low + Close traits on your Bar struct.
Crossover/crossunder has no built-in. PL Crosses Over / Crosses Under are language keywords. ta-rs has no crossover function. Implement as: let crossed_over = prev_a <= prev_b && a > b;. You must store previous-bar values in struct fields.
Dollar amounts versus price levels for stops. SetStopLoss and SetProfitTarget in PL accept a dollar (currency) amount. Rust has no implicit conversion — you must compute the price level manually: stop_price = entry_price - stop_dollars / (qty * point_value).
Position state is not tracked automatically. PL provides MarketPosition, EntryPrice, CurrentContracts, and BarsSinceEntry as built-in read-only variables updated by the engine. In Rust, you must maintain these as struct fields and update them manually whenever the execution engine fills an order.
Rust has no Value1..Value99 or Condition1..Condition99. These PL pre-declared variables must be replaced with named, typed struct fields. Use descriptive identifiers like rsi_value: f64 and is_oversold: bool.
Multi-data series requires explicit design. PL Close of Data2 accesses a second feed bound to the chart. In Rust, you must pass a second bar slice (bars2: &[Bar]) to on_bar() or store it as a field. There is no implicit secondary-feed mechanism.
Ownership and borrowing affect indicator state. PL variables are global mutable state with no restrictions. In Rust, indicator structs are owned by the strategy and mutated via &mut self in on_bar(). If you try to pass &mut self.sma and &self simultaneously, you will hit borrow-checker errors. Extract the needed bar data into local variables before calling .next().
No Portfolio Money Management (PMM) equivalent. PL's PMM allows a single script to govern position sizing across multiple instruments. Rust has no built-in portfolio-level abstraction. You must implement cross-instrument logic as a separate orchestrator that calls individual strategy instances.
Floating-point equality differs. PL uses tolerance-based comparison for = on float values. Rust == on f64 is exact bitwise comparison. Converting PL If Close = 100 to if close == 100.0 may miss matches due to floating-point precision. Use an epsilon comparison: (close - 100.0).abs() < 1e-10.
Multiple Once blocks need separate booleans. PL supports multiple independent Once Begin ... End blocks in the same script, each executing exactly once. A single self.first_bar bool handles only one. If the PL source has N Once blocks, create N separate bool fields (e.g., once_header: bool, once_init: bool).
Inputs: declaration; note name, type, and default value — each becomes a struct field and constructor parameterVariables: declaration; note initial values — each becomes a mutable struct field initialized in new()Value1..Value99 and Condition1..Condition99 usages; plan meaningful replacement namesData2 / Data3 references; decide on multi-feed architecture (second parameter or struct field)SetStopLoss, SetProfitTarget, and dollar-based parameters; note the instrument's point valueIntraBarPersist variables; decide whether tick-level behavior needs replication.elf function calls; locate source and plan conversion to Rust functions or methodsSell order maps to closing the long position, not entering short — audit all order keywordsBuyToCover order maps to closing the short position, not entering longClose[N]) guarded with if bars.len() > n to prevent panicsnew(), not inside on_bar()DataItem (ATR, Stochastic) receive properly constructed DataItem, not raw f64Crosses Over / Crosses Under implemented as two-bar comparisons with stored previous valuesMarketPosition, EntryPrice, CurrentContracts, BarsSinceEntry tracked as manually updated struct fieldsValue1..Value99 and Condition1..Condition99 renamed to descriptive typed fieldscargo build with zero errors and zero warningsmatch expressions with complex patterns; plan PL Switch or If/Else chainMarketPosition, EntryPrice, etc.SellShort, not SellSell, not SellShortbars[bars.len() - 1 - n].close lookbacks converted to Close[n]Crosses Over / Crosses Under keywordsInputs:, mutable state → Variables:.next() calls replaced with PL function calls — PL handles indicator state internallySetStopLoss / SetProfitTarget