Esempio n. 1
0
        public void testAccessViolation()
        {
            // Testing dynamic cast of coupon in Black pricer...

            SavedSettings backup = new SavedSettings();

            Date todaysDate = new Date(7, Month.April, 2010);
            Date settlementDate = new Date(9, Month.April, 2010);
            Settings.setEvaluationDate(todaysDate);
            Calendar calendar = new TARGET();

            Handle<YieldTermStructure> rhTermStructure = new Handle<YieldTermStructure>(
                Utilities.flatRate(settlementDate, 0.04875825, new Actual365Fixed()));

            double volatility = 0.10;
            Handle<OptionletVolatilityStructure> vol= new Handle<OptionletVolatilityStructure>(
                new ConstantOptionletVolatility(2,
                                                       calendar,
                                                       BusinessDayConvention.ModifiedFollowing,
                                                       volatility,
                                                       new Actual365Fixed()));

            IborIndex index3m =new USDLibor(new Period(3,TimeUnit.Months), rhTermStructure);

            Date payDate = new Date(20, Month.December, 2013);
            Date startDate = new Date(20, Month.September, 2013);
            Date endDate = new Date(20, Month.December, 2013);
            double spread = 0.0115;
            IborCouponPricer pricer = new BlackIborCouponPricer(vol);
            FloatingRateCoupon coupon = new FloatingRateCoupon(100,payDate, startDate, endDate, 2,
                                                index3m, 1.0 , spread / 100);
            coupon.setPricer(pricer);

            try
            {
                // this caused an access violation in version 1.0
                coupon.amount();
            }
            catch (Exception )
            {
                // ok; proper exception thrown
            }
        }
Esempio n. 2
0
            //public IndexHistoryCleaner indexCleaner;
            // initial setup
            public CommonVars()
            {
                backup = new SavedSettings();
                //indexCleaner = new IndexHistoryCleaner();
                termStructure = new RelinkableHandle<YieldTermStructure>();
                int swapSettlementDays = 2;
                faceAmount = 100.0;
                BusinessDayConvention fixedConvention = BusinessDayConvention.Unadjusted;
                compounding = Compounding.Continuous;
                Frequency fixedFrequency = Frequency.Annual;
                Frequency floatingFrequency = Frequency.Semiannual;
                iborIndex = new Euribor(new Period(floatingFrequency), termStructure);
                Calendar calendar = iborIndex.fixingCalendar();
                swapIndex=  new SwapIndex("EuriborSwapIsdaFixA", new Period(10,TimeUnit.Years), swapSettlementDays,
                                      iborIndex.currency(), calendar,
                                      new Period(fixedFrequency), fixedConvention,
                                      iborIndex.dayCounter(), iborIndex);
                spread = 0.0;
                nonnullspread = 0.003;
                Date today = new Date(24,Month.April,2007);
                Settings.setEvaluationDate(today);

                //Date today = Settings::instance().evaluationDate();
                termStructure.linkTo(Utilities.flatRate(today, 0.05, new Actual365Fixed()));

                pricer = new BlackIborCouponPricer();
                Handle<SwaptionVolatilityStructure> swaptionVolatilityStructure =
                   new Handle<SwaptionVolatilityStructure>(new ConstantSwaptionVolatility(today,
                   new NullCalendar(),BusinessDayConvention.Following, 0.2, new Actual365Fixed()));

                Handle<Quote> meanReversionQuote = new Handle<Quote>(new SimpleQuote(0.01));
                cmspricer = new AnalyticHaganPricer(swaptionVolatilityStructure, GFunctionFactory.YieldCurveModel.Standard, meanReversionQuote);
            }
Esempio n. 3
0
        public void testBondFromScheduleWithDateVector()
        {
            // Testing South African R2048 bond price using Schedule constructor with Date vector
             SavedSettings backup = new SavedSettings();

             //When pricing bond from Yield To Maturity, use NullCalendar()
             Calendar calendar = new NullCalendar();

             int settlementDays = 3;

             Date issueDate = new Date(29, Month.June, 2012);
             Date today = new Date(7, Month.September, 2015);
             Date evaluationDate = calendar.adjust(today);
             Date settlementDate = calendar.advance(evaluationDate, new Period(settlementDays, TimeUnit.Days));
             Settings.setEvaluationDate(evaluationDate);

             // For the schedule to generate correctly for Feb-28's, make maturity date on Feb 29
             Date maturityDate = new Date(29, Month.February, 2048);

             double coupon = 0.0875;
             Compounding comp = Compounding.Compounded;
             Frequency freq = Frequency.Semiannual;
             DayCounter dc = new ActualActual(ActualActual.Convention.Bond);

             // Yield as quoted in market
             InterestRate yield = new InterestRate(0.09185, dc, comp, freq);

             Period tenor = new Period(6, TimeUnit.Months);
             Period exCouponPeriod = new Period(10, TimeUnit.Days);

             // Generate coupon dates for 31 Aug and end of Feb each year
             // For leap years, this will generate 29 Feb, but the bond
             // actually pays coupons on 28 Feb, regardsless of whether
             // it is a leap year or not.
             Schedule schedule = new Schedule(issueDate, maturityDate, tenor,
            new NullCalendar(), BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted,
            DateGeneration.Rule.Backward, true);

             // Adjust the 29 Feb's to 28 Feb
             List<Date> dates = new List<Date>();
             for (int i = 0; i < schedule.Count; ++i)
             {
            Date d = schedule.date(i);
            if (d.Month == 2 && d.Day == 29)
               dates.Add(new Date(28, Month.February, d.Year));
            else
               dates.Add(d);
             }

             schedule = new Schedule(dates,
                                 schedule.calendar(),
                                 schedule.businessDayConvention(),
                                 schedule.terminationDateBusinessDayConvention(),
                                 schedule.tenor(),
                                 schedule.rule(),
                                 schedule.endOfMonth(),
                                 schedule.isRegular());

             FixedRateBond bond = new FixedRateBond(
             0,
             100.0,
             schedule,
             new List<double>() { coupon },
             dc, BusinessDayConvention.Following, 100.0,
             issueDate, calendar,
             exCouponPeriod, calendar, BusinessDayConvention.Unadjusted, false);

             double calculatedPrice = BondFunctions.dirtyPrice(bond, yield, settlementDate);
             double expectedPrice = 95.75706;
             double tolerance = 1e-5;
             if (Math.Abs(calculatedPrice - expectedPrice) > tolerance)
             {
            Assert.Fail(string.Format("failed to reproduce R2048 dirty price\nexpected: {0}\ncalculated: {1}", expectedPrice, calculatedPrice));
             }
        }
