feat: add Gaussian1D framework bindings (models, swaption, and cap/floor engines)

Author: quantales

docs/api/models.md

@@ -327,7 +327,49 @@ helper = ql.HestonModelHelper(
 .. autoclass:: pyquantlib.ConstantParameter
 ```
 
+## Gaussian 1-D Framework
+
+### Gsr
+
+```{eval-rst}
+.. autoclass:: pyquantlib.Gsr
+```
+
+Gaussian short-rate (GSR) model in forward measure. Supports constant or piecewise mean reversion and volatility, with both static and floating (Handle-based) data.
+
+```python
+# Constant mean reversion
+gsr = ql.Gsr(term_structure_handle, [], [0.01], 0.1)
+
+# Piecewise
+gsr = ql.Gsr(term_structure, [step_date], [0.01, 0.02], [0.1, 0.15])
+```
+
+### MarkovFunctional
+
+```{eval-rst}
+.. autoclass:: pyquantlib.MarkovFunctional
+```
+
+Markov Functional 1-factor model calibrated to swaption or caplet smiles.
+
+```{eval-rst}
+.. autoclass:: pyquantlib.MarkovFunctionalModelSettings
+```
+
+```{eval-rst}
+.. autoclass:: pyquantlib.MarkovFunctionalModelOutputs
+```
+
+```python
+# Swaption-calibrated MarkovFunctional
+mf = ql.MarkovFunctional(
+    term_structure, 0.01, [], [0.01],
+    swaption_vol_handle, expiries, tenors, swap_index,
+)
+```
+
 ```{note}
 Abstract base classes are available in `pyquantlib.base` for custom model implementations:
-`CalibratedModel`, `ShortRateModel`, `OneFactorModel`, `OneFactorAffineModel`, `TwoFactorModel`, `AffineModel`, `TermStructureConsistentModel`, `CalibrationHelper`, `BlackCalibrationHelper`.
+`CalibratedModel`, `ShortRateModel`, `OneFactorModel`, `OneFactorAffineModel`, `TwoFactorModel`, `AffineModel`, `TermStructureConsistentModel`, `Gaussian1dModel`, `CalibrationHelper`, `BlackCalibrationHelper`.
 ```

docs/api/pricingengines.md

@@ -482,6 +482,50 @@ engine = ql.FdG2SwaptionEngine(model, tGrid=100, xGrid=50, yGrid=50)
 swaption.setPricingEngine(engine)
 ```
 
+### Gaussian1dSwaptionEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.Gaussian1dSwaptionEngine
+```
+
+Gaussian 1-D model swaption engine with numerical integration. Supports European and Bermudan exercise.
+
+```python
+model = ql.Gsr(curve, [ql.Date(15, 1, 2025)], [0.01], 0.01)
+engine = ql.Gaussian1dSwaptionEngine(model, integrationPoints=64)
+swaption.setPricingEngine(engine)
+print(swaption.NPV())
+```
+
+### Gaussian1dJamshidianSwaptionEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.Gaussian1dJamshidianSwaptionEngine
+```
+
+Jamshidian decomposition swaption engine for Gaussian 1-D models. European exercise only.
+
+```python
+engine = ql.Gaussian1dJamshidianSwaptionEngine(model)
+swaption.setPricingEngine(engine)
+```
+
+### Gaussian1dNonstandardSwaptionEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.Gaussian1dNonstandardSwaptionEngine
+```
+
+Gaussian 1-D model engine for nonstandard swaptions (period-varying notionals and strikes).
+
+### Gaussian1dFloatFloatSwaptionEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.Gaussian1dFloatFloatSwaptionEngine
+```
+
+Gaussian 1-D model engine for float-float swaptions.
+
 ## Barrier Engines
 
 ### AnalyticBarrierEngine
@@ -731,6 +775,21 @@ Analytic cap/floor engine for affine short-rate models (Hull-White, CIR, G2++).
 
 Lattice-based cap/floor engine for short-rate models.
 
+### Gaussian1dCapFloorEngine
+
+```{eval-rst}
+.. autoclass:: pyquantlib.Gaussian1dCapFloorEngine
+```
+
+Gaussian 1-D model cap/floor engine with numerical integration.
+
+```python
+model = ql.Gsr(curve, [ql.Date(15, 1, 2025)], [0.01], 0.01)
+engine = ql.Gaussian1dCapFloorEngine(model, integrationPoints=64)
+cap.setPricingEngine(engine)
+print(cap.NPV())
+```
+
 ## YoY Inflation Cap/Floor Engines
 
 ### YoYInflationBlackCapFloorEngine

docs/changelog.md

@@ -40,10 +40,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `MCDigitalEngine` factory function for Monte Carlo digital option pricing (pseudo-random and low-discrepancy)
 - `AnalyticDividendEuropeanEngine` for European options with discrete dividends
 - `AnalyticBSMHullWhiteEngine` for BSM + Hull-White stochastic interest rates
+- `Gaussian1dSwaptionEngine` for Gaussian 1-D model swaption pricing (European/Bermudan)
+- `Gaussian1dJamshidianSwaptionEngine` for Jamshidian decomposition swaption pricing
+- `Gaussian1dNonstandardSwaptionEngine` for nonstandard swaption pricing with OAS support
+- `Gaussian1dFloatFloatSwaptionEngine` for float-float swaption pricing with OAS support
+- `Gaussian1dCapFloorEngine` for Gaussian 1-D model cap/floor pricing
 - `AnalyticCapFloorEngine` for analytic cap/floor pricing with affine short-rate models
 - `TreeCapFloorEngine` for lattice-based cap/floor pricing with short-rate models
 
 #### Models
+- `Gaussian1dModel` ABC for Gaussian 1-D short-rate models (in `pyquantlib.base`)
+- `Gsr` Gaussian short-rate model with piecewise volatility and reversion, plus calibration methods
+- `MarkovFunctional` Markov-functional model with `ModelSettings` builder and `ModelOutputs` diagnostics
+- `Gaussian1dModelHandle` and `RelinkableGaussian1dModelHandle` for Gaussian1dModel references
 - `CoxIngersollRoss` (CIR) short-rate model with Feller constraint support
 - `ExtendedCoxIngersollRoss` extended CIR model fitted to the initial term structure
 - `CapHelper` calibration helper for ATM caps (with handle and hidden-handle constructors)

include/pyquantlib/pyquantlib.h

@@ -297,6 +297,9 @@ namespace ql_models {
     void hestonmodelhelper(py::module_&);
     void coxingersollross(py::module_&);
     void extendedcoxingersollross(py::module_&);
+    void gaussian1dmodel(py::module_&);
+    void gsr(py::module_&);
+    void markovfunctional(py::module_&);
 }
 
 namespace ql_instruments {
@@ -455,6 +458,12 @@ namespace ql_pricingengines {
     // Cap/floor engines
     void analyticcapfloorengine(py::module_&);
     void treecapfloorengine(py::module_&);
+    void gaussian1dcapfloorengine(py::module_&);
+    // Gaussian1D swaption engines
+    void gaussian1dswaptionengine(py::module_&);
+    void gaussian1djamshidianswaptionengine(py::module_&);
+    void gaussian1dnonstandardswaptionengine(py::module_&);
+    void gaussian1dfloatfloatswaptionengine(py::module_&);
 }
 
 namespace ql_methods {