powerlanguage-cpp-conversion

name	powerlanguage-cpp-conversion
description	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.

PowerLanguage ↔ C++ Conversion

How to use

This skill covers the structural and semantic differences between MultiCharts PowerLanguage and C++ 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.

---

Part 0: Structural Template

PowerLanguage runs the entire script top-to-bottom on each bar close automatically. C++ has no implicit bar loop, no built-in OHLCV type, and no order submission mechanism. Every PL-to-C++ conversion targets the framework-agnostic scaffold below.

Bar struct

#include <cstdint>
#include <string>
#include <vector>

struct Bar {
    double open;
    double high;
    double low;
    double close;
    double volume;
    int64_t time;       // Unix epoch seconds
    size_t bar_number;  // 1-based to match PL convention
};

Order types

enum class Side { Long, Short };

enum class OrderType { Market, Limit, Stop };

struct Order {
    std::string label;
    Side side;
    OrderType type;
    double price;  // 0.0 for Market
    double qty;
};

Strategy base class

class Strategy {
public:
    virtual ~Strategy() = default;
    virtual void on_bar(const std::vector<Bar>& bars,
                        std::vector<Order>& orders) = 0;
};

Strategy subclass skeleton

#include "ta_libc.h"  // TA-Lib

class MyStrategy : public Strategy {
public:
    // Inputs (PL: Inputs: Length(20))
    MyStrategy(int length, double threshold)
        : length_(length), threshold_(threshold) {}

    void on_bar(const std::vector<Bar>& bars,
                std::vector<Order>& orders) override;

private:
    // Inputs (immutable after construction)
    int length_;
    double threshold_;

    // Variables (PL: Variables: my_var(0))
    double my_var_ = 0.0;

    // Position state (PL: MarketPosition, EntryPrice, etc.)
    int position_ = 0;           // -1, 0, +1
    double entry_price_ = 0.0;
    int bars_since_entry_ = 0;
    double current_contracts_ = 0.0;
};

TA-Lib call pattern

// Extract close prices into a contiguous array (TA-Lib needs parallel arrays)
std::vector<double> closes(bars.size());
for (size_t i = 0; i < bars.size(); ++i) closes[i] = bars[i].close;

// Batch API: compute SMA over the full close array
int outBeg = 0, outNBElement = 0;
std::vector<double> sma_out(bars.size());
TA_SMA(0, static_cast<int>(closes.size()) - 1,
       closes.data(), length_,
       &outBeg, &outNBElement, sma_out.data());

// Current bar's SMA is the LAST valid output element
double current_sma = sma_out[outNBElement - 1];

The output array is NOT aligned with the input array. The first valid output is at sma_out[0], which corresponds to closes[outBeg]. The current value is always sma_out[outNBElement - 1].

Main loop

int main() {
    std::vector<Bar> bars = load_bars("data.csv"); // user-provided
    MyStrategy strategy(20, 0.5);
    std::vector<Order> orders;

    for (size_t i = 0; i < bars.size(); ++i) {
        orders.clear();
        std::vector<Bar> history(bars.begin(), bars.begin() + i + 1);
        strategy.on_bar(history, orders);
        // execute orders against simulated book...
    }
    return 0;
}

The history vector up to and including bar i mirrors PL's implicit bar-by-bar execution. bars.back() inside on_bar() is the current bar.

Incremental alternative (TA-Lib RT)

TA-Lib RT is a community fork that adds streaming APIs: TA_SMA_StateInit(), TA_SMA_State(), TA_SMA_StateFree(). These maintain internal state across calls, avoiding full-array recomputation on each bar. Use TA-Lib RT when performance matters for large bar counts.

---

Part 1: Concept Mapping

Table 1 — Declarations

PowerLanguage	C++	Notes
Inputs: Length(20)	int length_ member + constructor param	Inputs become const or private members set at construction
Variables: myVar(0)	double my_var_ = 0.0 member	Mutable members; initialize in-class or in the constructor initializer list
Value1 .. Value99	named member (e.g., double rsi_val_ = 0.0)	Must rename to meaningful identifiers
Condition1 .. Condition99	named member (e.g., bool is_oversold_ = false)	Same: rename to typed bool members
Arrays: buf[10](0)	double buf_[11] = {}; or std::vector<double> buf_(11, 0.0)	PL [10] means last index is 10 (11 elements)
IntraBarPersist myVar(0)	double my_var_ = 0.0 member (same as Variables)	C++ has no bar-close vs intra-bar distinction; all members persist

---

Table 2 — Data Access

PowerLanguage	C++	Notes
Open, High, Low, Close, Volume	bars.back().open, .high, .low, .close, .volume	bars.back() for current bar
Close[1]	bars[bars.size() - 2].close	Lookback N: bars[bars.size() - 1 - n].close. Check bars.size() > n to avoid UB.
Close of Data2	separate const std::vector<Bar>& bars2 parameter	PL Data2 is a second chart feed; pass a second vector reference
Date	time_t t = bar.time; auto* tm = std::gmtime(&t); → tm->tm_year, tm->tm_mon, tm->tm_mday	PL Date is YYYMMDD integer (YYY = years since 1900); C++ uses <ctime> or <chrono>. Cast int64_t to time_t for portability.
Time	time_t t = bar.time; auto* tm = std::gmtime(&t); → tm->tm_hour, tm->tm_min	PL Time is HHMM integer
BarNumber / CurrentBar	bar.bar_number or i + 1 (loop index)	PL is 1-based