Esempio n. 4
0
        public void testSettings()
        {
            // Testing cash-flow settings...
            SavedSettings backup = new SavedSettings();

            Date today = Date.Today;
            Settings.setEvaluationDate(today);

            // cash flows at T+0, T+1, T+2
            List<CashFlow> leg = new List<CashFlow>();

            for (int i=0; i<3; ++i)
                leg.Add(new SimpleCashFlow(1.0, today+i));

            // case 1: don't include reference-date payments, no override at
            //         today's date

            Settings.includeReferenceDateEvents = false;
            Settings.includeTodaysCashFlows = null;

            CHECK_INCLUSION(0, 0, false,leg,today);
            CHECK_INCLUSION(0, 1, false,leg,today);

            CHECK_INCLUSION(1, 0, true,leg,today);
            CHECK_INCLUSION(1, 1, false,leg,today);
            CHECK_INCLUSION(1, 2, false,leg,today);

            CHECK_INCLUSION(2, 1, true,leg,today);
            CHECK_INCLUSION(2, 2, false,leg,today);
            CHECK_INCLUSION(2, 3, false,leg,today);

            // case 2: same, but with explicit setting at today's date

            Settings.includeReferenceDateEvents = false;
            Settings.includeTodaysCashFlows = false;

            CHECK_INCLUSION(0, 0, false,leg,today);
            CHECK_INCLUSION(0, 1, false,leg,today);

            CHECK_INCLUSION(1, 0, true,leg,today);
            CHECK_INCLUSION(1, 1, false,leg,today);
            CHECK_INCLUSION(1, 2, false,leg,today);

            CHECK_INCLUSION(2, 1, true,leg,today);
            CHECK_INCLUSION(2, 2, false,leg,today);
            CHECK_INCLUSION(2, 3, false,leg,today);

            // case 3: do include reference-date payments, no override at
            //         today's date

            Settings.includeReferenceDateEvents = true;
            Settings.includeTodaysCashFlows = null;

            CHECK_INCLUSION(0, 0, true,leg,today);
            CHECK_INCLUSION(0, 1, false,leg,today);

            CHECK_INCLUSION(1, 0, true,leg,today);
            CHECK_INCLUSION(1, 1, true,leg,today);
            CHECK_INCLUSION(1, 2, false,leg,today);

            CHECK_INCLUSION(2, 1, true,leg,today);
            CHECK_INCLUSION(2, 2, true,leg,today);
            CHECK_INCLUSION(2, 3, false,leg,today);

            // case 4: do include reference-date payments, explicit (and same)
            //         setting at today's date

            Settings.includeReferenceDateEvents = true;
            Settings.includeTodaysCashFlows = true;

            CHECK_INCLUSION(0, 0, true,leg,today);
            CHECK_INCLUSION(0, 1, false,leg,today);

            CHECK_INCLUSION(1, 0, true,leg,today);
            CHECK_INCLUSION(1, 1, true,leg,today);
            CHECK_INCLUSION(1, 2, false,leg,today);

            CHECK_INCLUSION(2, 1, true,leg,today);
            CHECK_INCLUSION(2, 2, true,leg,today);
            CHECK_INCLUSION(2, 3, false,leg,today);

            // case 5: do include reference-date payments, override at
            //         today's date

            Settings.includeReferenceDateEvents = true;
            Settings.includeTodaysCashFlows = false;

            CHECK_INCLUSION(0, 0, false,leg,today);
            CHECK_INCLUSION(0, 1, false,leg,today);

            CHECK_INCLUSION(1, 0, true,leg,today);
            CHECK_INCLUSION(1, 1, true,leg,today);
            CHECK_INCLUSION(1, 2, false,leg,today);

            CHECK_INCLUSION(2, 1, true,leg,today);
            CHECK_INCLUSION(2, 2, true,leg,today);
            CHECK_INCLUSION(2, 3, false,leg,today);

            // no discount to make calculations easier
            InterestRate no_discount = new InterestRate(0.0, new Actual365Fixed(), Compounding.Continuous, Frequency.Annual);

            // no override
            Settings.includeTodaysCashFlows = null;

            CHECK_NPV(false, 2.0,no_discount,leg,today);
            CHECK_NPV(true, 3.0,no_discount,leg,today);

            // override
            Settings.includeTodaysCashFlows = false;

            CHECK_NPV(false, 2.0,no_discount,leg,today);
            CHECK_NPV(true, 2.0,no_discount,leg,today);
        }
