public virtual void test_resolve()
        {
            BusinessDayAdjustment bussAdj = BusinessDayAdjustment.of(FOLLOWING, SAT_SUN);
            ResolvedCds           test    = PRODUCT_STD.resolve(REF_DATA);
            int nDates = 44;

            LocalDate[] dates = new LocalDate[nDates];
            for (int i = 0; i < nDates; ++i)
            {
                dates[i] = START_DATE.plusMonths(3 * i);
            }
            IList <CreditCouponPaymentPeriod> payments = new List <CreditCouponPaymentPeriod>(nDates - 1);

            for (int i = 0; i < nDates - 2; ++i)
            {
                LocalDate start = i == 0 ? dates[i] : bussAdj.adjust(dates[i], REF_DATA);
                LocalDate end   = bussAdj.adjust(dates[i + 1], REF_DATA);
                payments.Add(CreditCouponPaymentPeriod.builder().startDate(start).endDate(end).unadjustedStartDate(dates[i]).unadjustedEndDate(dates[i + 1]).effectiveStartDate(start.minusDays(1)).effectiveEndDate(end.minusDays(1)).paymentDate(end).currency(USD).notional(NOTIONAL).fixedRate(COUPON).yearFraction(ACT_360.relativeYearFraction(start, end)).build());
            }
            LocalDate start = bussAdj.adjust(dates[nDates - 2], REF_DATA);
            LocalDate end   = dates[nDates - 1];

            payments.Add(CreditCouponPaymentPeriod.builder().startDate(start).endDate(end.plusDays(1)).unadjustedStartDate(dates[nDates - 2]).unadjustedEndDate(end).effectiveStartDate(start.minusDays(1)).effectiveEndDate(end).paymentDate(bussAdj.adjust(end, REF_DATA)).currency(USD).notional(NOTIONAL).fixedRate(COUPON).yearFraction(ACT_360.relativeYearFraction(start, end.plusDays(1))).build());
            ResolvedCds expected = ResolvedCds.builder().buySell(BUY).legalEntityId(LEGAL_ENTITY).dayCount(ACT_360).paymentOnDefault(ACCRUED_PREMIUM).paymentPeriods(payments).protectionStart(BEGINNING).protectionEndDate(END_DATE).settlementDateOffset(SETTLE_DAY_ADJ).stepinDateOffset(STEPIN_DAY_ADJ).build();

            assertEquals(test, expected);
        }
	  //-------------------------------------------------------------------------
	  public virtual void coverage()
	  {
		CreditCouponPaymentPeriod test1 = CreditCouponPaymentPeriod.builder().currency(USD).notional(NOTIONAL).startDate(START_DATE).endDate(END_DATE).effectiveStartDate(EFF_START_DATE).effectiveEndDate(EFF_END_DATE).paymentDate(END_DATE).fixedRate(COUPON).yearFraction(YEAR_FRACTION).build();
		coverImmutableBean(test1);
		CreditCouponPaymentPeriod test2 = CreditCouponPaymentPeriod.builder().currency(Currency.JPY).notional(5.0e6).startDate(START_DATE.minusDays(7)).endDate(END_DATE.minusDays(7)).effectiveStartDate(EFF_START_DATE.minusDays(7)).effectiveEndDate(EFF_END_DATE.minusDays(7)).paymentDate(END_DATE.minusDays(7)).fixedRate(0.01).yearFraction(0.25).build();
		coverBeanEquals(test1, test2);
	  }