---

Table 3 — Technical Indicators

PowerLanguage	C++ (TA-Lib)	Notes
Average(Close, Length)	TA_SMA(0, endIdx, inClose, length, &outBeg, &outNB, outSma)	Current value: outSma[outNB - 1]
XAverage(Close, Length)	TA_EMA(0, endIdx, inClose, length, &outBeg, &outNB, outEma)	Same batch pattern
RSI(Close, Length)	TA_RSI(0, endIdx, inClose, length, &outBeg, &outNB, outRsi)	Returns 0–100 range
Stochastic(...)	TA_STOCH(0, endIdx, inHigh, inLow, inClose, fastK, slowK, slowKMAType, slowD, slowDMAType, &outBeg, &outNB, outSlowK, outSlowD)	Full %K/%D smoothing control — maps better to PL's 11-param version than Pine's simple ta.stoch
ADX(Length)	TA_ADX(0, endIdx, inHigh, inLow, inClose, length, &outBeg, &outNB, outAdx)	Direct equivalent
CCI(Length)	TA_CCI(0, endIdx, inHigh, inLow, inClose, length, &outBeg, &outNB, outCci)	PL CCI takes only length (uses HLC internally); TA-Lib requires explicit HLC arrays
AvgTrueRange(Length)	TA_TRANGE(0, endIdx, inHigh, inLow, inClose, &outBeg, &outNB, outTr) then TA_SMA over outTr	PL AvgTrueRange is a SIMPLE average of TrueRange. TA_ATR is Wilder-smoothed — NOT equivalent; TA_ATR instead matches PL SmoothedAverage(TrueRange, Len)
BollingerBand(Close, Length, 2)	TA_BBANDS(0, endIdx, inClose, length, 2.0, 2.0, TA_MAType_SMA, &outBeg, &outNB, outUpper, outMiddle, outLower)	Returns three arrays: upper, middle, lower
Close Crosses Over MA	prev_close <= prev_ma && close > ma	No built-in crossover in TA-Lib; implement as two-bar comparison
Close Crosses Under MA	prev_close >= prev_ma && close < ma	Same pattern
Highest(Close, Length)	TA_MAX(0, endIdx, inClose, length, &outBeg, &outNB, outMax)	Direct equivalent
Lowest(Close, Length)	TA_MIN(0, endIdx, inClose, length, &outBeg, &outNB, outMin)	Direct equivalent
Momentum(Close, Length)	TA_MOM(0, endIdx, inClose, length, &outBeg, &outNB, outMom)	Direct equivalent
TSI(Close, LongLen, ShortLen)	Manual: compute momentum, apply TA_EMA twice (long then short) to both momentum and abs(momentum), then 100.0 * smoothed_mtm / smoothed_abs_mtm	TA-Lib has no TA_TSI; chain two EMA passes
AverageFC(Close, Length)	TA_SMA(0, endIdx, inClose, length, &outBeg, &outNB, outSma)	FC = "fast calculation": AverageFC = SummationFC/Len (running-sum SMA), numerically identical to Average; TA_SMA gives the same values
WAverage(Close, Length)	TA_WMA(0, endIdx, inClose, length, &outBeg, &outNB, outWma)	Weighted moving average; direct equivalent
AdaptiveMovAvg(Close, Length)	TA_KAMA(0, endIdx, inClose, length, &outBeg, &outNB, outKama)	Kaufman Adaptive MA; direct equivalent
MidPoint(Close, Length)	TA_MIDPOINT(0, endIdx, inClose, length, &outBeg, &outNB, outMid)	(Highest + Lowest) / 2 over period
MACD(Close, FastLen, SlowLen)	TA_MACD(0, endIdx, inClose, fastLen, slowLen, signalLen, &outBeg, &outNB, outMACD, outSignal, outHist)	Returns three arrays: MACD line, signal, histogram
KeltnerChannel(Close, Length, Mult)	Manual: TA_EMA for midline ± Mult * TA_ATR for bands	No single TA-Lib function; combine EMA + ATR
DMIPlus(Length)	TA_PLUS_DI(0, endIdx, inHigh, inLow, inClose, length, &outBeg, &outNB, outPlusDI)	+DI component of DMI
DMIMinus(Length)	TA_MINUS_DI(0, endIdx, inHigh, inLow, inClose, length, &outBeg, &outNB, outMinusDI)	−DI component of DMI
RateOfChange(Close, Length)	TA_ROC(0, endIdx, inClose, length, &outBeg, &outNB, outRoc)	Percentage rate of change
PercentR(Length)	TA_WILLR(0, endIdx, inHigh, inLow, inClose, length, &outBeg, &outNB, outWillR) then add 100 to each value	PL PercentR is POSITIVE 0..100 (= Williams %R + 100); TA_WILLR returns −100..0 — thresholds become 80/20 on the positive scale
MoneyFlow(Length)	TA_MFI(0, endIdx, inHigh, inLow, inClose, inVolume, length, &outBeg, &outNB, outMfi)	Money Flow Index; requires HLCV arrays
Parabolic(AFStep, AFMax)	TA_SAR(0, endIdx, inHigh, inLow, AFStep, AFMax, &outBeg, &outNB, outSar)	Parabolic SAR; requires HL arrays
Volatility(Length)	TA_TRANGE(0, endIdx, inHigh, inLow, inClose, &outBeg, &outNB, outTr) then TA_EMA over outTr (approximation)	PL Volatility is an EMA-weighted average of TrueRange (weighted toward the most recent bar) — NOT a stdev of log returns (that is VolatilityStdDev)
UltimateOscillator(Len1, Len2, Len3)	TA_ULTOSC(0, endIdx, inHigh, inLow, inClose, len1, len2, len3, &outBeg, &outNB, outUltOsc)	Three-period weighted oscillator
ChaikinOsc(FastLen, SlowLen)	TA_ADOSC(0, endIdx, inHigh, inLow, inClose, inVolume, fastLen, slowLen, &outBeg, &outNB, outAdosc)	Chaikin A/D Oscillator; requires HLCV
PriceOscillator(FastLen, SlowLen)	TA_APO(0, endIdx, inClose, fastLen, slowLen, TA_MAType_SMA, &outBeg, &outNB, outApo)	Absolute Price Oscillator
DirMovement(Length, oPlusDI, oMinusDI, oADX)	Call TA_PLUS_DI, TA_MINUS_DI, and TA_ADX separately	Multi-output; split into three TA-Lib calls
Extremes(Length, oHighest, oLowest)	Manual: track running max/min over lookback window	No single TA-Lib function; use TA_MAX + TA_MIN or manual loop
TrueRange	TA_TRANGE(0, endIdx, inHigh, inLow, inClose, &outBeg, &outNB, outTRange)	Single-bar true range; direct equivalent
StandardDev(Close, Length)	TA_STDDEV(0, endIdx, inClose, length, 1.0, &outBeg, &outNB, outStdDev)	nbDev param = 1.0 for one standard deviation
TrueHigh	std::max(bars[i].high, bars[i-1].close)	Manual one-liner; guard i > 0
TrueLow	std::min(bars[i].low, bars[i-1].close)	Manual one-liner; guard i > 0
Range	bars[i].high - bars[i].low	Simple arithmetic; no TA-Lib needed
HighestBar(Close, Length)	TA_MAXINDEX(0, endIdx, inClose, length, &outBeg, &outNB, outIdx)	Returns index of highest value; convert to bars-ago offset
LowestBar(Close, Length)	TA_MININDEX(0, endIdx, inClose, length, &outBeg, &outNB, outIdx)	Returns index of lowest value; convert to bars-ago offset
NthHighest(N, Close, Length)	Manual: copy window into temp array, std::nth_element, pick Nth	No TA-Lib equivalent
NthLowest(N, Close, Length)	Manual: copy window, std::nth_element, pick Nth from low end	No TA-Lib equivalent
NthHighestBar(N, Close, Length)	Manual: find Nth highest value, then scan for its bar index	No TA-Lib equivalent
NthLowestBar(N, Close, Length)	Manual: find Nth lowest value, then scan for its bar index	No TA-Lib equivalent
SwingHigh(Occur, Price, Strength, Length)	Manual: candidate bar higher than Strength bars on each side, scanning the last Length bars	Occurrence is the FIRST PL arg (Nth most recent swing); returns −1 when none found; Length must exceed Strength; no TA-Lib equivalent
SwingLow(Occur, Price, Strength, Length)	Manual: candidate bar lower than Strength bars on each side, scanning the last Length bars	Mirror of SwingHigh with reversed comparisons; −1 when none found
SwingHighBar(Occur, Price, Strength, Length)	Manual: find SwingHigh, return bars-ago offset	Same pivot logic, return offset instead of price
SwingLowBar(Occur, Price, Strength, Length)	Manual: find SwingLow, return bars-ago offset	Same pivot logic, return offset instead of price
Summation(Close, Length)	TA_SUM(0, endIdx, inClose, length, &outBeg, &outNB, outSum)	Rolling sum; direct equivalent
Cum(Close)	Manual: cumulative_ += bars.back().close (running total as member)	Cumulative sum from bar 1; no period param
LinearRegValue(Close, Length, Offset)	TA_LINEARREG(0, endIdx, inClose, length, &outBeg, &outNB, outLinReg)	Offset projection requires manual adjustment
LinearRegAngle(Close, Length)	TA_LINEARREG_ANGLE(0, endIdx, inClose, length, &outBeg, &outNB, outAngle)	Angle in degrees; direct equivalent
LinearRegSlope(Close, Length)	TA_LINEARREG_SLOPE(0, endIdx, inClose, length, &outBeg, &outNB, outSlope)	Slope coefficient; direct equivalent
Correlation(Close, Close2, Length)	TA_CORREL(0, endIdx, inClose, inClose2, length, &outBeg, &outNB, outCorr)	Pearson correlation; direct equivalent
RSquared(Close, Length)	Manual: pow(TA_CORREL result, 2)	Coefficient of determination; square the correlation
StdError(Close, Length)	Manual: compute residuals against the TA_LINEARREG fit, then sqrt(sum_sq_resid / (length - 2))	Standard error of the linear-regression residuals — NOT TA_STDDEV / sqrt(length) (that is SE of the mean)
Median(Close, Length)	Manual: copy window, std::nth_element(begin, mid, end), read middle	No TA-Lib rolling median
ELDate	Manual: convert bar.time to YYYMMDD format (YYY = year − 1900)	PL EasyLanguage date format
MinutesToTime(mins)	Manual: int hhmm = (mins / 60) * 100 + (mins % 60)	Convert total minutes to HHMM integer
TimeToMinutes(hhmm)	Manual: int mins = (hhmm / 100) * 60 + (hhmm % 100)	Convert HHMM integer to total minutes
AvgPrice	TA_AVGPRICE(0, endIdx, inOpen, inHigh, inLow, inClose, &outBeg, &outNB, outAvg)	(O+H+L+C)/4; direct equivalent
MedianPrice	TA_MEDPRICE(0, endIdx, inHigh, inLow, &outBeg, &outNB, outMedPr)	(H+L)/2; direct equivalent
TypicalPrice	TA_TYPPRICE(0, endIdx, inHigh, inLow, inClose, &outBeg, &outNB, outTyp)	(H+L+C)/3; direct equivalent
WeightedClose	TA_WCLPRICE(0, endIdx, inHigh, inLow, inClose, &outBeg, &outNB, outWcl)	(H+L+2C)/4; direct equivalent
CountIF(Cond, Length)	Manual: int count = 0; for (int j = 0; j < length; ++j) if (cond[size-1-j]) ++count;	Count true occurrences in lookback window
MRO(Cond, Length, Instance)	Manual: scan backwards through lookback for Nth true occurrence, return bars-ago	Most Recent Occurrence; manual loop
AccumDist	TA_AD(0, endIdx, inHigh, inLow, inClose, inVolume, &outBeg, &outNB, outAD)	Cumulative A/D line; requires HLCV arrays
IFF(Cond, TrueVal, FalseVal)	cond ? trueVal : falseVal	C++ ternary operator; direct equivalent
TriAverage(Close, Length)	TA_TRIMA(0, endIdx, inClose, length, &outBeg, &outNB, outTrima)	Triangular MA; direct equivalent
FastK(StochLength)	TA_STOCHF(0, endIdx, inHigh, inLow, inClose, StochLength, 1, TA_MAType_SMA, &outBeg, &outNB, outFastK, outFastD)	Use TA_STOCHF for fast stochastic; outFastK is raw %K
FastD(StochLength)	TA_STOCHF(0, endIdx, inHigh, inLow, inClose, StochLength, 3, TA_MAType_SMA, &outBeg, &outNB, outFastK, outFastD)	outFastD is smoothed Fast %D
SlowK(StochLength)	TA_STOCH(0, endIdx, inHigh, inLow, inClose, StochLength, 3, TA_MAType_SMA, 3, TA_MAType_SMA, &outBeg, &outNB, outSlowK, outSlowD)	outSlowK from full stochastic
SlowD(StochLength)	TA_STOCH(0, endIdx, inHigh, inLow, inClose, StochLength, 3, TA_MAType_SMA, 3, TA_MAType_SMA, &outBeg, &outNB, outSlowK, outSlowD)	outSlowD from full stochastic
FastKCustom(H, L, C, StochLen)	TA_STOCHF(0, endIdx, H, L, C, StochLen, 1, TA_MAType_SMA, &outBeg, &outNB, outFastK, outFastD)	Custom price arrays
FastDCustom(H, L, C, StochLen)	TA_STOCHF(0, endIdx, H, L, C, StochLen, 3, TA_MAType_SMA, &outBeg, &outNB, outFastK, outFastD)	Custom prices; use outFastD
SlowKCustom(H, L, C, StochLen)	TA_STOCH(0, endIdx, H, L, C, StochLen, 3, TA_MAType_SMA, 3, TA_MAType_SMA, &outBeg, &outNB, outSlowK, outSlowD)	Custom prices
SlowDCustom(H, L, C, StochLen)	TA_STOCH(0, endIdx, H, L, C, StochLen, 3, TA_MAType_SMA, 3, TA_MAType_SMA, &outBeg, &outNB, outSlowK, outSlowD)	Slow %D with custom prices
StochasticExp(H, L, C, StochLen, S1, S2, ...)	TA_STOCH(0, endIdx, H, L, C, StochLen, S1, TA_MAType_EMA, S2, TA_MAType_EMA, &outBeg, &outNB, outSlowK, outSlowD)	Use TA_MAType_EMA for exponential smoothing
ADXR(Length)	TA_ADXR(0, endIdx, inHigh, inLow, inClose, length, &outBeg, &outNB, outAdxr)	Direct equivalent; ADX Rating
ADXCustom(H, L, C, Length)	TA_ADX(0, endIdx, H, L, C, length, &outBeg, &outNB, outAdx)	Custom price arrays
DMI(Length)	TA_ADX(0, endIdx, inHigh, inLow, inClose, length, &outBeg, &outNB, outAdx)	Wrapper; same as ADX
DMIPlusCustom(H, L, C, Length)	TA_PLUS_DI(0, endIdx, H, L, C, length, &outBeg, &outNB, outPlusDI)	+DI with custom prices
DMIMinusCustom(H, L, C, Length)	TA_MINUS_DI(0, endIdx, H, L, C, length, &outBeg, &outNB, outMinusDI)	−DI with custom prices
ParabolicCustom(AfStep, AfLimit)	TA_SAR(0, endIdx, inHigh, inLow, AfStep, AfLimit, &outBeg, &outNB, outSar)	Same as Parabolic with explicit limit
TRIX(Close, Length)	TA_TRIX(0, endIdx, inClose, length, &outBeg, &outNB, outTrix)	Direct equivalent
MassIndex(SmoothLen, SumLen)	Manual: TA_EMA of range, ratio, then sum	No single TA-Lib function; chain EMA calls
EaseOfMovement	Manual: distance moved / box ratio	No TA-Lib function; compute from OHLCV
SwingIndex	Manual: Wilder swing index formula	No TA-Lib function; ~20 lines of C++
AccumSwingIndex	Manual: running sum of SwingIndex	No TA-Lib function
Detrend(Close, Length)	Manual: close minus offset SMA	No direct TA-Lib; use TA_SMA with offset
PercentChange(Close, Length)	TA_ROC(0, endIdx, inClose, length, &outBeg, &outNB, outRoc)	Same as Rate of Change
UlcerIndex(Close, Length)	Manual: RMS of drawdown percentage	No TA-Lib function; track max, compute pct drawdown
ParabolicSAR(AfStep, AfLimit, ...)	TA_SAR(0, endIdx, inHigh, inLow, AfStep, AfLimit, &outBeg, &outNB, outSar) + manual position tracking	Track sign changes in SAR vs price for position/transition
LinearReg(Close, Length, TgtBar, ...)	TA_LINEARREG(...) + TA_LINEARREG_SLOPE(...) + TA_LINEARREG_ANGLE(...) + TA_LINEARREG_INTERCEPT(...)	Combine four TA-Lib calls for multi-output
TrueRangeCustom(H, L, C)	TA_TRANGE(0, endIdx, H, L, C, &outBeg, &outNB, outTRange)	Custom price arrays
VolatilityStdDev(NumDays)	Manual: compute log returns, then TA_STDDEV × sqrt(252)	Annualized historical volatility
StandardDevAnnual(Close, Length, DataType)	TA_STDDEV(0, endIdx, inClose, length, 1.0, &outBeg, &outNB, outStdDev) then multiply by sqrt(252)	Annualize the output
HighestFC(Close, Length)	TA_MAX(0, endIdx, inClose, length, &outBeg, &outNB, outMax)	Same as Highest
LowestFC(Close, Length)	TA_MIN(0, endIdx, inClose, length, &outBeg, &outNB, outMin)	Same as Lowest
PivotHighVS(Inst, Price, LStr, RStr, Len)	Manual: scan for bar higher than L bars left and R bars right	Asymmetric pivot detection
PivotLowVS(Inst, Price, LStr, RStr, Len)	Manual: scan for bar lower than L bars left and R bars right	Same for lows
PivotHighVSBar(Inst, Price, LStr, RStr, Len)	Manual: return offset of detected pivot high	bars-ago index
PivotLowVSBar(Inst, Price, LStr, RStr, Len)	Manual: return offset of detected pivot low	bars-ago index
Divergence(P1, P2, Str, Len, HiLo)	Manual: compare pivot highs/lows of two series	No TA-Lib function
TimeSeriesForecast(Close, Length)	TA_TSF(0, endIdx, inClose, length, &outBeg, &outNB, outTsf)	Direct equivalent
SummationFC(Close, Length)	TA_SUM(0, endIdx, inClose, length, &outBeg, &outNB, outSum)	Same as Summation
OpenD(N)	Manual: aggregate intraday bars into daily struct DailyBar, index daily_bars[size-1-N].open	Requires daily bar aggregation
HighD(N)	Manual: daily_bars[size-1-N].high	Daily high from aggregation
LowD(N)	Manual: daily_bars[size-1-N].low	Daily low
CloseD(N)	Manual: daily_bars[size-1-N].close	Daily close
OpenW(N)	Manual: aggregate to weekly bars	Same pattern
HighW(N)	Manual: weekly high	Weekly aggregation
LowW(N)	Manual: weekly low	Weekly aggregation
CloseW(N)	Manual: weekly close	Weekly aggregation
OpenM(N)	Manual: aggregate to monthly bars	Monthly aggregation
HighM(N)	Manual: monthly high	Monthly aggregation
LowM(N)	Manual: monthly low	Monthly aggregation
CloseM(N)	Manual: monthly close	Monthly aggregation
OpenY(N)	Manual: aggregate to yearly bars	Yearly aggregation
HighY(N)	Manual: yearly high	Yearly aggregation
LowY(N)	Manual: yearly low	Yearly aggregation
CloseY(N)	Manual: yearly close	Yearly aggregation
LRO(Cond, Length, N)	Manual: scan from length bars ago forward, find Nth true	Least Recent Occurrence
SummationIf(Cond, Price, Length)	Manual: for (int i = 0; i < length; i++) if (cond[end-i]) sum += price[end-i];	Conditional rolling sum
IFFString(Cond, TrueStr, FalseStr)	cond ? trueStr : falseStr	C++ ternary with std::string
OBV	TA_OBV(0, endIdx, inClose, inVolume, &outBeg, &outNB, outObv)	Direct equivalent
VolumeROC(Length)	TA_ROC(0, endIdx, inVolume, length, &outBeg, &outNB, outRoc)	Apply ROC to volume array
VolumeOsc(ShortLen, LongLen)	Manual: TA_SMA(volume, ShortLen) - TA_SMA(volume, LongLen)	Difference of two volume SMAs
PriceVolTrend	Manual: cumulative (close[i] - close[i-1]) / close[i-1] * volume[i]	Running sum
LWAccDis	Manual: cumulative (close - open) / (high - low) * volume	Larry Williams A/D
Fisher(Price)	Manual: normalize, then 0.5 * log((1 + norm) / (1 - norm))	Fisher transformation
FisherINV(Price)	Manual: (exp(2 * price) - 1) / (exp(2 * price) + 1)	Inverse Fisher
C_Doji(Pct)	TA_CDLDOJI(0, endIdx, inOpen, inHigh, inLow, inClose, &outBeg, &outNB, outInt)	TA-Lib CDL* functions return ±100
C_Hammer_HangingMan(Len, Factor, ...)	TA_CDLHAMMER(...) / TA_CDLHANGINGMAN(...)	Separate TA-Lib functions for each pattern
C_BullEng_BearEng(Len, ...)	TA_CDLENGULFING(0, endIdx, inOpen, inHigh, inLow, inClose, &outBeg, &outNB, outInt)	+100=bullish, −100=bearish
C_BullHar_BearHar(Len, ...)	TA_CDLHARAMI(0, endIdx, inOpen, inHigh, inLow, inClose, &outBeg, &outNB, outInt)	+100=bullish, −100=bearish
C_MornDoji_EveDoji(Len, Pct, ...)	TA_CDLMORNINGDOJISTAR(...) / TA_CDLEVENINGDOJISTAR(...)	Separate functions
C_MornStar_EveStar(Len, ...)	TA_CDLMORNINGSTAR(...) / TA_CDLEVENINGSTAR(...)	Separate functions
C_PierceLine_DkCloud(Len, ...)	TA_CDLPIERCING(...) / TA_CDLDARKCLOUDCOVER(...)	Separate functions
C_ShootingStar(Len, Factor)	TA_CDLSHOOTINGSTAR(0, endIdx, inOpen, inHigh, inLow, inClose, &outBeg, &outNB, outInt)	Direct equivalent
C_3WhSolds_3BlkCrows(Len, Factor, ...)	TA_CDL3WHITESOLDIERS(...) / TA_CDL3BLACKCROWS(...)	Separate functions
Statistical extended
AvgDeviation(Close, N)	Manual: mean absolute deviation	No TA-Lib equivalent
Variance(Close, N)	TA_VAR(0, endIdx, inClose, N, 1.0, &outBeg, &outNB, outVar)	Population variance; the 1.0 is the required double optInNbDev argument
Kurtosis(Close, N)	Manual: 4th moment calculation	No TA-Lib equivalent
Skew(Close, N)	Manual: 3rd moment calculation	No TA-Lib equivalent
PercentRank(ValToRank, Price, N)	Manual: count values ≤ target / N	No TA-Lib equivalent
Covariance(P1, P2, N)	Manual: sum((P1-mean1)*(P2-mean2)) / N	No TA-Lib equivalent
Quartile(Close, N, Q)	Manual: sort window, pick percentile	No TA-Lib equivalent
TrimMean(Close, N, Pct)	Manual: sort, trim edges, average	No TA-Lib equivalent
Mode(Close, N, Type)	Manual: frequency count over window	No TA-Lib equivalent
HarmonicMean(Close, N)	Manual: N / sum(1/x)	No TA-Lib equivalent
Moving averages extended
SmoothedAverage(Close, N)	Manual: Wilder smoothing prev*(N-1)/N + val/N	Same formula as TA-Lib's internal Wilder smoothing
Miscellaneous
BarAnnualization	Manual: compute from bar frequency	Bars-per-year factor
LastBarOnChart	bar_index == data_size - 1	True on last bar
Custom functions
StochRSI(Close, N, M)	TA_STOCHRSI(0, sz-1, close, N, M, 1, TA_MAType_SMA, ...)	Stochastic RSI
supertrend(N, Mult)	Manual: ATR bands + direction flip logic	No TA-Lib equivalent
NVI(Start)	Manual: accumulate on volume-down bars	No TA-Lib equivalent
PVI(Start)	Manual: accumulate on volume-up bars	No TA-Lib equivalent
Coppo(N1, N2, N3)	Manual: TA_WMA of two TA_ROC results	Coppock Curve
LWTI(Close, P, N)	Manual: (sma(diff, N) / sma(range, N)) * 50 + 50	No TA-Lib equivalent
TVI(Close, Vol, Tick)	Manual: cumulative directional volume	No TA-Lib equivalent
SharpeRatio(Period, Rate, Calc, Cap)	Manual: (avg_return - rf) / std_return	Portfolio Sharpe
WRSI(N, Close)	TA_RSI(0, sz-1, close, N, ...)	TA-Lib RSI uses Wilder smoothing
NewMA(Close, N)	Manual: Heikin-Ashi + triple EMA hybrid	No TA-Lib equivalent

