Examples of org.jquantlib.time.Schedule

org.jquantlib.time.Schedule
@author Zahid Hussain

            for (int n = 0; n < (compounding).length; n++) {
              final Date dated = calendar.advance(today, issueMonths[i], TimeUnit.Months);
              final Date issue = dated;
              final Date maturity = calendar.advance(issue, lengths[j], TimeUnit.Years);


              final Schedule sch = new Schedule(
                      dated,
                  maturity,
                  new Period(frequencies[l]),
                  calendar,
                  accrualConvention,

View Full Code Here

          final Date maturity = calendar.advance(issue, length, TimeUnit.Years);


          final SimpleQuote rate = new SimpleQuote(0.0);
          final Handle<YieldTermStructure> discountCurve = new Handle<YieldTermStructure>(Utilities.flatRate(today, rate, bondDayCount));


          final Schedule sch = new Schedule(
                  dated, maturity,
              new Period(frequency), calendar,
              accrualConvention, accrualConvention,
              Rule.Backward, false);

View Full Code Here

    final Handle<YieldTermStructure> discountCurve = new Handle<YieldTermStructure>(Utilities.flatRate(today, 0.03, new Actual360()));


      // actual market values from the evaluation date


      final Frequency freq = Frequency.Semiannual;
      final Schedule sch1 = new Schedule(new Date(31, Month.October, 2004),
                    new Date(31, Month.October, 2006), new Period(freq), bondCalendar,
                    BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted, DateGeneration.Rule.Backward, false);


      final FixedRateBond bond1 = new FixedRateBond(settlementDays, faceAmount, sch1,
                          new double[] {0.025},
                          bondDayCount, BusinessDayConvention.ModifiedFollowing,
                          100.0, new Date(1, Month.November, 2004));


    final PricingEngine bondEngine = new DiscountingBondEngine(discountCurve);


      bond1.setPricingEngine(bondEngine);


      final double marketPrice1 = 99.203125;
      final double marketYield1 = 0.02925;


      final Schedule sch2 = new Schedule(new Date(15, Month.November, 2004),
          new Date(15, Month.November, 2009), new Period(freq), bondCalendar,
          BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted, DateGeneration.Rule.Backward, false);


      final FixedRateBond bond2 = new FixedRateBond(settlementDays, faceAmount, sch2,
                          new double [] {0.035},
                          bondDayCount, BusinessDayConvention.ModifiedFollowing,
                          100.0, new Date(15, Month.November, 2004));


      bond2.setPricingEngine(bondEngine);


      final double marketPrice2 = 99.6875;
      final double marketYield2 = 0.03569;


      // calculated values


      final double cachedPrice1a = 99.204505, cachedPrice2a = 99.687192;
      final double cachedPrice1b = 98.943393, cachedPrice2b = 101.986794;
      final double cachedYield1a = 0.029257,  cachedYield2a = 0.035689;
      final double cachedYield1b = 0.029045,  cachedYield2b = 0.035375;
      final double cachedYield1c = 0.030423,  cachedYield2c = 0.030432;


      // check
      final double tolerance = 1.0e-6;
      double price, yield;


      price = bond1.cleanPrice(marketYield1,
                               bondDayCount, Compounding.Compounded, freq);
      if (Math.abs(price-cachedPrice1a) > tolerance) {
        fail("failed to reproduce cached price:"
                     + "\n    calculated: " + price
                     + "\n    expected:   " + cachedPrice1a
                     + "\n    tolerance:  " + tolerance
                     + "\n    error:      " + (price-cachedPrice1a));
      }


      price = bond1.getCleanPrice();
      if (Math.abs(price-cachedPrice1b) > tolerance) {
        fail("failed to reproduce cached price:"
                     + "\n    calculated: " + price
                     + "\n    expected:   " + cachedPrice1b
                     + "\n    tolerance:  " + tolerance
                     + "\n    error:      " + (price-cachedPrice1b));
      }


      yield = bond1.yield(marketPrice1, bondDayCount, Compounding.Compounded, freq);
      if (Math.abs(yield-cachedYield1a) > tolerance) {
        fail("failed to reproduce cached compounded yield:"
                     + "\n    calculated: " + yield
                     + "\n    expected:   " + cachedYield1a
                     + "\n    tolerance:  " + tolerance
                     + "\n    error:      " + (yield-cachedYield1a));
      }


      yield = bond1.yield(marketPrice1, bondDayCount, Compounding.Continuous, freq);
      if (Math.abs(yield-cachedYield1b) > tolerance) {
        fail("failed to reproduce cached continuous yield:"
                     + "\n    calculated: " + yield
                     + "\n    expected:   " + cachedYield1b
                     + "\n    tolerance:  " + tolerance
                     + "\n    error:      " + (yield-cachedYield1b));
      }


      yield = bond1.yield(bondDayCount, Compounding.Continuous, freq);
      if (Math.abs(yield-cachedYield1c) > tolerance) {
        fail("failed to reproduce cached continuous yield:"
                     + "\n    calculated: " + yield
                     + "\n    expected:   " + cachedYield1c
                     + "\n    tolerance:  " + tolerance
                     + "\n    error:      " + (yield-cachedYield1c));
      }




      price = bond2.cleanPrice(marketYield2, bondDayCount, Compounding.Compounded, freq);
      if (Math.abs(price-cachedPrice2a) > tolerance) {
        fail("failed to reproduce cached price:"
                     + "\n    calculated: " + price
                     + "\n    expected:   " + cachedPrice2a
                     + "\n    tolerance:  " + tolerance
                     + "\n    error:      " + (price-cachedPrice2a));
      }


      price = bond2.getCleanPrice();
      if (Math.abs(price-cachedPrice2b) > tolerance) {
        fail("failed to reproduce cached price:"
                     + "\n    calculated: " + price
                     + "\n    expected:   " + cachedPrice2b
                     + "\n    tolerance:  " + tolerance
                     + "\n    error:      " + (price-cachedPrice2b));
      }


      yield = bond2.yield(marketPrice2, bondDayCount, Compounding.Compounded, freq);
      if (Math.abs(yield-cachedYield2a) > tolerance) {
        fail("failed to reproduce cached compounded yield:"
                     + "\n    calculated: " + yield
                     + "\n    expected:   " + cachedYield2a
                     + "\n    tolerance:  " + tolerance
                     + "\n    error:      " + (yield-cachedYield2a));
      }


      yield = bond2.yield(marketPrice2, bondDayCount, Compounding.Continuous, freq);
      if (Math.abs(yield-cachedYield2b) > tolerance) {
        fail("failed to reproduce cached continuous yield:"
                     + "\n    calculated: " + yield
                     + "\n    expected:   " + cachedYield2b
                     + "\n    tolerance:  " + tolerance
                     + "\n    error:      " + (yield-cachedYield2b));
      }


      yield = bond2.yield(bondDayCount, Compounding.Continuous, freq);
      if (Math.abs(yield-cachedYield2c) > tolerance) {
        fail("failed to reproduce cached continuous yield:"
                     + "\n    calculated: " + yield
                     + "\n    expected:   " + cachedYield2c
                     + "\n    tolerance:  " + tolerance
                     + "\n    error:      " + (yield-cachedYield2c));
      }


      // with explicit settlement date:


      final Schedule sch3 = new Schedule(new Date(30,Month.November,2004),
                    new Date(30,Month.November,2006), new Period(freq),
                    new UnitedStates(UnitedStates.Market.GOVERNMENTBOND),
                    BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted, DateGeneration.Rule.Backward, false);


      final FixedRateBond bond3 = new FixedRateBond(settlementDays, faceAmount, sch3,

View Full Code Here


      final double tolerance = 1.0e-6;


      // plain


      final Schedule sch = new Schedule(new Date(30,Month.November,2004),
                   new Date(30,Month.November,2008), new Period(Frequency.Semiannual),
                   new UnitedStates(UnitedStates.Market.GOVERNMENTBOND),
                   BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted, DateGeneration.Rule.Backward, false);


      final FixedRateBond bond1 = new FixedRateBond(settlementDays, faceAmount, sch,
                          new double [] { 0.02875 },
                          new ActualActual(ActualActual.Convention.ISMA),
                          BusinessDayConvention.ModifiedFollowing,
                          100.0, new Date(30,Month.November,2004));


      final PricingEngine bondEngine = new DiscountingBondEngine(discountCurve);
      bond1.setPricingEngine(bondEngine);


      final double cachedPrice1 = 99.298100;


      double price = bond1.getCleanPrice();
      if (Math.abs(price-cachedPrice1) > tolerance) {
          fail("failed to reproduce cached price:\n"
                     + "    calculated: " + price + "\n"
                     + "    expected:   " + cachedPrice1 + "\n"
                     + "    error:      " + (price-cachedPrice1));
      }


      // varying coupons


      final double [] couponRates = new double[] { 0.02875, 0.03, 0.03125, 0.0325 };


      final FixedRateBond bond2 = new FixedRateBond(settlementDays, faceAmount, sch,
                            couponRates,
                            new ActualActual(ActualActual.Convention.ISMA),
                            BusinessDayConvention.ModifiedFollowing,
                            100.0, new Date(30,Month.November,2004));


      bond2.setPricingEngine(bondEngine);


      final double cachedPrice2 = 100.334149;


      price = bond2.getCleanPrice();
      if (Math.abs(price-cachedPrice2) > tolerance) {
          fail("failed to reproduce cached price:\n"
                     + "    calculated: " + price + "\n"
                     + "    expected:   " + cachedPrice2 + "\n"
                     + "    error:      " + (price-cachedPrice2));
      }


      // stub date


      final Schedule sch3 = new Schedule(new Date(30,Month.November,2004),
                    new Date(30,Month.March,2009), new Period(Frequency.Semiannual),
                    new UnitedStates(UnitedStates.Market.GOVERNMENTBOND),
                    BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted,
                    DateGeneration.Rule.Backward, false,
                    new Date(), new Date(30,Month.November,2008));

View Full Code Here

          // plain
          final InterestRate yield = new InterestRate(yields[bondIndex],
                             new Business252(new Brazil()),
                             Compounding.Compounded, Frequency.Annual);


          final Schedule schedule = new Schedule(new Date(1,Month.January,2007),
                            maturityDates[bondIndex], new Period(Frequency.Semiannual),
                            new Brazil(Brazil.Market.SETTLEMENT),
                            BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted,
                            DateGeneration.Rule.Backward, false);

View Full Code Here

            endDate = terminationDate_;
        } else {
            endDate = startDate.add (swapTenor_);
        }


        final Schedule fixedSchedule = new Schedule(startDate, endDate,
                fixedTenor_, fixedCalendar_,
                fixedConvention_,
                fixedTerminationDateConvention_,
                fixedRule_, fixedEndOfMonth_,
                fixedFirstDate_, fixedNextToLastDate_);


        final Schedule floatSchedule = new Schedule(startDate, endDate,
                floatTenor_, floatCalendar_,
                floatConvention_,
                floatTerminationDateConvention_,
                floatRule_ , floatEndOfMonth_,
                floatFirstDate_, floatNextToLastDate_);

View Full Code Here

            throw new LibraryException(reportFalseDateGenerationRule(stubDate, rule));
        default:
            throw new LibraryException("unknown DateGeneration.Rule"); // TODO: message
        }


        final Schedule schedule = new Schedule(startDate, maturityDate_, tenor,
                calendar_, accrualConvention, accrualConvention,
                rule, endOfMonth,
                firstDate, nextToLastDate);


        cashflows_ = new FixedRateLeg(schedule, accrualDayCounter)

View Full Code Here

          rule + " DateGeneration::Rule");
    default:
      QL.error("unknown DateGeneration::Rule (" + rule + ")");
    }


    final Schedule schedule = new Schedule(startDate, maturityDate_, new Period(couponFrequency),
        calendar_, accrualConvention, accrualConvention,
        rule, endOfMonth,
        firstDate, nextToLastDate);


    cashflows_ = new IborLeg(schedule, index.currentLink())