Exemple #3
0
            public double rpv01(NodalCurve creditCurve, PriceType cleanOrDirty)
            {
                double pv = 0.0;

                for (int i = startPeriodIndex; i < nPayments; i++)
                {
                    CreditCouponPaymentPeriod coupon = cds.PaymentPeriods.get(i);
                    double yc = offsetAccEnd[i];
                    double q  = Math.Exp(-creditCurve.yValue(yc) * yc);
                    pv += coupon.YearFraction * paymentDF[i] * q;
                }

                if (cds.PaymentOnDefault.AccruedInterest)
                {
                    double accPV = 0.0;
                    for (int i = startPeriodIndex; i < nPayments; i++)
                    {
                        accPV += calculateSinglePeriodAccrualOnDefault(i, creditCurve);
                    }
                    pv += accPV;
                }
                pv /= valuationDF;
                if (cleanOrDirty == PriceType.CLEAN)
                {
                    pv -= accYearFraction;
                }
                return(pv);
            }
	  public virtual void test_contains()
	  {
		CreditCouponPaymentPeriod test = CreditCouponPaymentPeriod.builder().currency(USD).notional(NOTIONAL).startDate(START_DATE).endDate(END_DATE).effectiveStartDate(EFF_START_DATE).effectiveEndDate(EFF_END_DATE).paymentDate(END_DATE).fixedRate(COUPON).yearFraction(YEAR_FRACTION).build();
		assertTrue(test.contains(START_DATE));
		assertTrue(test.contains(START_DATE.plusMonths(1)));
		assertFalse(test.contains(END_DATE));
		assertFalse(test.contains(START_DATE.minusDays(1)));
	  }
	  public virtual void test_builder()
	  {
		CreditCouponPaymentPeriod test = CreditCouponPaymentPeriod.builder().currency(USD).notional(NOTIONAL).startDate(START_DATE).endDate(END_DATE).effectiveStartDate(EFF_START_DATE).effectiveEndDate(EFF_END_DATE).paymentDate(END_DATE).fixedRate(COUPON).yearFraction(YEAR_FRACTION).build();
		assertEquals(test.Currency, USD);
		assertEquals(test.EffectiveStartDate, EFF_START_DATE);
		assertEquals(test.EffectiveEndDate, EFF_END_DATE);
		assertEquals(test.StartDate, START_DATE);
		assertEquals(test.EndDate, END_DATE);
		assertEquals(test.FixedRate, COUPON);
		assertEquals(test.Notional, NOTIONAL);
		assertEquals(test.PaymentDate, END_DATE);
		assertEquals(test.YearFraction, YEAR_FRACTION);
	  }
        /// <summary>
        /// Calculates the accrued premium per fractional spread for unit notional.
        /// </summary>
        /// <param name="stepinDate">  the step-in date </param>
        /// <returns> the accrued year fraction </returns>
        public double accruedYearFraction(LocalDate stepinDate)
        {
            if (stepinDate.isBefore(AccrualStartDate))
            {
                return(0d);
            }
            if (stepinDate.isEqual(AccrualEndDate))
            {
                return(paymentPeriods.get(paymentPeriods.size() - 1).YearFraction);
            }
            CreditCouponPaymentPeriod period = findPeriod(stepinDate).orElseThrow(() => new System.ArgumentException("Date outside range"));

            return(dayCount.relativeYearFraction(period.StartDate, stepinDate));
        }
        static ResolvedCdsIndexTest()
        {
            int nDates = 44;

            LocalDate[] dates = new LocalDate[nDates];
            for (int i = 0; i < nDates; ++i)
            {
                dates[i] = START_DATE.plusMonths(3 * i);
            }
            for (int i = 0; i < nDates - 2; ++i)
            {
                LocalDate start = i == 0 ? dates[i] : BUSS_ADJ.adjust(dates[i], REF_DATA);
                LocalDate end   = BUSS_ADJ.adjust(dates[i + 1], REF_DATA);
                PAYMENTS.Add(CreditCouponPaymentPeriod.builder().startDate(start).endDate(end).effectiveStartDate(start.minusDays(1)).effectiveEndDate(end.minusDays(1)).paymentDate(end).currency(USD).notional(NOTIONAL).fixedRate(COUPON).yearFraction(ACT_360.relativeYearFraction(start, end)).build());
            }
            LocalDate start = BUSS_ADJ.adjust(dates[nDates - 2], REF_DATA);
            LocalDate end   = dates[nDates - 1];

            PAYMENTS.Add(CreditCouponPaymentPeriod.builder().startDate(start).endDate(end.plusDays(1)).effectiveStartDate(start.minusDays(1)).effectiveEndDate(end).paymentDate(BUSS_ADJ.adjust(end, REF_DATA)).currency(USD).notional(NOTIONAL).fixedRate(COUPON).yearFraction(ACT_360.relativeYearFraction(start, end.plusDays(1))).build());
        }
	  public virtual void test_serialization()
	  {
		CreditCouponPaymentPeriod test = CreditCouponPaymentPeriod.builder().currency(USD).notional(NOTIONAL).startDate(START_DATE).endDate(END_DATE).effectiveStartDate(EFF_START_DATE).effectiveEndDate(EFF_END_DATE).paymentDate(END_DATE).fixedRate(COUPON).yearFraction(YEAR_FRACTION).build();
		assertSerialization(test);
	  }