---

Table 4 — Strategy Orders

PowerLanguage	C++	Notes
Buy("label") next bar market	orders.push_back({"label", Side::Long, OrderType::Market, 0.0, 1.0})	Push to the orders vector
SellShort("label") next bar market	Order{"label", Side::Short, OrderType::Market, 0.0, 1.0}	Side::Short for short entry
Sell("label") next bar market	Close long: set 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 position_ = 0	PL BuyToCover exits an existing short
Buy("label") next bar at price limit	Order{"label", Side::Long, OrderType::Limit, price, 1.0}	Limit order
Buy("label") next bar at price stop	Order{"label", Side::Long, OrderType::Stop, price, 1.0}	Stop order
SetStopLoss(dollars)	stop_price = entry_price_ - dollars / (qty * point_value)	PL takes a dollar amount; C++ must convert to price level
SetProfitTarget(dollars)	target_price = entry_price_ + dollars / (qty * point_value)	Same dollar-to-price conversion

---

Table 5 — Plotting

PowerLanguage	C++	Notes
Plot1(value, "label")	std::cout << label << ": " << value << "\n" or log to file	No chart in C++; output to stdout, file, or results container
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 write to results

---

Table 6 — Control Flow

PowerLanguage	C++	Notes
If cond Then Begin ... End;	if (cond) { ... }	C++ requires parentheses around condition
If cond Then ... Else ...	if (cond) { ... } else { ... }	Direct mapping
For idx = 1 to n Begin ... End;	for (int i = 1; i <= n; ++i) { ... }	PL For is inclusive; use <= in C++. 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;	switch (expr) { case 1: ... break; default: break; }	C++ switch requires break; to prevent fallthrough; PL empty case body is a compile error — use Value1 = Value1; as no-op
Once Begin ... End;	if (first_bar_) { ... first_bar_ = false; }	Use a bool member; PL Once runs on first bar only

