Brownian Bridge™

1. The `PathSimulator` stores the model as `const Model* _model` (a raw owning pointer). In the copy constructor, `_model(ps._model->clone())` is used. What is the purpose of storing the model as a pointer rather than as a `Model` object by value?

Pointers are faster to dereference than values in a loop`Model` is abstract (has pure virtual methods) and cannot be instantiated as a value; a pointer is required to enable polymorphic dispatch to derived typesThe model is shared between multiple path simulators, so a pointer avoids duplicationThe compiler requires raw pointers for vtable lookups

2. The `EulerPathSimulator::next_step` computes: ```cpp double next_step = current_price + model->drift_term(t, current_price) * dt + model->diffusion_term(t, current_price) * sqrt(dt) * gaussian; ``` For Black-Scholes where `drift_term = r*S` and `diffusion_term = sigma*S`, what is the bias of this Euler scheme for large `dt`?

No bias — the Euler scheme is exact for geometric Brownian motionThe Euler scheme is biased for log-normal dynamics because it approximates `d(S)` linearly; paths can go negative for large `dt`, and the second-order Itô correction is missingThe scheme overestimates the option price because it generates too many paths above the strikeThe bias is proportional to `sqrt(dt)` and is corrected by the Milstein term

3. The standard error of a Monte Carlo estimate decreases as `O(1/N)` — doubling the number of paths halves the standard error.

truefalse

4. In the `MonteCarlo` engine, `_path_simulator` is stored as `PathSimulator*` obtained via `clone()`. In the `price()` method that loops over paths, each call to `_path_simulator->path()` generates an independent path. What ensures independence between paths?

Each `path()` call creates a new `PathSimulator` object, which reinitialises the RNGThe `StandardGaussianGenerator` inside `PathSimulator` maintains internal state (a seeded Mersenne Twister) and advances it on each `generate()` call, producing a new draw each timeThe paths are computed in parallel on separate threads with separate RNG instancesIndependence is guaranteed by the central limit theorem

5. The `Payoff` hierarchy has `EuropeanOptionPayoff`, `PutPayoff`, and `AsianCallPayoff`. All derive from `Payoff` and implement `discounted_payoff(path, time_points)`. For a European call with strike K, what is the correct implementation?

`return std::max(path.back() - _strike, 0.0);``return std::exp(-_risk_free_rate * time_points.back()) * std::max(path.back() - _strike, 0.0);``return std::max(path.back() - _strike, 0.0) / path[0];``return std::exp(-_risk_free_rate * time_points.back()) * (path.back() - _strike);`

6. The Open/Closed Principle, as applied to the MC pricing framework, means that you can add a new model (e.g., `HestonModel`) or a new payoff (e.g., `BarrierCallPayoff`) without modifying `MonteCarlo`, `PathSimulator`, or any existing class.

truefalse

Quiz: Monte Carlo Pricing Framework in C++

Quick Quiz