Exemple #9
0
            public Pricer(FastCreditCurveCalibrator outerInstance, ResolvedCds nodeCds, CreditDiscountFactors yieldCurve, DoubleArray creditCurveKnots, double fractionalSpread, double pointsUpfront, double lgd, LocalDate stepinDate, LocalDate effectiveStartDate, LocalDate settlementDate, double accruedYearFraction)
            {
                this.outerInstance = outerInstance;

                accYearFraction       = accruedYearFraction;
                cds                   = nodeCds;
                fracSpread            = fractionalSpread;
                puf                   = pointsUpfront;
                productEffectiveStart = yieldCurve.relativeYearFraction(effectiveStartDate);
                double protectionEnd = yieldCurve.relativeYearFraction(cds.ProtectionEndDate);

                // protection leg
                proLegIntPoints = DoublesScheduleGenerator.getIntegrationsPoints(productEffectiveStart, protectionEnd, yieldCurve.ParameterKeys, creditCurveKnots).toArray();
                nProPoints      = proLegIntPoints.Length;
                valuationDF     = yieldCurve.discountFactor(settlementDate);
                lgdDF           = lgd / valuationDF;
                proYieldCurveRT = new double[nProPoints];
                proDF           = new double[nProPoints];
                for (int i = 0; i < nProPoints; i++)
                {
                    proYieldCurveRT[i] = yieldCurve.zeroRate(proLegIntPoints[i]) * proLegIntPoints[i];
                    proDF[i]           = Math.Exp(-proYieldCurveRT[i]);
                }
                // premium leg
                nPayments = cds.PaymentPeriods.size();
                paymentDF = new double[nPayments];
                int indexTmp = -1;

                for (int i = 0; i < nPayments; i++)
                {
                    if (stepinDate.isBefore(cds.PaymentPeriods.get(i).EndDate))
                    {
                        paymentDF[i] = yieldCurve.discountFactor(cds.PaymentPeriods.get(i).PaymentDate);
                    }
                    else
                    {
                        indexTmp = i;
                    }
                }
                startPeriodIndex = indexTmp + 1;
                // accrual on default
                if (cds.PaymentOnDefault.AccruedInterest)
                {
                    LocalDate   tmp = nPayments == 1 ? effectiveStartDate : cds.AccrualStartDate;
                    DoubleArray integrationSchedule = DoublesScheduleGenerator.getIntegrationsPoints(yieldCurve.relativeYearFraction(tmp), protectionEnd, yieldCurve.ParameterKeys, creditCurveKnots);
                    accRate          = new double[nPayments];
                    offsetAccStart   = new double[nPayments];
                    offsetAccEnd     = new double[nPayments];
                    premLegIntPoints = new double[nPayments][];
                    premDF           = new double[nPayments][];
                    rt     = new double[nPayments][];
                    premDt = new double[nPayments][];
                    for (int i = startPeriodIndex; i < nPayments; i++)
                    {
                        CreditCouponPaymentPeriod coupon = cds.PaymentPeriods.get(i);
                        offsetAccStart[i] = yieldCurve.relativeYearFraction(coupon.EffectiveStartDate);
                        offsetAccEnd[i]   = yieldCurve.relativeYearFraction(coupon.EffectiveEndDate);
                        accRate[i]        = coupon.YearFraction / yieldCurve.DayCount.relativeYearFraction(coupon.StartDate, coupon.EndDate);
                        double start = Math.Max(productEffectiveStart, offsetAccStart[i]);
                        if (start >= offsetAccEnd[i])
                        {
                            continue;
                        }
                        premLegIntPoints[i] = DoublesScheduleGenerator.truncateSetInclusive(start, offsetAccEnd[i], integrationSchedule).toArray();
                        int n = premLegIntPoints[i].Length;
                        rt[i]     = new double[n];
                        premDF[i] = new double[n];
                        for (int k = 0; k < n; k++)
                        {
                            rt[i][k]     = yieldCurve.zeroRate(premLegIntPoints[i][k]) * premLegIntPoints[i][k];
                            premDF[i][k] = Math.Exp(-rt[i][k]);
                        }
                        premDt[i] = new double[n - 1];

                        for (int k = 1; k < n; k++)
                        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double dt = premLegIntPoints[i][k] - premLegIntPoints[i][k - 1];
                            double dt = premLegIntPoints[i][k] - premLegIntPoints[i][k - 1];
                            premDt[i][k - 1] = dt;
                        }
                    }
                }
                else
                {
                    accRate          = null;
                    offsetAccStart   = null;
                    offsetAccEnd     = null;
                    premDF           = null;
                    premDt           = null;
                    rt               = null;
                    premLegIntPoints = null;
                }
            }