---

Table 7 — Other Built-ins and Features

PowerLanguage	C++	Notes
MarketPosition	position_ (int: −1/0/+1)	Track manually as member; update on fills
EntryPrice	entry_price_ (double)	Track manually
CurrentContracts	current_contracts_ (double)	Track manually
BarsSinceEntry	bars_since_entry_ (int)	Increment each bar while in position; reset on entry
Print("text")	std::cout << "text" << std::endl	Use iostream or fprintf
#BeginCmtry ... #EndCmtry	No equivalent	Skip or log
Alert("msg")	std::cerr << "ALERT: msg" << std::endl or callback	Design depends on framework

---

Part 2: Semantic Differences and Gotchas

Order fill timing — the #1 conversion bug

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 (size_t i = 0; i + 1 < bars.size(); ++i) {
    orders.clear();
    std::vector<Bar> history(bars.begin(), bars.begin() + i + 1);
    strategy.on_bar(history, orders);             // orders queued on bar i...
    const Bar& next = bars[i + 1];
    for (const Order& o : orders) {               // ...filled on bar i+1
        if (o.type == OrderType::Market)
            fill(o, next.open);                                  // next bar's OPEN
        else if (o.type == OrderType::Stop && next.high >= o.price)  // buy stop
            fill(o, std::max(o.price, next.open));               // intrabar at the stop price
        // sell stop: next.low <= o.price; limit orders mirror with reversed comparisons
    }
}