View Full Code Here

        final Date maturityDate = startDate.add(maturity);
        final Period accPeriodTenor = new Period(6, TimeUnit.Months);
        final BusinessDayConvention modFollow = BusinessDayConvention.ModifiedFollowing;
        final DateGeneration.Rule dateRule = DateGeneration.Rule.Backward;


        final Schedule firstConstrSchedule = new Schedule(
                startDate, maturityDate, accPeriodTenor,
                calendar, modFollow, modFollow,
                dateRule, false, null, null);


        final List<Date> dates = new ArrayList<Date>();
        dates.add(startDate);
        dates.add(calendar.advance(startDate, new Period(10, TimeUnit.Weeks),modFollow));


        final Schedule secondConstrSchedule = new Schedule(dates, calendar, modFollow);


        testDateAfter(firstConstrSchedule);
        testDateAfter(secondConstrSchedule);


        testNextAndPrevDate(firstConstrSchedule);

View Full Code Here


        final double [] nominals = {1,1.0};




        // TODO: code review :: please verify against QL/C++ code
        final Schedule fixedSchedule = new Schedule(
                startDate, maturity,
                new Period(fixedLegFrequency), index.fixingCalendar(),
                BusinessDayConvention.Unadjusted, BusinessDayConvention.Unadjusted,
                DateGeneration.Rule.Forward, false);

View Full Code Here

0 1 2

TOP

Related Classes of org.jquantlib.time.Schedule

org.jquantlib.instruments.bonds.FixedRateBond

org.jquantlib.instruments.bonds.FloatingRateBond

org.jquantlib.instruments.FixedRateBond

org.jquantlib.instruments.FloatingRateBond

org.jquantlib.instruments.MakeVanillaSwap

org.jquantlib.model.shortrate.calibrationhelpers.CapHelper

org.jquantlib.samples.Bonds

org.jquantlib.samples.ConvertibleBonds

org.jquantlib.Settings

org.jquantlib.termstructures.yieldcurves.BMASwapRateHelper

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.