Exemple #10
0
        private Pair <double, PointSensitivityBuilder> singlePeriodAccrualOnDefaultSensitivity(CreditCouponPaymentPeriod coupon, LocalDate effectiveStartDate, DoubleArray integrationSchedule, CreditDiscountFactors discountFactors, LegalEntitySurvivalProbabilities survivalProbabilities)
        {
            LocalDate start = coupon.EffectiveStartDate.isBefore(effectiveStartDate) ? effectiveStartDate : coupon.EffectiveStartDate;

            if (!start.isBefore(coupon.EffectiveEndDate))
            {
                return(Pair.of(0d, PointSensitivityBuilder.none()));  //this coupon has already expired
            }
            DoubleArray knots = DoublesScheduleGenerator.truncateSetInclusive(discountFactors.relativeYearFraction(start), discountFactors.relativeYearFraction(coupon.EffectiveEndDate), integrationSchedule);
            // pv
            double pv = 0d;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int nItems = knots.size();
            int nItems = knots.size();

            double[] dhrtBar = new double[nItems - 1];
            double[] dhtBar  = new double[nItems - 1];
            double[] bBar    = new double[nItems];
            double[] p       = new double[nItems];
            double[] q       = new double[nItems];
            double   t       = knots.get(0);
            double   ht0     = survivalProbabilities.zeroRate(t) * t;
            double   rt0     = discountFactors.zeroRate(t) * t;

            q[0] = Math.Exp(-ht0);
            p[0] = Math.Exp(-rt0);
            double b0       = q[0] * p[0];
            double effStart = discountFactors.relativeYearFraction(coupon.EffectiveStartDate);
            double t0       = t - effStart + omega;

            for (int i = 1; i < nItems; ++i)
            {
                t = knots.get(i);
                double ht1 = survivalProbabilities.zeroRate(t) * t;
                double rt1 = discountFactors.zeroRate(t) * t;
                q[i] = Math.Exp(-ht1);
                p[i] = Math.Exp(-rt1);
                double b1   = q[i] * p[i];
                double dt   = knots.get(i) - knots.get(i - 1);
                double dht  = ht1 - ht0;
                double drt  = rt1 - rt0;
                double dhrt = dht + drt;
                double tPv;
                if (formula == AccrualOnDefaultFormula.MARKIT_FIX)
                {
                    if (Math.Abs(dhrt) < SMALL)
                    {
                        double eps = epsilonP(-dhrt);
                        tPv            = dht * dt * b0 * eps;
                        dhtBar[i - 1]  = dt * b0 * eps;
                        dhrtBar[i - 1] = -dht *dt *b0 *epsilonPP(-dhrt);

                        bBar[i - 1] += dht * eps;
                    }
                    else
                    {
                        tPv            = dht * dt / dhrt * ((b0 - b1) / dhrt - b1);
                        dhtBar[i - 1]  = dt / dhrt * ((b0 - b1) / dhrt - b1);
                        dhrtBar[i - 1] = dht * dt / (dhrt * dhrt) * (b1 - 2d * (b0 - b1) / dhrt);
                        bBar[i - 1]   += dht * dt / (dhrt * dhrt);
                        bBar[i]       += -dht * dt / dhrt * (1d + 1d / dhrt);
                    }
                }
                else
                {
                    double t1 = t - effStart + omega;
                    if (Math.Abs(dhrt) < SMALL)
                    {
                        double eps  = epsilon(-dhrt);
                        double epsp = epsilonP(-dhrt);
                        tPv            = dht * b0 * (t0 * eps + dt * epsp);
                        dhtBar[i - 1]  = b0 * (t0 * eps + dt * epsp);
                        dhrtBar[i - 1] = -dht * b0 * (t0 * epsp + dt * epsilonPP(-dhrt));
                        bBar[i - 1]   += dht * (t0 * eps + dt * epsp);
                    }
                    else
                    {
                        tPv            = dht / dhrt * (t0 * b0 - t1 * b1 + dt / dhrt * (b0 - b1));
                        dhtBar[i - 1]  = (t0 * b0 - t1 * b1 + dt / dhrt * (b0 - b1)) / dhrt;
                        dhrtBar[i - 1] = dht / (dhrt * dhrt) * (-2d * dt / dhrt * (b0 - b1) - t0 * b0 + t1 * b1);
                        bBar[i - 1]   += dht / dhrt * (t0 + dt / dhrt);
                        bBar[i]       += dht / dhrt * (-t1 - dt / dhrt);
                    }
                    t0 = t1;
                }
                pv += tPv;
                ht0 = ht1;
                rt0 = rt1;
                b0  = b1;
            }
            double yfRatio = coupon.YearFraction / discountFactors.DayCount.relativeYearFraction(coupon.StartDate, coupon.EndDate);
            // pv sensitivity
            PointSensitivityBuilder qSensiFirst = survivalProbabilities.zeroRatePointSensitivity(knots.get(0)).multipliedBy(yfRatio * ((dhrtBar[0] + dhtBar[0]) / q[0] + bBar[0] * p[0]));
            PointSensitivityBuilder pSensiFirst = discountFactors.zeroRatePointSensitivity(knots.get(0)).multipliedBy(yfRatio * (dhrtBar[0] / p[0] + bBar[0] * q[0]));
            PointSensitivityBuilder pvSensi     = pSensiFirst.combinedWith(qSensiFirst);

            for (int i = 1; i < nItems - 1; ++i)
            {
                PointSensitivityBuilder qSensi = survivalProbabilities.zeroRatePointSensitivity(knots.get(i)).multipliedBy(yfRatio * (-(dhrtBar[i - 1] + dhtBar[i - 1]) / q[i] + (dhrtBar[i] + dhtBar[i]) / q[i] + bBar[i] * p[i]));
                PointSensitivityBuilder pSensi = discountFactors.zeroRatePointSensitivity(knots.get(i)).multipliedBy(yfRatio * (-dhrtBar[i - 1] / p[i] + dhrtBar[i] / p[i] + bBar[i] * q[i]));
                pvSensi = pvSensi.combinedWith(pSensi).combinedWith(qSensi);
            }
            if (nItems > 1)
            {
                PointSensitivityBuilder qSensiLast = survivalProbabilities.zeroRatePointSensitivity(knots.get(nItems - 1)).multipliedBy(yfRatio * (-(dhrtBar[nItems - 2] + dhtBar[nItems - 2]) / q[nItems - 1] + bBar[nItems - 1] * p[nItems - 1]));
                PointSensitivityBuilder pSensiLast = discountFactors.zeroRatePointSensitivity(knots.get(nItems - 1)).multipliedBy(yfRatio * (-dhrtBar[nItems - 2] / p[nItems - 1] + bBar[nItems - 1] * q[nItems - 1]));
                pvSensi = pvSensi.combinedWith(pSensiLast).combinedWith(qSensiLast);
            }

            return(Pair.of(yfRatio * pv, pvSensi));
        }