EMA seeding/warmup gotcha: PL XAverage seeds recursively from the first bar's price; TA-Lib TA_EMA seeds with the SMA of the first Length values — early values differ. Other targets differ again (pandas-ta SMA seed by default, ta-rs first-value seed, Pine na during warmup). Discard roughly the first 3×Length bars before comparing backtests.

1. Sell does not mean "go short". In PowerLanguage, Sell exits an existing long position. The C++ equivalent is closing the position (setting position_ to 0). Do not create a new short entry as a translation of Sell.

2. PL is implicitly bar-driven; C++ requires an explicit loop. PowerLanguage executes the entire script top-to-bottom on each bar close automatically. In C++, you must write the for (size_t i = 0; i < bars.size(); ++i) loop and call on_bar() on each iteration.

3. Bar lookback causes undefined behavior without bounds checking. PL uses MaxBarsBack to prevent execution on bars with insufficient history — the script simply does not run on those early bars. C++ bars[bars.size() - 6] is undefined behavior when bars.size() < 6 — likely a crash, but possibly silent corruption. Always check bars.size() > n before lookback access, and skip the bar or use a default value when history is insufficient.

4. TA-Lib uses batch computation, not streaming. TA-Lib functions like TA_SMA process an entire array at once and return outBegIdx (first valid output index) and outNBElement (count of valid outputs). Calling TA-Lib on every bar with a growing history slice recomputes the entire series each time. For performance, consider TA-Lib RT's streaming API or caching previous results.