Esempio n. 5
0
        public void testCachedMarketValue()
        {
            // Testing credit-default swap against cached market values...

            SavedSettings backup = new SavedSettings();

            Settings.setEvaluationDate(new Date(9,Month.June,2006));
            Date evalDate = Settings.evaluationDate();
            Calendar calendar = new UnitedStates();

            List<Date> discountDates = new List<Date>();
            discountDates.Add(evalDate);
            discountDates.Add(calendar.advance(evalDate, 1, TimeUnit.Weeks,  BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 1, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 2, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 3, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 6, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate,12, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 2, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 3, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 4, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 5, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 6, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 7, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 8, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate, 9, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate,10, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            discountDates.Add(calendar.advance(evalDate,15, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));

            List<double> dfs = new List<double>();
            dfs.Add(1.0);
            dfs.Add(0.9990151375768731);
            dfs.Add(0.99570502636871183);
            dfs.Add(0.99118260474528685);
            dfs.Add(0.98661167950906203);
            dfs.Add(0.9732592953359388 );
            dfs.Add(0.94724424481038083);
            dfs.Add(0.89844996737120875 );
            dfs.Add(0.85216647839921411 );
            dfs.Add(0.80775477692556874 );
            dfs.Add(0.76517289234200347 );
            dfs.Add(0.72401019553182933 );
            dfs.Add(0.68503909569219212 );
            dfs.Add(0.64797499814013748 );
            dfs.Add(0.61263171936255534 );
            dfs.Add(0.5791942350748791  );
            dfs.Add(0.43518868769953606 );

            DayCounter curveDayCounter = new Actual360();

            RelinkableHandle<YieldTermStructure> discountCurve = new RelinkableHandle<YieldTermStructure>();
            discountCurve.linkTo( new InterpolatedDiscountCurve<LogLinear>( discountDates, dfs, curveDayCounter,null,null,null,new LogLinear() ) );

            DayCounter dayCounter = new Thirty360();
            List<Date> dates = new List<Date>();
            dates.Add(evalDate);
            dates.Add(calendar.advance(evalDate, 6, TimeUnit.Months, BusinessDayConvention.ModifiedFollowing));
            dates.Add(calendar.advance(evalDate, 1, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            dates.Add(calendar.advance(evalDate, 2, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            dates.Add(calendar.advance(evalDate, 3, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            dates.Add(calendar.advance(evalDate, 4, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            dates.Add(calendar.advance(evalDate, 5, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            dates.Add(calendar.advance(evalDate, 7, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));
            dates.Add(calendar.advance(evalDate,10, TimeUnit.Years, BusinessDayConvention.ModifiedFollowing));

            List<double> defaultProbabilities = new List<double>();
            defaultProbabilities.Add(0.0000);
            defaultProbabilities.Add(0.0047);
            defaultProbabilities.Add(0.0093);
            defaultProbabilities.Add(0.0286);
            defaultProbabilities.Add(0.0619);
            defaultProbabilities.Add(0.0953);
            defaultProbabilities.Add(0.1508);
            defaultProbabilities.Add(0.2288);
            defaultProbabilities.Add(0.3666);

            List<double> hazardRates = new List<double>();
            hazardRates.Add(0.0);
            for (int i=1; i<dates.Count; ++i)
            {
                double t1 = dayCounter.yearFraction(dates[0], dates[i-1]);
                double t2 = dayCounter.yearFraction(dates[0], dates[i]);
                double S1 = 1.0 - defaultProbabilities[i-1];
                double S2 = 1.0 - defaultProbabilities[i];
                hazardRates.Add(Math.Log(S1/S2)/(t2-t1));
            }

            RelinkableHandle<DefaultProbabilityTermStructure> piecewiseFlatHazardRate = new RelinkableHandle<DefaultProbabilityTermStructure>();
            piecewiseFlatHazardRate.linkTo(new InterpolatedHazardRateCurve<BackwardFlat>(dates,hazardRates,new Thirty360()));

            // Testing credit default swap

            // Build the schedule
            Date issueDate = new Date(20, Month.March, 2006);
            Date maturity = new Date(20, Month.June, 2013);
            Frequency cdsFrequency = Frequency.Semiannual;
            BusinessDayConvention cdsConvention = BusinessDayConvention.ModifiedFollowing;

            Schedule schedule = new Schedule(issueDate, maturity, new Period(cdsFrequency), calendar,
                                                   cdsConvention, cdsConvention,
                                                   DateGeneration.Rule.Forward, false);

            // Build the CDS
            double recoveryRate = 0.25;
            double fixedRate=0.0224;
            DayCounter dayCount= new Actual360();
            double cdsNotional=100.0;

            CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, cdsNotional, fixedRate,
                                        schedule, cdsConvention, dayCount, true, true);
            cds.setPricingEngine(new MidPointCdsEngine(piecewiseFlatHazardRate, recoveryRate,discountCurve));

            double calculatedNpv = cds.NPV();
            double calculatedFairRate = cds.fairSpread();

            double npv = -1.364048777;        // from Bloomberg we have 98.15598868 - 100.00;
            double fairRate =  0.0248429452; // from Bloomberg we have 0.0258378;

            double tolerance = 1e-9;

            if (Math.Abs(npv - calculatedNpv) > tolerance)
                Assert.Fail(
                    "Failed to reproduce the npv for the given credit-default swap\n"
                    + "    computed NPV:  " + calculatedNpv + "\n"
                    + "    Given NPV:     " + npv);

            if ( Math.Abs( fairRate - calculatedFairRate ) > tolerance )
                Assert.Fail( "Failed to reproduce the fair rate for the given credit-default swap\n"
                    + "    computed fair rate:  " + calculatedFairRate + "\n"
                    + "    Given fair rate:     " + fairRate );
        }
Esempio n. 6
0
        public void testImpliedHazardRate()
        {
            // Testing implied hazard-rate for credit-default swaps...

            SavedSettings backup = new SavedSettings();

            // Initialize curves
            Calendar calendar = new TARGET();
            Date today = calendar.adjust(Date.Today);
            Settings.setEvaluationDate(today);

            double h1 = 0.30, h2 = 0.40;
            DayCounter dayCounter = new Actual365Fixed();

            List<Date> dates = new List<Date>(3);
            List<double> hazardRates = new List<double>(3);
            dates.Add(today);
            hazardRates.Add(h1);

            dates.Add(today + new Period(5,TimeUnit.Years));
            hazardRates.Add(h1);

            dates.Add(today + new Period(10,TimeUnit.Years));
            hazardRates.Add(h2);

            RelinkableHandle<DefaultProbabilityTermStructure> probabilityCurve =
                new RelinkableHandle<DefaultProbabilityTermStructure>();
            probabilityCurve.linkTo(new InterpolatedHazardRateCurve<BackwardFlat>(dates,
                                                                                            hazardRates,
                                                                                            dayCounter));

            RelinkableHandle<YieldTermStructure> discountCurve = new RelinkableHandle<YieldTermStructure>();
            discountCurve.linkTo(new FlatForward(today,0.03,new Actual360()));

            Frequency frequency = Frequency.Semiannual;
            BusinessDayConvention convention = BusinessDayConvention.ModifiedFollowing;

            Date issueDate = calendar.advance(today, -6, TimeUnit.Months);
            double fixedRate = 0.0120;
            DayCounter cdsDayCount = new Actual360();
            double notional = 10000.0;
            double recoveryRate = 0.4;

            double? latestRate = null;
            for (int n=6; n<=10; ++n)
            {
                Date maturity = calendar.advance(issueDate, n, TimeUnit.Years);
                Schedule schedule = new Schedule(issueDate, maturity, new Period(frequency), calendar,
                                        convention, convention,
                                        DateGeneration.Rule.Forward, false);

                CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
                                            schedule, convention, cdsDayCount,true, true);
                cds.setPricingEngine(new MidPointCdsEngine(probabilityCurve, recoveryRate, discountCurve));

                double NPV = cds.NPV();
                double flatRate = cds.impliedHazardRate(NPV, discountCurve,
                                                                    dayCounter,
                                                                    recoveryRate);

                if (flatRate < h1 || flatRate > h2) {
                    Assert.Fail("implied hazard rate outside expected range\n"
                                    + "    maturity: " + n + " years\n"
                                    + "    expected minimum: " + h1 + "\n"
                                    + "    expected maximum: " + h2 + "\n"
                                    + "    implied rate:     " + flatRate);
                }

                if (n > 6 && flatRate < latestRate) {
                    Assert.Fail("implied hazard rate decreasing with swap maturity\n"
                                    + "    maturity: " + n + " years\n"
                                    + "    previous rate: " + latestRate + "\n"
                                    + "    implied rate:  " + flatRate);
                }

                latestRate = flatRate;

                RelinkableHandle<DefaultProbabilityTermStructure> probability = new RelinkableHandle<DefaultProbabilityTermStructure>();
                probability.linkTo(new FlatHazardRate(	today,new Handle<Quote>(new SimpleQuote(flatRate)),dayCounter));

                CreditDefaultSwap cds2 = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
                                                schedule, convention, cdsDayCount,true, true);
                cds2.setPricingEngine(new MidPointCdsEngine(probability,recoveryRate,discountCurve));

                double NPV2 = cds2.NPV();
                double tolerance = 1.0;
                if (Math.Abs(NPV-NPV2) > tolerance) {
                    Assert.Fail("failed to reproduce NPV with implied rate\n"
                                    + "    expected:   " + NPV + "\n"
                                    + "    calculated: " + NPV2);
                }
            }
        }
Esempio n. 7
0
        public void testFairUpfront()
        {
            // Testing fair-upfront calculation for credit-default swaps...

            SavedSettings backup = new SavedSettings();

            // Initialize curves
            Calendar calendar = new TARGET();
            Date today = calendar.adjust(Date.Today);
            Settings.setEvaluationDate(today);

            Handle<Quote> hazardRate = new Handle<Quote>(new SimpleQuote(0.01234));
            RelinkableHandle<DefaultProbabilityTermStructure> probabilityCurve =
                new RelinkableHandle<DefaultProbabilityTermStructure>();
            probabilityCurve.linkTo(new FlatHazardRate(0, calendar, hazardRate, new Actual360()));

            RelinkableHandle<YieldTermStructure> discountCurve =
                new RelinkableHandle<YieldTermStructure>();
            discountCurve.linkTo(new FlatForward(today,0.06,new Actual360()));

            // Build the schedule
            Date issueDate = today;
            Date maturity = calendar.advance(issueDate, 10, TimeUnit.Years);
            BusinessDayConvention convention = BusinessDayConvention.Following;

            Schedule schedule =
                new MakeSchedule().from(issueDate)
                                       .to(maturity)
                                       .withFrequency(Frequency.Quarterly)
                                       .withCalendar(calendar)
                                       .withTerminationDateConvention(convention)
                                       .withRule(DateGeneration.Rule.TwentiethIMM).value();

            // Build the CDS
            double fixedRate = 0.05;
            double upfront = 0.001;
            DayCounter dayCount = new Actual360();
            double notional = 10000.0;
            double recoveryRate = 0.4;

            IPricingEngine engine = new MidPointCdsEngine(probabilityCurve, recoveryRate,	discountCurve, true);

            CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, notional, upfront, fixedRate,
                                        schedule, convention, dayCount, true, true);
            cds.setPricingEngine(engine);

            double fairUpfront = cds.fairUpfront();

            CreditDefaultSwap fairCds = new CreditDefaultSwap(Protection.Side.Seller, notional,
                                            fairUpfront, fixedRate,	schedule, convention, dayCount, true, true);
            fairCds.setPricingEngine(engine);

            double fairNPV = fairCds.NPV();
            double tolerance = 1e-10;

            if (Math.Abs(fairNPV) > tolerance)
                Assert.Fail(
                    "Failed to reproduce null NPV with calculated fair upfront\n"
                    + "    calculated upfront: " + fairUpfront + "\n"
                    + "    calculated NPV:     " + fairNPV);

            // same with null upfront to begin with
            upfront = 0.0;
            CreditDefaultSwap cds2 = new CreditDefaultSwap(Protection.Side.Seller, notional, upfront, fixedRate,
                                        schedule, convention, dayCount, true, true);
            cds2.setPricingEngine(engine);

            fairUpfront = cds2.fairUpfront();

            CreditDefaultSwap fairCds2 = new CreditDefaultSwap(Protection.Side.Seller, notional,
                                                fairUpfront, fixedRate,	schedule, convention, dayCount, true, true);
            fairCds2.setPricingEngine(engine);

            fairNPV = fairCds2.NPV();

            if (Math.Abs(fairNPV) > tolerance)
                Assert.Fail(
                    "Failed to reproduce null NPV with calculated fair upfront\n"
                    + "    calculated upfront: " + fairUpfront + "\n"
                    + "    calculated NPV:     " + fairNPV);
        }
Esempio n. 8
0
        public void testCachedValue()
        {
            // Testing credit-default swap against cached values...

            SavedSettings backup = new SavedSettings();

            // Initialize curves
            Settings.setEvaluationDate(new Date(9,Month.June,2006));
            Date today = Settings.evaluationDate();
            Calendar calendar = new TARGET();

            Handle<Quote> hazardRate = new Handle<Quote>(new SimpleQuote(0.01234));
            RelinkableHandle<DefaultProbabilityTermStructure> probabilityCurve = new RelinkableHandle<DefaultProbabilityTermStructure>();
            probabilityCurve.linkTo(new FlatHazardRate(0, calendar, hazardRate, new Actual360()));

            RelinkableHandle<YieldTermStructure> discountCurve = new RelinkableHandle<YieldTermStructure>();

            discountCurve.linkTo(new FlatForward(today,0.06,new Actual360()));

            // Build the schedule
            Date issueDate = calendar.advance(today, -1, TimeUnit.Years);
            Date maturity = calendar.advance(issueDate, 10, TimeUnit.Years);
            Frequency frequency = Frequency.Semiannual;
            BusinessDayConvention convention = BusinessDayConvention.ModifiedFollowing;

            Schedule schedule = new Schedule(issueDate, maturity, new Period(frequency), calendar,
                                    convention, convention, DateGeneration.Rule.Forward, false);

            // Build the CDS
            double fixedRate = 0.0120;
            DayCounter dayCount = new Actual360();
            double notional = 10000.0;
            double recoveryRate = 0.4;

            CreditDefaultSwap cds = new CreditDefaultSwap(Protection.Side.Seller, notional, fixedRate,
                                        schedule, convention, dayCount, true, true);
            cds.setPricingEngine(new MidPointCdsEngine(probabilityCurve,recoveryRate,discountCurve));

            double npv = 295.0153398;
            double fairRate = 0.007517539081;

            double calculatedNpv = cds.NPV();
            double calculatedFairRate = cds.fairSpread();
            double tolerance = 1.0e-7;

            if (Math.Abs(calculatedNpv - npv) > tolerance)
                Assert.Fail(
                    "Failed to reproduce NPV with mid-point engine\n"
                    + "    calculated NPV: " + calculatedNpv + "\n"
                    + "    expected NPV:   " + npv);

            if (Math.Abs(calculatedFairRate - fairRate) > tolerance)
                Assert.Fail(
                    "Failed to reproduce fair rate with mid-point engine\n"
                    + "    calculated fair rate: " + calculatedFairRate + "\n"
                    + "    expected fair rate:   " + fairRate);

            cds.setPricingEngine(new IntegralCdsEngine(new Period(1,TimeUnit.Days),probabilityCurve,
                                                                    recoveryRate,discountCurve));

            calculatedNpv = cds.NPV();
            calculatedFairRate = cds.fairSpread();
            tolerance = 1.0e-5;

            if (Math.Abs(calculatedNpv - npv) > notional*tolerance*10)
                Assert.Fail(
                    "Failed to reproduce NPV with integral engine "
                    + "(step = 1 day)\n"
                    + "    calculated NPV: " + calculatedNpv + "\n"
                    + "    expected NPV:   " + npv);

            if (Math.Abs(calculatedFairRate - fairRate) > tolerance)
                Assert.Fail(
                    "Failed to reproduce fair rate with integral engine "
                    + "(step = 1 day)\n"
                    + "    calculated fair rate: " + calculatedFairRate + "\n"
                    + "    expected fair rate:   " + fairRate);

            cds.setPricingEngine(new IntegralCdsEngine(new Period(1,TimeUnit.Weeks),probabilityCurve,recoveryRate,discountCurve));

            calculatedNpv = cds.NPV();
            calculatedFairRate = cds.fairSpread();
            tolerance = 1.0e-5;

            if (Math.Abs(calculatedNpv - npv) > notional*tolerance*10)
                Assert.Fail(
                    "Failed to reproduce NPV with integral engine "
                    +"(step = 1 week)\n"
                    + "    calculated NPV: " + calculatedNpv + "\n"
                    + "    expected NPV:   " + npv);

            if (Math.Abs(calculatedFairRate - fairRate) > tolerance)
                Assert.Fail(
                    "Failed to reproduce fair rate with integral engine "
                    +"(step = 1 week)\n"
                    + "    calculated fair rate: " + calculatedFairRate + "\n"
                    + "    expected fair rate:   " + fairRate);
        }
Esempio n. 9
0
        public void testYYIndex()
        {
            // Testing year-on-year inflation indices

            SavedSettings backup = new SavedSettings();
            //IndexHistoryCleaner cleaner = new IndexHistoryCleaner();

            YYEUHICP yyeuhicp = new YYEUHICP( true );
            if ( yyeuhicp.name() != "EU YY_HICP"
                || yyeuhicp.frequency() != Frequency.Monthly
                || yyeuhicp.revised()
                || !yyeuhicp.interpolated()
                || yyeuhicp.ratio()
                || yyeuhicp.availabilityLag() != new Period( 1, TimeUnit.Months ) )
            {
                Assert.Fail( "wrong year-on-year EU HICP data ("
                            + yyeuhicp.name() + ", "
                            + yyeuhicp.frequency() + ", "
                            + yyeuhicp.revised() + ", "
                            + yyeuhicp.interpolated() + ", "
                            + yyeuhicp.ratio() + ", "
                            + yyeuhicp.availabilityLag() + ")" );
            }

            YYEUHICPr yyeuhicpr = new YYEUHICPr( true );
            if ( yyeuhicpr.name() != "EU YYR_HICP"
                || yyeuhicpr.frequency() != Frequency.Monthly
                || yyeuhicpr.revised()
                || !yyeuhicpr.interpolated()
                || !yyeuhicpr.ratio()
                || yyeuhicpr.availabilityLag() != new Period( 1, TimeUnit.Months ) )
            {
                Assert.Fail( "wrong year-on-year EU HICPr data ("
                                + yyeuhicpr.name() + ", "
                                + yyeuhicpr.frequency() + ", "
                                + yyeuhicpr.revised() + ", "
                                + yyeuhicpr.interpolated() + ", "
                                + yyeuhicpr.ratio() + ", "
                                + yyeuhicpr.availabilityLag() + ")" );
            }

            YYUKRPI yyukrpi = new YYUKRPI( false );
            if ( yyukrpi.name() != "UK YY_RPI"
                || yyukrpi.frequency() != Frequency.Monthly
                || yyukrpi.revised()
                || yyukrpi.interpolated()
                || yyukrpi.ratio()
                || yyukrpi.availabilityLag() != new Period( 1, TimeUnit.Months ) )
            {
                Assert.Fail( "wrong year-on-year UK RPI data ("
                                + yyukrpi.name() + ", "
                                + yyukrpi.frequency() + ", "
                                + yyukrpi.revised() + ", "
                                + yyukrpi.interpolated() + ", "
                                + yyukrpi.ratio() + ", "
                                + yyukrpi.availabilityLag() + ")" );
            }

            YYUKRPIr yyukrpir = new YYUKRPIr( false );
            if ( yyukrpir.name() != "UK YYR_RPI"
                || yyukrpir.frequency() != Frequency.Monthly
                || yyukrpir.revised()
                || yyukrpir.interpolated()
                || !yyukrpir.ratio()
                || yyukrpir.availabilityLag() != new Period( 1, TimeUnit.Months ) )
            {
                Assert.Fail( "wrong year-on-year UK RPIr data ("
                                + yyukrpir.name() + ", "
                                + yyukrpir.frequency() + ", "
                                + yyukrpir.revised() + ", "
                                + yyukrpir.interpolated() + ", "
                                + yyukrpir.ratio() + ", "
                                + yyukrpir.availabilityLag() + ")" );
            }

            // Retrieval test.
            //----------------
            // make sure of the evaluation date
            Date evaluationDate = new Date( 13, Month.August, 2007 );
            evaluationDate = new UnitedKingdom().adjust( evaluationDate );
            Settings.setEvaluationDate( evaluationDate );

            // fixing data
            Date from = new Date( 1, Month.January, 2005 );
            Date to = new Date( 13, Month.August, 2007 );
            Schedule rpiSchedule = new MakeSchedule().from( from ).to( to )
            .withTenor( new Period( 1, TimeUnit.Months ) )
            .withCalendar( new UnitedKingdom() )
            .withConvention( BusinessDayConvention.ModifiedFollowing ).value();

            double[] fixData = { 189.9, 189.9, 189.6, 190.5, 191.6, 192.0,
            192.2, 192.2, 192.6, 193.1, 193.3, 193.6,
            194.1, 193.4, 194.2, 195.0, 196.5, 197.7,
            198.5, 198.5, 199.2, 200.1, 200.4, 201.1,
            202.7, 201.6, 203.1, 204.4, 205.4, 206.2,
            207.3 };

            bool interp = false;
            YYUKRPIr iir = new YYUKRPIr( interp );
            YYUKRPIr iirYES = new YYUKRPIr( true );
            for ( int i = 0; i < fixData.Length; i++ )
            {
                iir.addFixing( rpiSchedule[i], fixData[i] );
                iirYES.addFixing( rpiSchedule[i], fixData[i] );
            }

            Date todayMinusLag = evaluationDate - iir.availabilityLag();
            KeyValuePair<Date, Date> lim0 = Utils.inflationPeriod( todayMinusLag, iir.frequency() );
            todayMinusLag = lim0.Value + 1 - 2 * new Period( iir.frequency() );

            double eps = 1.0e-8;

            // Interpolation tests
            //--------------------
            // (no TS so can't forecast).
            for ( int i = 13; i < rpiSchedule.Count; i++ )
            {
                KeyValuePair<Date, Date> lim = Utils.inflationPeriod( rpiSchedule[i], iir.frequency() );
                KeyValuePair<Date, Date> limBef = Utils.inflationPeriod( rpiSchedule[i - 12], iir.frequency() );
                for ( Date d = lim.Key; d <= lim.Value; d++ )
                {
                    if ( d < todayMinusLag )
                    {
                        double expected = fixData[i] / fixData[i - 12] - 1.0;
                        double calculated = iir.fixing( d );
                        Assert.IsTrue( Math.Abs( calculated - expected ) < eps,
                                                "Non-interpolated fixings not constant within a period: "
                                                + calculated
                                                + ", should be "
                                                + expected );

                        double dp = lim.Value + 1 - lim.Key;
                        double dpBef = limBef.Value + 1 - limBef.Key;
                        double dl = d - lim.Key;
                        // potentially does not work on 29th Feb
                        double dlBef = new NullCalendar().advance( d, -new Period( 1, TimeUnit.Years ),
                            BusinessDayConvention.ModifiedFollowing ) - limBef.Key;

                        double linearNow = fixData[i] + ( fixData[i + 1] - fixData[i] ) * dl / dp;
                        double linearBef = fixData[i - 12] + ( fixData[i + 1 - 12] - fixData[i - 12] ) * dlBef / dpBef;
                        double expectedYES = linearNow / linearBef - 1.0;
                        double calculatedYES = iirYES.fixing( d );
                        Assert.IsTrue( Math.Abs( expectedYES - calculatedYES ) < eps,
                                                "Error in interpolated fixings: expect " + expectedYES
                                                + " see " + calculatedYES
                                                + " flat " + calculated
                                                + ", data: " + fixData[i - 12] + ", " + fixData[i + 1 - 12]
                                                + ", " + fixData[i] + ", " + fixData[i + 1]
                                                + ", fac: " + dp + ", " + dl
                                                + ", " + dpBef + ", " + dlBef
                                                + ", to: " + linearNow + ", " + linearBef
                                                );
                    }
                }
            }
        }
Esempio n. 10
0
        public void testZeroTermStructure()
        {
            // Testing zero inflation term structure...

            SavedSettings backup = new SavedSettings();

            // try the Zero UK
            Calendar calendar = new UnitedKingdom();
            BusinessDayConvention bdc = BusinessDayConvention.ModifiedFollowing;
            Date evaluationDate = new Date( 13, Month.August, 2007 );
            evaluationDate = calendar.adjust( evaluationDate );
            Settings.setEvaluationDate( evaluationDate );

            // fixing data
            Date from = new Date( 1, Month.January, 2005 );
            Date to = new Date( 13, Month.August, 2007 );
            Schedule rpiSchedule = new MakeSchedule().from( from ).to( to )
                                          .withTenor( new Period( 1, TimeUnit.Months ) )
                                          .withCalendar( new UnitedKingdom() )
                                          .withConvention( BusinessDayConvention.ModifiedFollowing )
                                          .value();

            double[] fixData = { 189.9, 189.9, 189.6, 190.5, 191.6, 192.0,
                              192.2, 192.2, 192.6, 193.1, 193.3, 193.6,
                              194.1, 193.4, 194.2, 195.0, 196.5, 197.7,
                              198.5, 198.5, 199.2, 200.1, 200.4, 201.1,
                              202.7, 201.6, 203.1, 204.4, 205.4, 206.2,
                              207.3, 206.1,  -999.0 };

            RelinkableHandle<ZeroInflationTermStructure> hz = new RelinkableHandle<ZeroInflationTermStructure>();
            bool interp = false;
            UKRPI iiUKRPI = new UKRPI( interp, hz );
            for ( int i = 0; i < rpiSchedule.Count; i++ )
            {
                iiUKRPI.addFixing( rpiSchedule[i], fixData[i] );
            }

            ZeroInflationIndex ii = iiUKRPI as ZeroInflationIndex;
            YieldTermStructure nominalTS = nominalTermStructure();

            // now build the zero inflation curve

            Datum[] zcData = {
               new Datum( new Date(13, Month.August, 2008), 2.93 ),
               new Datum( new Date(13, Month.August, 2009), 2.95 ),
               new Datum( new Date(13, Month.August, 2010), 2.965 ),
               new Datum( new Date(15, Month.August, 2011), 2.98 ),
               new Datum( new Date(13, Month.August, 2012), 3.0 ),
               new Datum( new Date(13, Month.August, 2014), 3.06 ),
               new Datum( new Date(13, Month.August, 2017), 3.175 ),
               new Datum( new Date(13, Month.August, 2019), 3.243 ),
               new Datum( new Date(15, Month.August, 2022), 3.293 ),
               new Datum( new Date(14, Month.August, 2027), 3.338 ),
               new Datum( new Date(13, Month.August, 2032), 3.348 ),
               new Datum( new Date(15, Month.August, 2037), 3.348 ),
               new Datum( new Date(13, Month.August, 2047), 3.308 ),
               new Datum( new Date(13, Month.August, 2057), 3.228 )};

            Period observationLag = new Period( 2, TimeUnit.Months );
            DayCounter dc = new Thirty360();
            Frequency frequency = Frequency.Monthly;
            List<BootstrapHelper<ZeroInflationTermStructure>> helpers =
                makeHelpers( zcData, zcData.Length, ii,
                                                observationLag,
                                                calendar, bdc, dc );

            double baseZeroRate = zcData[0].rate / 100.0;
            PiecewiseZeroInflationCurve<Linear> pZITS = new PiecewiseZeroInflationCurve<Linear>(
                                evaluationDate, calendar, dc, observationLag,
                                frequency, ii.interpolated(), baseZeroRate,
                                new Handle<YieldTermStructure>( nominalTS ), helpers );
            pZITS.recalculate();

            // first check that the zero rates on the curve match the data
            // and that the helpers give the correct impled rates
            const double eps = 0.00000001;
            bool forceLinearInterpolation = false;
            for ( int i = 0; i < zcData.Length; i++ )
            {
                Assert.IsTrue( Math.Abs( zcData[i].rate / 100.0
                - pZITS.zeroRate( zcData[i].date, observationLag, forceLinearInterpolation ) ) < eps,
                "ZITS zeroRate != instrument "
                + pZITS.zeroRate( zcData[i].date, observationLag, forceLinearInterpolation )
                + " vs " + zcData[i].rate / 100.0
                + " interpolation: " + ii.interpolated()
                + " forceLinearInterpolation " + forceLinearInterpolation );

                Assert.IsTrue( Math.Abs( helpers[i].impliedQuote()
                - zcData[i].rate / 100.0 ) < eps,
                "ZITS implied quote != instrument "
                + helpers[i].impliedQuote()
                + " vs " + zcData[i].rate / 100.0 );
            }

            // now test the forecasting capability of the index.
            hz.linkTo( pZITS );
            from = hz.link.baseDate();
            to = hz.link.maxDate() - new Period( 1, TimeUnit.Months ); // a bit of margin for adjustments
            Schedule testIndex = new MakeSchedule().from( from ).to( to )
                                            .withTenor( new Period( 1, TimeUnit.Months ) )
                                            .withCalendar( new UnitedKingdom() )
                                            .withConvention( BusinessDayConvention.ModifiedFollowing ).value();

            // we are testing UKRPI which is not interpolated
            Date bd = hz.link.baseDate();
            double bf = ii.fixing( bd );
            for ( int i = 0; i < testIndex.Count; i++ )
            {
                Date d = testIndex[i];
                double z = hz.link.zeroRate( d, new Period( 0, TimeUnit.Days ) );
                double t = hz.link.dayCounter().yearFraction( bd, d );
                if ( !ii.interpolated() ) // because fixing constant over period
                    t = hz.link.dayCounter().yearFraction( bd,
                     Utils.inflationPeriod( d, ii.frequency() ).Key );
                double calc = bf * Math.Pow( 1 + z, t );
                if ( t <= 0 )
                    calc = ii.fixing( d, false ); // still historical
                if ( Math.Abs( calc - ii.fixing( d, true ) ) / 10000.0 > eps )
                    Assert.Fail( "ZC index does not forecast correctly for date " + d
                                + " from base date " + bd
                                + " with fixing " + bf
                                + ", correct:  " + calc
                                + ", fix: " + ii.fixing( d, true )
                                + ", t " + t );
            }

            //===========================================================================================
            // Test zero-inflation-indexed (i.e. cpi ratio) cashflow
            // just ordinary indexed cashflow with a zero inflation index

            Date baseDate = new Date( 1, Month.January, 2006 );
            Date fixDate = new Date( 1, Month.August, 2014 );
            Date payDate = new UnitedKingdom().adjust( fixDate + new Period( 3, TimeUnit.Months ), BusinessDayConvention.ModifiedFollowing );
            Index ind = ii as Index;
             Utils.QL_REQUIRE( ind != null, () => "dynamic_pointer_cast to Index from InflationIndex failed" );

            double notional = 1000000.0;//1m
            IndexedCashFlow iicf = new IndexedCashFlow( notional, ind, baseDate, fixDate, payDate );
            double correctIndexed = ii.fixing( iicf.fixingDate() ) / ii.fixing( iicf.baseDate() );
            double calculatedIndexed = iicf.amount() / iicf.notional();
            Assert.IsTrue( Math.Abs( correctIndexed - calculatedIndexed ) < eps,
                                  "IndexedCashFlow indexing wrong: " + calculatedIndexed + " vs correct = "
                                  + correctIndexed );

            //===========================================================================================
            // Test zero coupon swap

            // first make one ...

            ZeroInflationIndex zii = ii as ZeroInflationIndex;
             Utils.QL_REQUIRE( zii != null, () => "dynamic_pointer_cast to ZeroInflationIndex from UKRPI failed" );
            ZeroCouponInflationSwap nzcis =
                new ZeroCouponInflationSwap( ZeroCouponInflationSwap.Type.Payer,
                                                     1000000.0,
                                                     evaluationDate,
                                                     zcData[6].date,    // end date = maturity
                                                     calendar, bdc, dc, zcData[6].rate / 100.0, // fixed rate
                                                     zii, observationLag );

            // N.B. no coupon pricer because it is not a coupon, effect of inflation curve via
            //      inflation curve attached to the inflation index.
            Handle<YieldTermStructure> hTS = new Handle<YieldTermStructure>( nominalTS );
            IPricingEngine sppe = new DiscountingSwapEngine( hTS );
            nzcis.setPricingEngine( sppe );

            // ... and price it, should be zero
            Assert.IsTrue( Math.Abs( nzcis.NPV() ) < 0.00001, "ZCIS does not reprice to zero "
                              + nzcis.NPV()
                              + evaluationDate + " to " + zcData[6].date + " becoming " + nzcis.maturityDate()
                              + " rate " + zcData[6].rate
                              + " fixed leg " + nzcis.legNPV( 0 )
                              + " indexed-predicted inflated leg " + nzcis.legNPV( 1 )
                              + " discount " + nominalTS.discount( nzcis.maturityDate() ) );

            //===========================================================================================
            // Test multiplicative seasonality in price
            //

            //Seasonality factors NOT normalized
            //and UKRPI is not interpolated
            Date trueBaseDate = Utils.inflationPeriod( hz.link.baseDate(), ii.frequency() ).Value;
            Date seasonallityBaseDate = new Date( 31, Month.January, trueBaseDate.year() );
            List<double> seasonalityFactors = new List<double>( 12 );
            seasonalityFactors.Add( 1.003245 );
            seasonalityFactors.Add( 1.000000 );
            seasonalityFactors.Add( 0.999715 );
            seasonalityFactors.Add( 1.000495 );
            seasonalityFactors.Add( 1.000929 );
            seasonalityFactors.Add( 0.998687 );
            seasonalityFactors.Add( 0.995949 );
            seasonalityFactors.Add( 0.994682 );
            seasonalityFactors.Add( 0.995949 );
            seasonalityFactors.Add( 1.000519 );
            seasonalityFactors.Add( 1.003705 );
            seasonalityFactors.Add( 1.004186 );

            //Creating two different seasonality objects
            //
            MultiplicativePriceSeasonality seasonality_1 = new MultiplicativePriceSeasonality();
            InitializedList<double> seasonalityFactors_1 = new InitializedList<double>( 12, 1.0 );
            seasonality_1.set( seasonallityBaseDate, Frequency.Monthly, seasonalityFactors_1 );

            MultiplicativePriceSeasonality seasonality_real =
                new MultiplicativePriceSeasonality( seasonallityBaseDate, Frequency.Monthly, seasonalityFactors );
            //Testing seasonality correction when seasonality factors are = 1
            //
            double[] fixing = {
            ii.fixing(new Date(14,Month.January  ,2013),true),
            ii.fixing(new Date(14,Month.February ,2013),true),
            ii.fixing(new Date(14,Month.March    ,2013),true),
            ii.fixing(new Date(14,Month.April    ,2013),true),
            ii.fixing(new Date(14,Month.May      ,2013),true),
            ii.fixing(new Date(14,Month.June     ,2013),true),
            ii.fixing(new Date(14,Month.July     ,2013),true),
            ii.fixing(new Date(14,Month.August   ,2013),true),
            ii.fixing(new Date(14,Month.September,2013),true),
            ii.fixing(new Date(14,Month.October  ,2013),true),
            ii.fixing(new Date(14,Month.November ,2013),true),
            ii.fixing(new Date(14,Month.December ,2013),true)
             };

            hz.link.setSeasonality( seasonality_1 );
             Utils.QL_REQUIRE( hz.link.hasSeasonality(), () => "[44] incorrectly believes NO seasonality correction" );

            double[] seasonalityFixing_1 = {
            ii.fixing(new Date(14,Month.January  ,2013),true),
            ii.fixing(new Date(14,Month.February ,2013),true),
            ii.fixing(new Date(14,Month.March    ,2013),true),
            ii.fixing(new Date(14,Month.April    ,2013),true),
            ii.fixing(new Date(14,Month.May      ,2013),true),
            ii.fixing(new Date(14,Month.June     ,2013),true),
            ii.fixing(new Date(14,Month.July     ,2013),true),
            ii.fixing(new Date(14,Month.August   ,2013),true),
            ii.fixing(new Date(14,Month.September,2013),true),
            ii.fixing(new Date(14,Month.October  ,2013),true),
            ii.fixing(new Date(14,Month.November ,2013),true),
            ii.fixing(new Date(14,Month.December ,2013),true)
             };

            for ( int i = 0; i < 12; i++ )
            {
                if ( Math.Abs( fixing[i] - seasonalityFixing_1[i] ) > eps )
                {
                    Assert.Fail( "Seasonality doesn't work correctly when seasonality factors are set = 1" );
                }
            }

            //Testing seasonality correction when seasonality factors are different from 1
            //
            //0.998687 is the seasonality factor corresponding to June (the base CPI curve month)
            //
            double[] expectedFixing = {
            ii.fixing(new Date(14,Month.January  ,2013),true) * 1.003245/0.998687,
            ii.fixing(new Date(14,Month.February ,2013),true) * 1.000000/0.998687,
            ii.fixing(new Date(14,Month.March    ,2013),true) * 0.999715/0.998687,
            ii.fixing(new Date(14,Month.April    ,2013),true) * 1.000495/0.998687,
            ii.fixing(new Date(14,Month.May      ,2013),true) * 1.000929/0.998687,
            ii.fixing(new Date(14,Month.June     ,2013),true) * 0.998687/0.998687,
            ii.fixing(new Date(14,Month.July     ,2013),true) * 0.995949/0.998687,
            ii.fixing(new Date(14,Month.August   ,2013),true) * 0.994682/0.998687,
            ii.fixing(new Date(14,Month.September,2013),true) * 0.995949/0.998687,
            ii.fixing(new Date(14,Month.October  ,2013),true) * 1.000519/0.998687,
            ii.fixing(new Date(14,Month.November ,2013),true) * 1.003705/0.998687,
            ii.fixing(new Date(14,Month.December ,2013),true) * 1.004186/0.998687
             };

            hz.link.setSeasonality( seasonality_real );

            double[] seasonalityFixing_real = {
            ii.fixing(new Date(14,Month.January  ,2013),true),
            ii.fixing(new Date(14,Month.February ,2013),true),
            ii.fixing(new Date(14,Month.March    ,2013),true),
            ii.fixing(new Date(14,Month.April    ,2013),true),
            ii.fixing(new Date(14,Month.May      ,2013),true),
            ii.fixing(new Date(14,Month.June     ,2013),true),
            ii.fixing(new Date(14,Month.July     ,2013),true),
            ii.fixing(new Date(14,Month.August   ,2013),true),
            ii.fixing(new Date(14,Month.September,2013),true),
            ii.fixing(new Date(14,Month.October  ,2013),true),
            ii.fixing(new Date(14,Month.November ,2013),true),
            ii.fixing(new Date(14,Month.December ,2013),true)
             };

            for ( int i = 0; i < 12; i++ )
            {
                if ( Math.Abs( expectedFixing[i] - seasonalityFixing_real[i] ) > 0.01 )
                {
                    Assert.Fail( "Seasonality doesn't work correctly when considering seasonality factors != 1 "
                                    + expectedFixing[i] + " vs " + seasonalityFixing_real[i] );
                }
            }

            //Testing Unset function
            //
             Utils.QL_REQUIRE( hz.link.hasSeasonality(), () => "[4] incorrectly believes NO seasonality correction" );
            hz.link.setSeasonality();
             Utils.QL_REQUIRE( !hz.link.hasSeasonality(), () => "[5] incorrectly believes HAS seasonality correction" );

            double[] seasonalityFixing_unset = {
            ii.fixing(new Date(14,Month.January  ,2013),true),
            ii.fixing(new Date(14,Month.February ,2013),true),
            ii.fixing(new Date(14,Month.March    ,2013),true),
            ii.fixing(new Date(14,Month.April    ,2013),true),
            ii.fixing(new Date(14,Month.May      ,2013),true),
            ii.fixing(new Date(14,Month.June     ,2013),true),
            ii.fixing(new Date(14,Month.July     ,2013),true),
            ii.fixing(new Date(14,Month.August   ,2013),true),
            ii.fixing(new Date(14,Month.September,2013),true),
            ii.fixing(new Date(14,Month.October  ,2013),true),
            ii.fixing(new Date(14,Month.November ,2013),true),
            ii.fixing(new Date(14,Month.December ,2013),true)
             };

            for ( int i = 0; i < 12; i++ )
            {
                if ( Math.Abs( seasonalityFixing_unset[i] - seasonalityFixing_1[i] ) > eps )
                {
                    Assert.Fail( "UnsetSeasonality doesn't work correctly "
                                    + seasonalityFixing_unset[i] + " vs " + seasonalityFixing_1[i] );
                }
            }

            //==============================================================================
            // now do an INTERPOLATED index, i.e. repeat everything on a fake version of
            // UKRPI (to save making another term structure)

            bool interpYES = true;
            UKRPI iiUKRPIyes = new UKRPI( interpYES, hz );
            for ( int i = 0; i < fixData.Length; i++ )
            {
                iiUKRPIyes.addFixing( rpiSchedule[i], fixData[i] );
            }

            ZeroInflationIndex iiyes = iiUKRPIyes as ZeroInflationIndex;

            // now build the zero inflation curve
            // same data, bigger lag or it will be a self-contradiction
            Period observationLagyes = new Period( 3, TimeUnit.Months );
            List<BootstrapHelper<ZeroInflationTermStructure>> helpersyes =
                makeHelpers( zcData, zcData.Length,
                iiyes, observationLagyes, calendar, bdc, dc );

            PiecewiseZeroInflationCurve<Linear> pZITSyes =
                    new PiecewiseZeroInflationCurve<Linear>(
                    evaluationDate, calendar, dc, observationLagyes,
                    frequency, iiyes.interpolated(), baseZeroRate,
                    new Handle<YieldTermStructure>( nominalTS ), helpersyes );
            pZITSyes.recalculate();

            // first check that the zero rates on the curve match the data
            // and that the helpers give the correct impled rates
            forceLinearInterpolation = false;   // still
            for ( int i = 0; i < zcData.Length; i++ )
            {
                Assert.IsTrue( Math.Abs( zcData[i].rate / 100.0
                                - pZITSyes.zeroRate( zcData[i].date, observationLagyes, forceLinearInterpolation ) ) < eps,
                                "ZITS INTERPOLATED zeroRate != instrument "
                                + pZITSyes.zeroRate( zcData[i].date, observationLagyes, forceLinearInterpolation )
                                + " date " + zcData[i].date + " observationLagyes " + observationLagyes
                                + " vs " + zcData[i].rate / 100.0
                                + " interpolation: " + iiyes.interpolated()
                                + " forceLinearInterpolation " + forceLinearInterpolation );
                Assert.IsTrue( Math.Abs( helpersyes[i].impliedQuote()
                                    - zcData[i].rate / 100.0 ) < eps,
                                "ZITS INTERPOLATED implied quote != instrument "
                                + helpersyes[i].impliedQuote()
                                + " vs " + zcData[i].rate / 100.0 );
            }

            //======================================================================================
            // now test the forecasting capability of the index.
            hz.linkTo( pZITSyes );
            from = hz.link.baseDate() + new Period( 1, TimeUnit.Months ); // to avoid historical linear bit for rest of base month
            to = hz.link.maxDate() - new Period( 1, TimeUnit.Months ); // a bit of margin for adjustments
            testIndex = new MakeSchedule().from( from ).to( to )
            .withTenor( new Period( 1, TimeUnit.Months ) )
            .withCalendar( new UnitedKingdom() )
            .withConvention( BusinessDayConvention.ModifiedFollowing ).value();

            // we are testing UKRPI which is FAKE interpolated for testing here
            bd = hz.link.baseDate();
            bf = iiyes.fixing( bd );
            for ( int i = 0; i < testIndex.Count; i++ )
            {
                Date d = testIndex[i];
                double z = hz.link.zeroRate( d, new Period( 0, TimeUnit.Days ) );
                double t = hz.link.dayCounter().yearFraction( bd, d );
                double calc = bf * Math.Pow( 1 + z, t );
                if ( t <= 0 ) calc = iiyes.fixing( d ); // still historical
                if ( Math.Abs( calc - iiyes.fixing( d ) ) > eps )
                    Assert.Fail( "ZC INTERPOLATED index does not forecast correctly for date " + d
                                    + " from base date " + bd
                                    + " with fixing " + bf
                                    + ", correct:  " + calc
                                    + ", fix: " + iiyes.fixing( d )
                                    + ", t " + t
                                    + ", zero " + z );
            }

            //===========================================================================================
            // Test zero coupon swap

            ZeroInflationIndex ziiyes = iiyes as ZeroInflationIndex;
             Utils.QL_REQUIRE( ziiyes != null, () => "dynamic_pointer_cast to ZeroInflationIndex from UKRPI-I failed" );
            ZeroCouponInflationSwap nzcisyes = new ZeroCouponInflationSwap( ZeroCouponInflationSwap.Type.Payer,
                                                              1000000.0,
                                                              evaluationDate,
                                                              zcData[6].date,    // end date = maturity
                                                              calendar, bdc, dc, zcData[6].rate / 100.0, // fixed rate
                                                              ziiyes, observationLagyes );

            // N.B. no coupon pricer because it is not a coupon, effect of inflation curve via
            //      inflation curve attached to the inflation index.
            nzcisyes.setPricingEngine( sppe );

            // ... and price it, should be zero
            Assert.IsTrue( Math.Abs( nzcisyes.NPV() ) < 0.00001, "ZCIS-I does not reprice to zero "
                                    + nzcisyes.NPV()
                                    + evaluationDate + " to " + zcData[6].date + " becoming " + nzcisyes.maturityDate()
                                    + " rate " + zcData[6].rate
                                    + " fixed leg " + nzcisyes.legNPV( 0 )
                                    + " indexed-predicted inflated leg " + nzcisyes.legNPV( 1 )
                                    + " discount " + nominalTS.discount( nzcisyes.maturityDate() )
                                    );

            // remove circular refernce
            hz.linkTo( new ZeroInflationTermStructure() );
        }
Esempio n. 11
0
        public void testYYTermStructure()
        {
            // Testing year-on-year inflation term structure...

            SavedSettings backup = new SavedSettings();
            //IndexHistoryCleaner cleaner;

            // try the YY UK
            Calendar calendar = new UnitedKingdom();
            BusinessDayConvention bdc = BusinessDayConvention.ModifiedFollowing;
            Date evaluationDate = new Date(13, Month.August, 2007);
            evaluationDate = calendar.adjust(evaluationDate);
            Settings.setEvaluationDate(evaluationDate);

            // fixing data
            Date from = new Date(1, Month.January, 2005);
            Date to = new Date(13, Month.August, 2007);
            Schedule rpiSchedule = new MakeSchedule().from(from).to(to)
            .withTenor(new Period(1,TimeUnit.Months))
            .withCalendar(new UnitedKingdom())
            .withConvention(BusinessDayConvention.ModifiedFollowing).value();
            double[] fixData = { 189.9, 189.9, 189.6, 190.5, 191.6, 192.0,
                192.2, 192.2, 192.6, 193.1, 193.3, 193.6,
                194.1, 193.4, 194.2, 195.0, 196.5, 197.7,
                198.5, 198.5, 199.2, 200.1, 200.4, 201.1,
                202.7, 201.6, 203.1, 204.4, 205.4, 206.2,
                207.3 };

            RelinkableHandle<YoYInflationTermStructure> hy = new RelinkableHandle<YoYInflationTermStructure>();
            bool interp = false;
            YYUKRPIr iir = new YYUKRPIr(interp, hy);
            for (int i=0; i<fixData.Length; i++)
            {
                iir.addFixing(rpiSchedule[i], fixData[i]);
            }

            YieldTermStructure nominalTS = nominalTermStructure();

            // now build the YoY inflation curve
            Datum[] yyData = {
                new Datum( new Date(13, Month.August, 2008), 2.95 ),
                new Datum( new Date(13, Month.August, 2009), 2.95 ),
                new Datum( new Date(13, Month.August, 2010), 2.93 ),
                new Datum( new Date(15, Month.August, 2011), 2.955 ),
                new Datum( new Date(13, Month.August, 2012), 2.945 ),
                new Datum( new Date(13, Month.August, 2013), 2.985 ),
                new Datum( new Date(13, Month.August, 2014), 3.01 ),
                new Datum( new Date(13, Month.August, 2015), 3.035 ),
                new Datum( new Date(13, Month.August, 2016), 3.055 ),  // note that
                new Datum( new Date(13, Month.August, 2017), 3.075 ),  // some dates will be on
                new Datum( new Date(13, Month.August, 2019), 3.105 ),  // holidays but the payment
                new Datum( new Date(15, Month.August, 2022), 3.135 ),  // calendar will roll them
                new Datum( new Date(13, Month.August, 2027), 3.155 ),
                new Datum( new Date(13, Month.August, 2032), 3.145 ),
                new Datum( new Date(13, Month.August, 2037), 3.145 )
            };

            Period observationLag = new Period(2,TimeUnit.Months);
            DayCounter dc = new Thirty360();

            // now build the helpers ...
            List<BootstrapHelper<YoYInflationTermStructure>> helpers =
            makeHelpers (yyData, yyData.Length, iir,observationLag, calendar, bdc, dc);

            double baseYYRate = yyData[0].rate/100.0;
            PiecewiseYoYInflationCurve<Linear> pYYTS = new PiecewiseYoYInflationCurve<Linear>(
                            evaluationDate, calendar, dc, observationLag,
                            iir.frequency(),iir.interpolated(), baseYYRate,
                            new Handle<YieldTermStructure>(nominalTS), helpers);
            pYYTS.recalculate();

            // validation
            // yoy swaps should reprice to zero
            // yy rates should not equal yySwap rates
            double eps = 0.000001;
            // usual swap engine
            Handle<YieldTermStructure> hTS = new Handle<YieldTermStructure>(nominalTS);
            IPricingEngine sppe = new DiscountingSwapEngine(hTS);

            // make sure that the index has the latest yoy term structure
            hy.linkTo(pYYTS);

            for (int j = 1; j < yyData.Length; j++)
            {

                from = nominalTS.referenceDate();
                to = yyData[j].date;
                Schedule yoySchedule = new MakeSchedule().from(from).to(to)
                .withConvention(BusinessDayConvention.Unadjusted) // fixed leg gets calendar from
                .withCalendar(calendar)     // schedule
                .withTenor(new Period(1,TimeUnit.Years)).value(); // .back

                YearOnYearInflationSwap yyS2 = new YearOnYearInflationSwap(
                    YearOnYearInflationSwap.Type.Payer,
                    1000000.0,
                    yoySchedule,//fixed schedule, but same as yoy
                    yyData[j].rate/100.0,
                    dc,
                    yoySchedule,
                    iir,
                    observationLag,
                    0.0,        //spread on index
                    dc,
                    new UnitedKingdom());

                yyS2.setPricingEngine(sppe);

                Assert.IsTrue(Math.Abs(yyS2.NPV())<eps,"fresh yoy swap NPV!=0 from TS "
                            +"swap quote for pt " + j
                            + ", is " + yyData[j].rate/100.0
                            +" vs YoY rate "+ pYYTS.yoyRate(yyData[j].date-observationLag)
                            +" at quote date "+(yyData[j].date-observationLag)
                            +", NPV of a fresh yoy swap is " + yyS2.NPV()
                            +"\n      fair rate " + yyS2.fairRate()
                            +" payment "+yyS2.paymentConvention());
            }

            int jj=3;
            for (int k = 0; k < 14; k++)
            {
                from = nominalTS.referenceDate() - new Period(k,TimeUnit.Months);
                to = yyData[jj].date - new Period(k,TimeUnit.Months);
                Schedule yoySchedule = new MakeSchedule().from(from).to(to)
                .withConvention(BusinessDayConvention.Unadjusted) // fixed leg gets calendar from
                .withCalendar(calendar)     // schedule
                .withTenor(new Period(1,TimeUnit.Years))
                .value(); //backwards()

                YearOnYearInflationSwap yyS3 = new YearOnYearInflationSwap(
                    YearOnYearInflationSwap.Type.Payer,
                    1000000.0,
                    yoySchedule,//fixed schedule, but same as yoy
                    yyData[jj].rate/100.0,
                    dc,
                    yoySchedule,
                    iir,
                    observationLag,
                    0.0,        //spread on index
                    dc,
                    new UnitedKingdom());

                yyS3.setPricingEngine(sppe);

                Assert.IsTrue(Math.Abs(yyS3.NPV())< 20000.0,
                                            "unexpected size of aged YoY swap, aged "
                                            + k +" months: YY aged NPV = " + yyS3.NPV()
                                            +", legs "+ yyS3.legNPV(0) + " and " + yyS3.legNPV(1)
                                            );
            }
            // remove circular refernce
            hy.linkTo( new YoYInflationTermStructure());
        }