Exemple #11
0
        // computes accrual-on-default pv per unit notional for a single payment period
        private double singlePeriodAccrualOnDefault(CreditCouponPaymentPeriod coupon, LocalDate effectiveStartDate, DoubleArray integrationSchedule, CreditDiscountFactors discountFactors, LegalEntitySurvivalProbabilities survivalProbabilities)
        {
            LocalDate start = coupon.EffectiveStartDate.isBefore(effectiveStartDate) ? effectiveStartDate : coupon.EffectiveStartDate;

            if (!start.isBefore(coupon.EffectiveEndDate))
            {
                return(0d);  // this coupon has already expired
            }

            DoubleArray knots = DoublesScheduleGenerator.truncateSetInclusive(discountFactors.relativeYearFraction(start), discountFactors.relativeYearFraction(coupon.EffectiveEndDate), integrationSchedule);

            double t0Knot = knots.get(0);
            double ht0    = survivalProbabilities.zeroRate(t0Knot) * t0Knot;
            double rt0    = discountFactors.zeroRate(t0Knot) * t0Knot;
            double b0     = Math.Exp(-rt0 - ht0);

            double effStart = discountFactors.relativeYearFraction(coupon.EffectiveStartDate);
            double t0       = t0Knot - effStart + omega;
            double pv       = 0d;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int nItems = knots.size();
            int nItems = knots.size();

            for (int j = 1; j < nItems; ++j)
            {
                double t   = knots.get(j);
                double ht1 = survivalProbabilities.zeroRate(t) * t;
                double rt1 = discountFactors.zeroRate(t) * t;
                double b1  = Math.Exp(-rt1 - ht1);

                double dt = knots.get(j) - knots.get(j - 1);

                double dht  = ht1 - ht0;
                double drt  = rt1 - rt0;
                double dhrt = dht + drt;

                double tPV;
                if (formula == AccrualOnDefaultFormula.MARKIT_FIX)
                {
                    if (Math.Abs(dhrt) < SMALL)
                    {
                        tPV = dht * dt * b0 * Epsilon.epsilonP(-dhrt);
                    }
                    else
                    {
                        tPV = dht * dt / dhrt * ((b0 - b1) / dhrt - b1);
                    }
                }
                else
                {
                    double t1 = t - effStart + omega;
                    if (Math.Abs(dhrt) < SMALL)
                    {
                        tPV = dht * b0 * (t0 * epsilon(-dhrt) + dt * Epsilon.epsilonP(-dhrt));
                    }
                    else
                    {
                        tPV = dht / dhrt * (t0 * b0 - t1 * b1 + dt / dhrt * (b0 - b1));
                    }
                    t0 = t1;
                }

                pv += tPV;
                ht0 = ht1;
                rt0 = rt1;
                b0  = b1;
            }

            double yearFractionCurve = discountFactors.DayCount.relativeYearFraction(coupon.StartDate, coupon.EndDate);

            return(coupon.YearFraction * pv / yearFractionCurve);
        }