5. TA-Lib outBegIdx offset is the most common TA-Lib mistake. The output array is NOT aligned with the input array. The first valid output is at output[0], which corresponds to input[outBegIdx]. The current bar's value is output[outNBElement - 1]. Ignoring this offset and reading output[inputIndex] produces incorrect indicator values.

6. Crossover/crossunder has no TA-Lib built-in. PL Crosses Over / Crosses Under are language keywords. TA-Lib has no crossover function. Implement as: bool crossed_over = prev_a <= prev_b && a > b;. Store previous-bar values as member variables.

7. Dollar amounts versus price levels for stops. SetStopLoss and SetProfitTarget in PL accept a dollar amount. C++ must convert to price levels explicitly: stop_price = entry_price_ - stop_dollars / (qty * point_value).

8. Position state is not tracked automatically. PL provides MarketPosition, EntryPrice, CurrentContracts, and BarsSinceEntry as built-in variables updated by the engine. In C++, you must maintain these as class members and update them manually on order fills.

9. C++ has no Value1..Value99 or Condition1..Condition99. Replace with named, typed class members using descriptive identifiers.

10. TA-Lib output arrays must be pre-allocated. All TA_* functions write into caller-allocated arrays. Size them at least as large as the input array. Failing to allocate enough space causes a buffer overflow. Use std::vector instead of raw arrays to avoid this class of bugs.

