public static double atmRate(Leg leg, YieldTermStructure discountCurve, bool includeSettlementDateFlows) { double ret = NQuantLibcPINVOKE.CashFlows_atmRate__SWIG_3(Leg.getCPtr(leg), YieldTermStructure.getCPtr(discountCurve), includeSettlementDateFlows); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
/** * Immediately prior to default, the CDS has some value V (to the protection buyer). * After default, the contract cancelled, so there is an immediate loss of -V (or a gain if V was negative). * The protection buyer pays the accrued interest A and receives 1-RR, so the full * Value on Default (VoD) is -V + (1-RR) (where the A has been absorbed as we use the clean price for V). * * @param cds the analytic description of a CDS traded at a certain time * @param yieldCurve the yield (or discount) curve * @param creditCurve the credit (or survival) curve * @param coupon the coupon of the CDS * @return the value on default or jump to default */ public double valueOnDefault( CDS cds, YieldTermStructure yieldCurve, PiecewiseconstantHazardRate creditCurve, double coupon) { double pv = _pricer.pv(cds, yieldCurve, creditCurve, coupon); return(-pv + cds.getLGD()); }
public static double bps(Leg leg, YieldTermStructure discountCurve, bool includeSettlementDateFlows, Date settlementDate, Date npvDate) { double ret = NQuantLibcPINVOKE.CashFlows_bps__SWIG_0(Leg.getCPtr(leg), YieldTermStructure.getCPtr(discountCurve), includeSettlementDateFlows, Date.getCPtr(settlementDate), Date.getCPtr(npvDate)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public static ZeroCurve as_zerocurve(YieldTermStructure curve) { ZeroCurve ret = new ZeroCurve(NQuantLibcPINVOKE.as_zerocurve(YieldTermStructure.getCPtr(curve)), true); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public static double cleanPriceFromZSpread(Bond bond, YieldTermStructure discountCurve, double zSpread, DayCounter dc, Compounding compounding, Frequency freq) { double ret = NQuantLibcPINVOKE.cleanPriceFromZSpread__SWIG_1(Bond.getCPtr(bond), YieldTermStructure.getCPtr(discountCurve), zSpread, DayCounter.getCPtr(dc), (int)compounding, (int)freq); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public static double npv(Leg leg, YieldTermStructure discountCurve, double zSpread, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows) { double ret = NQuantLibcPINVOKE.CashFlows_npv__SWIG_2(Leg.getCPtr(leg), YieldTermStructure.getCPtr(discountCurve), zSpread, DayCounter.getCPtr(dayCounter), (int)compounding, (int)frequency, includeSettlementDateFlows); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public static double zSpread(Leg leg, double npv, YieldTermStructure arg2, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate, Date npvDate, double accuracy, uint maxIterations) { double ret = NQuantLibcPINVOKE.CashFlows_zSpread__SWIG_1(Leg.getCPtr(leg), npv, YieldTermStructure.getCPtr(arg2), DayCounter.getCPtr(dayCounter), (int)compounding, (int)frequency, includeSettlementDateFlows, Date.getCPtr(settlementDate), Date.getCPtr(npvDate), accuracy, maxIterations); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
//*************************************************************************************************************** // bucketed CS01 of a CDS from single market quote of that CDS //*************************************************************************************************************** public double[] bucketedCS01FromSpread( CDS cds, double coupon, YieldTermStructure yieldCurve, double marketSpread, CDS[] buckets) { PiecewiseconstantHazardRate cc = _curveBuilder.calibrateCreditCurve(cds, marketSpread, yieldCurve); return(bucketedCS01FromCreditCurve(cds, coupon, buckets, yieldCurve, cc)); }
public YieldTermStructure __deref__() { global::System.IntPtr cPtr = NQuantLibcPINVOKE.YieldTermStructureHandle___deref__(swigCPtr); YieldTermStructure ret = (cPtr == global::System.IntPtr.Zero) ? null : new YieldTermStructure(cPtr, true); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) { throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public double[][] bucketedCS01( CDS[] cds, double[] cdsCoupons, CDS[] pillarCDSs, CdsQuoteConvention[] marketQuotes, YieldTermStructure yieldCurve) { PiecewiseconstantHazardRate creditCurve = _curveBuilder.calibrateCreditCurve(pillarCDSs, marketQuotes, yieldCurve); return(bucketedCS01FromCreditCurve(cds, cdsCoupons, pillarCDSs, yieldCurve, creditCurve)); }
public double[] bucketedCS01FromParSpreads( CDS cds, double cdsCoupon, YieldTermStructure yieldCurve, CDS[] pillarCDSs, double[] spreads) { PiecewiseconstantHazardRate creditCurve = _curveBuilder.calibrateCreditCurve(pillarCDSs, spreads, yieldCurve); return(bucketedCS01FromCreditCurve(cds, cdsCoupon, pillarCDSs, yieldCurve, creditCurve)); }
public void testCashOrNothingEuropeanValues() { // Testing European cash-or-nothing digital option DigitalOptionData[] values = { // "Option pricing formulas", E.G. Haug, McGraw-Hill 1998 - pag 88 // type, strike, spot, q, r, t, vol, value, tol new DigitalOptionData(Option.Type.Put, 80.00, 100.0, 0.06, 0.06, 0.75, 0.35, 2.6710, 1e-4, true) }; DayCounter dc = new Actual360(); Date today = Date.Today; SimpleQuote spot = new SimpleQuote(0.0); SimpleQuote qRate = new SimpleQuote(0.0); YieldTermStructure qTS = Utilities.flatRate(today, qRate, dc); SimpleQuote rRate = new SimpleQuote(0.0); YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc); SimpleQuote vol = new SimpleQuote(0.0); BlackVolTermStructure volTS = Utilities.flatVol(today, vol, dc); for (int i = 0; i < values.Length; i++) { StrikedTypePayoff payoff = new CashOrNothingPayoff(values[i].type, values[i].strike, 10.0); Date exDate = today + Convert.ToInt32(values[i].t * 360 + 0.5); Exercise exercise = new EuropeanExercise(exDate); spot.setValue(values[i].s); qRate.setValue(values[i].q); rRate.setValue(values[i].r); vol.setValue(values[i].v); BlackScholesMertonProcess stochProcess = new BlackScholesMertonProcess(new Handle <Quote>(spot), new Handle <YieldTermStructure>(qTS), new Handle <YieldTermStructure>(rTS), new Handle <BlackVolTermStructure>(volTS)); IPricingEngine engine = new AnalyticEuropeanEngine(stochProcess); VanillaOption opt = new VanillaOption(payoff, exercise); opt.setPricingEngine(engine); double calculated = opt.NPV(); double error = Math.Abs(calculated - values[i].result); if (error > values[i].tol) { REPORT_FAILURE("value", payoff, exercise, values[i].s, values[i].q, values[i].r, today, values[i].v, values[i].result, calculated, error, values[i].tol, values[i].knockin); } } }
/** * The par spread par spread for a given yield and credit (hazard rate/survival) curve). * * @param cds analytic description of a CDS traded at a certain time * @param yieldCurve the yield (or discount) curve * @param creditCurve the credit (or survival) curve * @return the par spread */ public double parSpread(CDS cds, YieldTermStructure yieldCurve, PiecewiseconstantHazardRate creditCurve) { if (cds.getProtectionEnd() <= 0.0) { //short cut already Expired CDSs } double rpv01 = annuity(cds, yieldCurve, creditCurve, CdsPriceType.CLEAN, 0.0); double proLeg = protectionLeg(cds, yieldCurve, creditCurve, 0.0); return(proLeg / rpv01); }
public void calculate() { FxTermStructure fxForwardTS = under_.fxForwardTS_; YieldTermStructure discountTS = engine_.disCountTS_; double tradedForward = instInfo_.fxForwardRate_; double marketForward = fxForwardTS.forwardRate(instInfo_.maturityDate_); unitValue_ = (tradedForward - marketForward) * discountTS.discount(instInfo_.payDate_); this.Value_ = Convert.ToInt64(unitValue_) * instInfo_.Notional_; }
//public FxTermStructure fxForwardTS_ { get; set; } public FxUnderlying(CurrencyType baseCurrency, YieldTermStructure baseCurrencyTS, CurrencyType counterCurrency, YieldTermStructure counterCurrencyTS, double spotRate) { this.baseCurrency_ = baseCurrency; this.counterCurrency_ = counterCurrency; this.baseCurrencyTS_ = baseCurrencyTS; this.counterCurrencyTS_ = counterCurrencyTS; this.spotRate_ = spotRate; }
//------------------------------------------------------------------------- /** * Hedge a CDS with other CDSs on the same underlying (single-name or index) at different maturities. * <p> * The hedge is such that the total portfolio (the CDS <b>minus</b> the hedging CDSs, with notionals of the * CDS notional times the computed hedge ratios) is insensitive to infinitesimal changes to the the credit curve. * <p> * Here the credit curve is built using the hedging CDSs as pillars. * * @param cds the CDS to be hedged * @param coupon the coupon of the CDS to be hedged * @param hedgeCDSs the CDSs to hedge with - these are also used to build the credit curve * @param hedgeCDSCoupons the coupons of the CDSs to hedge with/build credit curve * @param hegdeCDSPUF the PUF of the CDSs to build credit curve * @param yieldCurve the yield curve * @return the hedge ratios, * since we use a unit notional, the ratios should be multiplied by -notional to give the hedge notional amounts */ public double[] getHedgeRatios( CDS cds, double coupon, CDS[] hedgeCDSs, double[] hedgeCDSCoupons, double[] hegdeCDSPUF, YieldTermStructure yieldCurve) { PiecewiseconstantHazardRate cc = _builder.calibrateCreditCurve(hedgeCDSs, hedgeCDSCoupons, yieldCurve, hegdeCDSPUF); return(getHedgeRatios(cds, coupon, hedgeCDSs, hedgeCDSCoupons, cc, yieldCurve)); }
/** * Hedge a CDS with other CDSs on the same underlying (single-name or index) at different maturities. * <p> * The hedge is such that the total portfolio (the CDS <b>minus</b> the hedging CDSs, with notionals of the * CDS notional times the computed hedge ratios) is insensitive to infinitesimal changes to the the credit curve. * <p> * If the number of hedge-CDSs equals the number of credit-curve knots, the system is square * and is solved exactly (see below).<br> * If the number of hedge-CDSs is less than the number of credit-curve knots, the system is * solved in a least-square sense (i.e. is hedge is not exact).<br> * If the number of hedge-CDSs is greater than the number of credit-curve knots, the system * cannot be solved. <br> * The system may not solve if the maturities if the hedging CDSs and very different from the * knot times (i.e. the sensitivity matrix is singular). * * @param cds the CDS to be hedged * @param coupon the coupon of the CDS to be hedged * @param hedgeCDSs the CDSs to hedge with - these are also used to build the credit curve * @param hedgeCDSCoupons the coupons of the CDSs to hedge with/build credit curve * @param creditCurve The credit curve * @param yieldCurve the yield curve * @return the hedge ratios, * since we use a unit notional, the ratios should be multiplied by -notional to give the hedge notional amounts */ public double[] getHedgeRatios( CDS cds, double coupon, CDS[] hedgeCDSs, double[] hedgeCDSCoupons, PiecewiseconstantHazardRate creditCurve, YieldTermStructure yieldCurve) { double[] cdsSense = getCurveSensitivities(cds, coupon, creditCurve, yieldCurve); double[,] hedgeSense = getCurveSensitivities(hedgeCDSs, hedgeCDSCoupons, creditCurve, yieldCurve); return(getHedgeRatios(cdsSense, hedgeSense)); }
/** * The analytic CS01 (or credit DV01). * * @param cds the analytic description of a CDS traded at a certain time * @param coupon the of the traded CDS (expressed as <b>fractions not basis points</b>) * @param yieldCurve the yield (or discount) curve * @param puf the points up-front (as a fraction) * @return the credit DV01 */ public double parallelCS01FromPUF(CDS cds, double coupon, YieldTermStructure yieldCurve, double puf) { PiecewiseconstantHazardRate cc = _curveBuilder.calibrateCreditCurve(cds, coupon, yieldCurve, puf); double a = _pricer.protectionLeg(cds, yieldCurve, cc); double b = _pricer.annuity(cds, yieldCurve, cc, CdsPriceType.CLEAN); double aPrime = _pricer.protectionLegCreditSensitivity(cds, yieldCurve, cc, 0); double bPrime = _pricer.pvPremiumLegCreditSensitivity(cds, yieldCurve, cc, 0); double s = a / b; double dPVdh = aPrime - coupon * bPrime; double dSdh = (aPrime - s * bPrime) / b; return(dPVdh / dSdh); }
public ProtectionLegElement(double start, double end, YieldTermStructure yieldCurve, int creditCurveKnot, double[] knots) { _knots = DoublesScheduleGenerator.truncateSetInclusive(start, end, knots); _n = _knots.Length; _rt = new double[_n]; _p = new double[_n]; for (int i = 0; i < _n; i++) { _rt[i] = yieldCurve.getRT_(_knots[i]); _p[i] = Math.Exp(-_rt[i]); } _creditCurveKnot = creditCurveKnot; }
public static double bps(Bond bond, YieldTermStructure discountCurve, Date settlementDate = null) { if (settlementDate == null) { settlementDate = bond.settlementDate(); } Utils.QL_REQUIRE(BondFunctions.isTradable(bond, settlementDate), () => "non tradable at " + settlementDate + " (maturity being " + bond.maturityDate() + ")"); return(CashFlows.bps(bond.cashflows(), discountCurve, false, settlementDate) * 100.0 / bond.notional(settlementDate)); }
public FdmQuantoHelper( YieldTermStructure rTS, YieldTermStructure fTS, BlackVolTermStructure fxVolTS, double equityFxCorrelation, double exchRateATMlevel) { rTS_ = rTS; fTS_ = fTS; fxVolTS_ = fxVolTS; equityFxCorrelation_ = equityFxCorrelation; exchRateATMlevel_ = exchRateATMlevel; }
public void testValues() { // Testing Cliquet option values Date today = Date.Today; DayCounter dc = new Actual360(); SimpleQuote spot = new SimpleQuote(60.0); SimpleQuote qRate = new SimpleQuote(0.04); YieldTermStructure qTS = Utilities.flatRate(today, qRate, dc); SimpleQuote rRate = new SimpleQuote(0.08); YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc); SimpleQuote vol = new SimpleQuote(0.30); BlackVolTermStructure volTS = Utilities.flatVol(today, vol, dc); BlackScholesMertonProcess process = new BlackScholesMertonProcess( new Handle <Quote>(spot), new Handle <YieldTermStructure>(qTS), new Handle <YieldTermStructure>(rTS), new Handle <BlackVolTermStructure>(volTS)); IPricingEngine engine = new AnalyticCliquetEngine(process); List <Date> reset = new List <Date>(); reset.Add(today + 90); Date maturity = today + 360; Option.Type type = Option.Type.Call; double moneyness = 1.1; PercentageStrikePayoff payoff = new PercentageStrikePayoff(type, moneyness); EuropeanExercise exercise = new EuropeanExercise(maturity); CliquetOption option = new CliquetOption(payoff, exercise, reset); option.setPricingEngine(engine); double calculated = option.NPV(); double expected = 4.4064; // Haug, p.37 double error = Math.Abs(calculated - expected); double tolerance = 1e-4; if (error > tolerance) { REPORT_FAILURE("value", payoff, exercise, spot.value(), qRate.value(), rRate.value(), today, vol.value(), expected, calculated, error, tolerance); } }
public double parSpreadCreditSensitivity( CDS cds, YieldTermStructure yieldCurve, PiecewiseconstantHazardRate creditCurve, int creditCurveNode) { double a = protectionLeg(cds, yieldCurve, creditCurve); double b = annuity(cds, yieldCurve, creditCurve, CdsPriceType.CLEAN); double spread = a / b; double dadh = protectionLegCreditSensitivity(cds, yieldCurve, creditCurve, creditCurveNode); double dbdh = pvPremiumLegCreditSensitivity(cds, yieldCurve, creditCurve, creditCurveNode); return(spread * (dadh / a - dbdh / b)); }
//------------------------------------------------------------------------- /** * The sensitivity of the PV of a CDS to the zero hazard rates at the knots of the credit curve. * * @param cds the CDS * @param coupon the coupon * @param creditCurve the credit Curve * @param yieldCurve the yield curve * @return vector of sensitivities */ public double[] getCurveSensitivities( CDS cds, double coupon, PiecewiseconstantHazardRate creditCurve, YieldTermStructure yieldCurve) { int n = creditCurve.getNumberOfKnots(); double[] CurveSen = new double[n]; for (int i = 0; i < n; i++) { CurveSen[i] = _pricer.pvCreditSensitivity(cds, yieldCurve, creditCurve, coupon, i); } return(CurveSen); }
public double pvPremiumLegCreditSensitivity( CDS cds, YieldTermStructure yieldCurve, PiecewiseconstantHazardRate creditCurve, int creditCurveNode) { if (cds.getProtectionEnd() <= 0.0) { //short cut already expired CDSs return(0.0); } int n = cds.getNumPayments(); double pvSense = 0.0; for (int i = 0; i < n; i++) { CdsCoupon c = cds.getCoupon(i); double paymentTime = c.getPaymentTime(); double creditObsTime = c.getEffEnd(); double dqdh = creditCurve.getSingleNodeDiscountFactorSensitivity(creditObsTime, creditCurveNode); if (dqdh == 0) { continue; } double p = Math.Exp(-yieldCurve.getRT_(paymentTime)); pvSense += c.getYearFrac() * p * dqdh; } if (cds.isPayAccOnDefault()) { double start = cds.getNumPayments() == 1 ? cds.getEffectiveProtectionStart() : cds.getAccStart(); double[] integrationSchedule = DoublesScheduleGenerator.getIntegrationsPoints(start, cds.getProtectionEnd(), yieldCurve, creditCurve); double accPVSense = 0.0; for (int i = 0; i < n; i++) { accPVSense += calculateSinglePeriodAccrualOnDefaultCreditSensitivity( cds.getCoupon(i), cds.getEffectiveProtectionStart(), integrationSchedule, yieldCurve, creditCurve, creditCurveNode); } pvSense += accPVSense; } double df = Math.Exp(-yieldCurve.getRT_(cds.getCashSettleTime())); pvSense /= df; return(pvSense); }
public void testFdValues() { //("Testing finite-difference engine for American options..."); Date today = Date.Today; DayCounter dc = new Actual360(); SimpleQuote spot = new SimpleQuote(0.0); SimpleQuote qRate = new SimpleQuote(0.0); YieldTermStructure qTS = Utilities.flatRate(today, qRate, dc); SimpleQuote rRate = new SimpleQuote(0.0); YieldTermStructure rTS = Utilities.flatRate(today, rRate, dc); SimpleQuote vol = new SimpleQuote(0.0); BlackVolTermStructure volTS = Utilities.flatVol(today, vol, dc); double tolerance = 8.0e-2; for (int i = 0; i < juValues.Length; i++) { StrikedTypePayoff payoff = new PlainVanillaPayoff(juValues[i].type, juValues[i].strike); Date exDate = today + Convert.ToInt32(juValues[i].t * 360 + 0.5); Exercise exercise = new AmericanExercise(today, exDate); spot.setValue(juValues[i].s); qRate.setValue(juValues[i].q); rRate.setValue(juValues[i].r); vol.setValue(juValues[i].v); BlackScholesMertonProcess stochProcess = new BlackScholesMertonProcess(new Handle <Quote>(spot), new Handle <YieldTermStructure>(qTS), new Handle <YieldTermStructure>(rTS), new Handle <BlackVolTermStructure>(volTS)); IPricingEngine engine = new FDAmericanEngine(stochProcess, 100, 100); VanillaOption option = new VanillaOption(payoff, exercise); option.setPricingEngine(engine); double calculated = option.NPV(); double error = Math.Abs(calculated - juValues[i].result); if (error > tolerance) { REPORT_FAILURE("value", payoff, exercise, juValues[i].s, juValues[i].q, juValues[i].r, today, juValues[i].v, juValues[i].result, calculated, error, tolerance); } } }
public double parallelCS01FromCreditCurve( CDS cds, double cdsCoupon, CDS[] bucketCDSs, YieldTermStructure yieldCurve, PiecewiseconstantHazardRate creditCurve) { double[] temp = bucketedCS01FromCreditCurve(cds, cdsCoupon, bucketCDSs, yieldCurve, creditCurve); double sum = 0; foreach (double cs in temp) { sum += cs; } return(sum); }
/** * Sensitivity of the present value (for the payer of premiums, i.e. the buyer of protection) to * the zero hazard rate of a given node (knot) of the credit curve. This is per unit of notional. * * @param cds the analytic description of a CDS traded at a certain time * @param yieldCurve the yield (or discount) curve * @param creditCurve the credit (or survival) curve * @param fractionalSpread the <b>fraction</b> spread * @param creditCurveNode the credit curve node * @return PV sensitivity to one node (knot) on the credit (hazard rate/survival) curve */ public double pvCreditSensitivity( CDS cds, YieldTermStructure yieldCurve, PiecewiseconstantHazardRate creditCurve, double fractionalSpread, int creditCurveNode) { if (cds.getProtectionEnd() <= 0.0) { //short cut already expired CDSs return(0.0); } double rpv01Sense = pvPremiumLegCreditSensitivity(cds, yieldCurve, creditCurve, creditCurveNode); double proLegSense = protectionLegCreditSensitivity(cds, yieldCurve, creditCurve, creditCurveNode); return(proLegSense - fractionalSpread * rpv01Sense); }
// par-rate approximation public static double parRate(YieldTermStructure yts, List <Date> dates, DayCounter resultDayCounter) { Utils.QL_REQUIRE(dates.Count >= 2, () => "at least two dates are required"); double sum = 0.0; double dt; for (int i = 1; i < dates.Count; ++i) { dt = resultDayCounter.yearFraction(dates[i - 1], dates[i]); Utils.QL_REQUIRE(dt >= 0.0, () => "unsorted dates"); sum += yts.discount(dates[i]) * dt; } double result = yts.discount(dates.First()) - yts.discount(dates.Last()); return(result / sum); }
public override IborIndex Clone(YieldTermStructure forwardingCurve) { if (Impl.QlObj is not global::QuantLib.OvernightIndex iborIdx) { throw new InvalidOperationException( $"Implementation object reference is of type {Impl.QlObj.GetType().FullName} which is not derived from {nameof(global::QuantLib.OvernightIndex)}"); } var qlObj = iborIdx.clone(forwardingCurve.GetHandle()); if (qlObj is global::QuantLib.OvernightIndex onIdx) { return(new OvernightIndex(onIdx)); } // This should never happen return(new IborIndex(qlObj)); }
public static double bps(Leg leg, YieldTermStructure discountCurve, bool includeSettlementDateFlows, Date settlementDate, Date npvDate) { double ret = NQuantLibcPINVOKE.CashFlows_bps__SWIG_0(Leg.getCPtr(leg), YieldTermStructure.getCPtr(discountCurve), includeSettlementDateFlows, Date.getCPtr(settlementDate), Date.getCPtr(npvDate)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); return ret; }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(YieldTermStructure obj) { return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; }
public static double cleanPriceFromZSpread(Bond bond, YieldTermStructure discountCurve, double zSpread, DayCounter dc, Compounding compounding, Frequency freq) { double ret = NQuantLibcPINVOKE.cleanPriceFromZSpread__SWIG_1(Bond.getCPtr(bond), YieldTermStructure.getCPtr(discountCurve), zSpread, DayCounter.getCPtr(dc), (int)compounding, (int)freq); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); return ret; }
public YieldTermStructure __deref__() { YieldTermStructure ret = new YieldTermStructure(NQuantLibcPINVOKE.YieldTermStructureHandle___deref__(swigCPtr), true); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); return ret; }
public static double atmRate(Bond bond, YieldTermStructure discountCurve) { double ret = NQuantLibcPINVOKE.BondFunctions_atmRate__SWIG_2(Bond.getCPtr(bond), YieldTermStructure.getCPtr(discountCurve)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); return ret; }
public static double atmRate(Bond bond, YieldTermStructure discountCurve, Date settlementDate, double cleanPrice) { double ret = NQuantLibcPINVOKE.BondFunctions_atmRate__SWIG_0(Bond.getCPtr(bond), YieldTermStructure.getCPtr(discountCurve), Date.getCPtr(settlementDate), cleanPrice); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); return ret; }
public RelinkableYieldTermStructureHandle(YieldTermStructure arg0) : this(NQuantLibcPINVOKE.new_RelinkableYieldTermStructureHandle__SWIG_0(YieldTermStructure.getCPtr(arg0)), true) { if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); }
public static double atmRate(Leg leg, YieldTermStructure discountCurve, bool includeSettlementDateFlows) { double ret = NQuantLibcPINVOKE.CashFlows_atmRate__SWIG_3(Leg.getCPtr(leg), YieldTermStructure.getCPtr(discountCurve), includeSettlementDateFlows); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); return ret; }
public void linkTo(YieldTermStructure arg0) { NQuantLibcPINVOKE.RelinkableYieldTermStructureHandle_linkTo(swigCPtr, YieldTermStructure.getCPtr(arg0)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); }
public static double zSpread(Leg leg, double npv, YieldTermStructure arg2, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows, Date settlementDate) { double ret = NQuantLibcPINVOKE.CashFlows_zSpread__SWIG_4(Leg.getCPtr(leg), npv, YieldTermStructure.getCPtr(arg2), DayCounter.getCPtr(dayCounter), (int)compounding, (int)frequency, includeSettlementDateFlows, Date.getCPtr(settlementDate)); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); return ret; }
public static double npv(Leg leg, YieldTermStructure discountCurve, double zSpread, DayCounter dayCounter, Compounding compounding, Frequency frequency, bool includeSettlementDateFlows) { double ret = NQuantLibcPINVOKE.CashFlows_npv__SWIG_2(Leg.getCPtr(leg), YieldTermStructure.getCPtr(discountCurve), zSpread, DayCounter.getCPtr(dayCounter), (int)compounding, (int)frequency, includeSettlementDateFlows); if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve(); return ret; }