QuanTAlib/lib/numerics/exptrans/Exptrans.md

EXPTRANS: Exponential Function

The exponential function is the only function that is its own derivative—a mathematical curiosity that makes it indispensable for modeling growth, decay, and everything compounding.

Property	Value
Category	Numeric
Inputs	Source (close)
Parameters	None
Outputs	Single series (EXPTRANS)
Output range	Varies (see docs)
Warmup	0 bars
PineScript	exptrans.pine

• The Exponential (EXP) transformer applies the natural exponential function e^x to each value in a time series.
• No configurable parameters; computation is stateless per bar.
• Output range: Varies (see docs).
• Requires 0 bars of warmup before first valid output (IsHot = true).
• Validated against TA-Lib, Skender, and Tulip reference implementations where available.

The Exponential (EXP) transformer applies the natural exponential function e^x to each value in a time series. As the inverse of the natural logarithm, it converts additive relationships back to multiplicative ones, making it essential for reconstructing price levels from log-returns and implementing models that assume log-normal distributions.

Mathematical Foundation

Core Formula

\text{EXP}_t = e^{x_t}

where:

• x_t is the input value at time t
• e \approx 2.71828... is Euler's number

Key Properties

Property	Formula	Description
Inverse of Log	e^{\ln(x)} = x	Undoes natural logarithm
Product Rule	e^{a+b} = e^a \cdot e^b	Additive inputs → multiplicative outputs
Quotient Rule	e^{a-b} = e^a / e^b	Differences → ratios
Power Rule	e^{n \cdot x} = (e^x)^n	Scaling in exponent → power
Identity	e^0 = 1	Zero maps to unity
Base Value	e^1 = e \approx 2.71828	Unit exponent gives e

Domain and Range

	Value
Domain	(-\infty, +\infty)
Range	(0, +\infty)

The exponential function accepts any real number but always produces strictly positive outputs.

Financial Applications

Log-Return to Price Reconstruction

Given cumulative log-returns, reconstruct price levels:

P_t = P_0 \cdot e^{\sum_{i=1}^{t} r_i}

where r_i are log-returns.

Volatility Scaling

Convert log-volatility to multiplicative factors:

\text{VolFactor} = e^{\sigma \sqrt{T}}

Compound Growth

Model continuous compounding:

A = P \cdot e^{rt}

where r is the continuous rate and t is time.

Option Pricing

The exponential appears throughout Black-Scholes:

C = S \cdot N(d_1) - K \cdot e^{-rT} \cdot N(d_2)

Implementation Details

Overflow Handling

For large positive inputs, e^x can overflow to infinity:

• e^{709} ≈ 8.2 \times 10^{307} (near double max)
• e^{710} → overflow

The implementation substitutes the last valid value when overflow occurs.

Precision Considerations

Input Range	Relative Precision
$	x
$	x
$	x

Streaming Characteristics

Metric	Value
Warmup Period	0
Memory	O(1)
Complexity	O(1) per update

Performance Profile

Operation Count (Scalar)

Operation	Count	Notes
EXP	1	Hardware instruction
Total	~20 cycles	Platform dependent

Quality Metrics

Metric	Score	Notes
Accuracy	10/10	IEEE 754 compliant
Timeliness	10/10	Zero lag
Smoothness	N/A	Transform preserves input characteristics

Usage Examples

Basic Usage

// Create EXP transformer
var exp = new Exptrans();

// Transform log-returns back to growth factors
var logReturn = new TValue(DateTime.UtcNow, 0.05);
var growthFactor = exp.Update(logReturn);  // ≈ 1.0513

Reconstructing Prices from Log-Returns

var logReturns = new TSeries();
// ... populate with cumulative log-returns

var cumulativeExp = new Exptrans();
var priceRatios = cumulativeExp.Update(logReturns);

// Multiply by initial price to get price levels
var initialPrice = 100.0;
var prices = priceRatios.Select(v => v * initialPrice);

Undoing Log Transform

var log = new Logtrans();
var exp = new Exptrans();

// Round-trip: price → log → exp → price
var price = new TValue(DateTime.UtcNow, 150.0);
var logPrice = log.Update(price);     // ≈ 5.0106
var recovered = exp.Update(logPrice); // ≈ 150.0

Common Pitfalls

1. Overflow Risk: Input values above ~709 cause overflow. Monitor input ranges when working with cumulative sums.

2. Magnitude Explosion: Small additive changes in the exponent create large multiplicative changes in output. A change of 1.0 in the exponent multiplies the output by e ≈ 2.72.

3. Inverse Relationship: EXP undoes LOG, but only if the original values were positive. Negative prices cannot be recovered through log-exp round-trip.

4. Scale Sensitivity: Unlike LOG which compresses ranges, EXP expands them dramatically. Ensure downstream consumers can handle the output magnitudes.

Validation

Test	Status
Math.Exp Parity	✅
Known Values (e⁰=1, e¹=e)	✅
Inverse of Log	✅
Product Rule	✅
Quotient Rule	✅
Power Rule	✅

References

• Euler, L. (1748). Introductio in analysin infinitorum.
• Maor, E. (1994). e: The Story of a Number. Princeton University Press.
• Hull, J. (2018). Options, Futures, and Other Derivatives. Pearson. (Black-Scholes applications)