11. Multi-data series requires explicit design. PL Close of Data2 accesses a second feed bound to the chart. In C++, pass const std::vector<Bar>& bars2 as a second parameter. There is no implicit secondary-feed mechanism.

12. No Portfolio Money Management (PMM) equivalent. PL's PMM allows a single script to govern position sizing across multiple instruments. C++ has no built-in portfolio abstraction. You must implement cross-instrument logic as a separate portfolio manager that calls individual strategy instances.

---

Part 3: Conversion Checklists

PL → C++ Pre-Conversion

• List every Inputs: declaration; note name, type, default — each becomes a constructor parameter and private member
• List every Variables: declaration; note initial values — each becomes a private member initialized in-class or in the constructor
• Identify all Value1..Value99 and Condition1..Condition99 usages; plan meaningful replacement names
• Identify all indicator calls; confirm each has a TA-Lib equivalent (check ta_func.h for the function name)
• Locate all Data2 / Data3 references; decide on multi-feed architecture
• Locate all SetStopLoss, SetProfitTarget, and dollar-based parameters; note point value for conversion
• Check for IntraBarPersist variables; decide whether tick-level behavior matters
• Identify all .elf function calls; plan conversion to C++ free functions or member functions

PL → C++ Post-Conversion

• Every Sell maps to closing the long, not entering short — audit all order keywords
• Every BuyToCover maps to closing the short, not entering long
• All lookback accesses (Close[N]) guarded with bars.size() > n
• All TA-Lib output arrays properly pre-allocated (use std::vector, not raw arrays)
• All TA-Lib results read from output[outNBElement - 1], not output[inputIndex] — outBegIdx offset accounted for
• Crosses Over / Crosses Under implemented as two-bar comparisons
• MarketPosition, EntryPrice, CurrentContracts, BarsSinceEntry tracked as manually updated members
• Dollar-based stop/target amounts converted to price levels
• Value1..Value99 and Condition1..Condition99 renamed to descriptive typed members
• Code compiles with g++ -std=c++17 -Wall -Wextra -Werror with zero errors and zero warnings
• Strategy back-tested on the same instrument and date range as PL original; trade count and net P&L in the same order of magnitude

C++ → PL Pre-Conversion

• List all class members and categorize: inputs (const/set-once) vs variables (mutable) vs indicator state
• Identify all TA-Lib function calls; map each to the PL built-in (TA_SMA → Average, TA_EMA → XAverage, TA_RSI → RSI, etc.)
• Check for switch statements with fallthrough — PL Switch does not fallthrough
• Identify any C++ libraries beyond TA-Lib; plan PL equivalents or inline reimplementation
• Check for explicit position-tracking members; confirm they can be replaced by PL's built-in MarketPosition, EntryPrice, etc.

C++ → PL Post-Conversion

• Every short entry maps to SellShort, not Sell
• Every long close maps to Sell, not SellShort
• All bars[bars.size() - 1 - n].close lookbacks converted to Close[n]
• All manual crossover comparisons converted to PL Crosses Over / Crosses Under keywords
• All class members categorized: const inputs → Inputs:, mutable state → Variables:
• All TA-Lib batch calls replaced with PL function calls (e.g., TA_SMA(...) → Average(Close, Length))
• TA-Lib outBegIdx / outNBElement index arithmetic eliminated — PL handles lookback alignment internally
• Price-level stops/targets converted to dollar amounts for SetStopLoss / SetProfitTarget
• Script compiled in MultiCharts PowerEditor with zero errors before testing