Package org.jquantlib.instruments.bonds

Examples of org.jquantlib.instruments.bonds.FixedRateBond


                     new UnitedStates(UnitedStates.Market.GOVERNMENTBOND),
                     BusinessDayConvention.Unadjusted,
                     BusinessDayConvention.Unadjusted,
                     DateGeneration.Rule.Backward, false);
       
         final FixedRateBond fixedRateBond = new FixedRateBond(
                     settlementDays,
                     faceAmount,
                     fixedBondSchedule,
                     new double[]{0.045},
                     new ActualActual(ActualActual.Convention.Bond),
                     BusinessDayConvention.ModifiedFollowing,
                     100.0,
                     new Date(15, Month.May, 2007));
       
         fixedRateBond.setPricingEngine(bondEngine);
       
         // Floating rate bond (3M USD Libor + 0.1%)
         // Should and will be priced on another curve later...
       
         final RelinkableHandle<YieldTermStructure> liborTermStructure = new RelinkableHandle<YieldTermStructure>();
         final IborIndex libor3m =  new USDLibor(new Period(3, TimeUnit.Months), liborTermStructure);
         libor3m.addFixing(new Date(17, Month.July, 2008), 0.0278625);
       
         final Schedule floatingBondSchedule = new Schedule(
                     new Date(21, Month.October, 2005),
                     new Date(21, Month.October, 2010), new Period(Frequency.Quarterly),
                     new UnitedStates(UnitedStates.Market.NYSE),
                     BusinessDayConvention.Unadjusted,
                     BusinessDayConvention.Unadjusted,
                     DateGeneration.Rule.Backward, true);
       
         final FloatingRateBond floatingRateBond = new FloatingRateBond(
                     settlementDays,
                     faceAmount,
                     floatingBondSchedule,
                     libor3m,
                     new Actual360(),
                     BusinessDayConvention.ModifiedFollowing,
                     2,                    
                     new Array(1).fill(1.0)//Gearings                    
                     new Array(1).fill(0.001),//Spreads
                     new Array(0),         // Caps
                     new Array(0),         // Floors
                     true,             // Fixing in arrears
                     100.0,
                     new Date(21, Month.October, 2005));
       
         floatingRateBond.setPricingEngine(bondEngine);
              
         // optionLet volatilities
         final double volatility = 0.0;
         final Handle<OptionletVolatilityStructure> vol =
               new Handle<OptionletVolatilityStructure>(
                     new ConstantOptionletVolatility(
                         settlementDays,
                         calendar,
                         BusinessDayConvention.ModifiedFollowing,
                         volatility,
                         new Actual365Fixed()));
       
         // Coupon pricers
         final IborCouponPricer pricer = new BlackIborCouponPricer(vol);
         PricerSetter.setCouponPricer(floatingRateBond.cashflows(),pricer);
       
         // Yield curve bootstrapping
         forecastingTermStructure.linkTo(depoSwapTermStructure);
         discountingTermStructure.linkTo(bondDiscountingTermStructur);
       
         // We are using the depo & swap curve to estimate the future Libor
         // rates
         liborTermStructure.linkTo(depoSwapTermStructure);
       
         /***************
         * BOND PRICING *
         ****************/
       
        QL.info("Results:");
       
         System.out.println("                 "
             + "  " "ZC"
             + "  " "Fixed"
             + "  " "Floating"
             );
               
         System.out.println( "Net present value"
               "  " + zeroCouponBond.NPV()
               "  " + fixedRateBond.NPV()
               "  " + floatingRateBond.NPV());
               
        System.out.println("Clean Price      "
            + "  " +zeroCouponBond.cleanPrice()
            + "  " +fixedRateBond.cleanPrice()
            + "  " + floatingRateBond.cleanPrice()
            );
       
        System.out.println("Dirty price      "
              + " " + zeroCouponBond.dirtyPrice()
              + " " + fixedRateBond.dirtyPrice()
              + " " + floatingRateBond.dirtyPrice()
              );
       
        System.out.println( "Accrued coupon  "
          + " " + zeroCouponBond.accruedAmount()
          + " " + fixedRateBond.accruedAmount()
          + " " + floatingRateBond.accruedAmount()
            );

        System.out.println( "Previous coupon "
          + " " + "N/A"  //zeroCouponBond
          + " " + fixedRateBond.previousCoupon()
          + " " + floatingRateBond.previousCoupon()
            );

        System.out.println( "Next coupon     "
          + " " + "N/A"  //zeroCouponBond
          + " " + fixedRateBond.nextCoupon()
          + " " + floatingRateBond.nextCoupon()
            );
        System.out.println( "Yield           "
          + " " + zeroCouponBond.yield(new Actual360(),Compounding.Compounded, Frequency.Annual)
          + " " + fixedRateBond.yield(new Actual360(),Compounding.Compounded, Frequency.Annual)
          + " " + floatingRateBond.yield(new Actual360(),Compounding.Compounded, Frequency.Annual)
            );

         // Other computations
        System.out.println("Sample indirect computations (for the floating rate bond): " );
View Full Code Here


                                final /* Real */ double redemption,
                                final Date issueDate) {
    super(cleanPrice);
    QL.validateExperimentalMode()
   
    this.bond = new FixedRateBond(settlementDays, faceAmount, schedule,
        coupons, dayCounter, paymentConvention, redemption, issueDate);
   
    this.latestDate = this.bond.maturityDate();
    new Settings().evaluationDate().addObserver(this);
   
View Full Code Here

            final Date maturity = vars.calendar.advance(vars.today, bondData[i].n, bondData[i].units);
            final Date issue = vars.calendar.advance(maturity, -bondData[i].length, TimeUnit.Years);
            /*@Rate*/ final double[] coupons = new double[1];
            coupons[0] = bondData[i].coupon/100.0;

            final FixedRateBond bond = new FixedRateBond(vars.bondSettlementDays, 100.0,
                               vars.schedules[i], coupons,
                               vars.bondDayCounter, vars.bondConvention,
                               vars.bondRedemption, issue);

            final PricingEngine bondEngine = new DiscountingBondEngine(curveHandle);
            bond.setPricingEngine(bondEngine);

            /*@Real*/ final double expectedPrice = bondData[i].price, estimatedPrice = bond.cleanPrice();
            /*@Real*/ final double error = Math.abs(expectedPrice-estimatedPrice);
            if (error > tolerance) {
              throw new RuntimeException(
                  String.format("#%d %s %s %f %s %f %s %f",
                  i+1, " bond failure:",
View Full Code Here

                  DateGeneration.Rule.Backward,
                  false,
                  new Date(),
                  new Date());

              final FixedRateBond bond = new FixedRateBond(
                      settlementDays,
                      faceAmount,
                      sch,
                  new double[] { coupons[k] }, bondDayCount, paymentConvention, redemption, issue);

              for (int m = 0; m < (yields).length; m++) {
                final double price = bond.cleanPrice(yields[m], bondDayCount, compounding[n], frequencies[l]);
                final double calculated = bond.yield(
                        price,
                        bondDayCount,
                        compounding[n],
                        frequencies[l],
                        new Date(),
                        tolerance,
                        maxEvaluations);

                if (Math.abs(yields[m] - calculated) > tolerance) {
                  // the difference might not matter
                  final double price2 = bond.cleanPrice(calculated, bondDayCount, compounding[n], frequencies[l]);
                  if (Math.abs(price - price2) / price > tolerance) {
                                  fail(
                            "yield recalculation failed:\n" + "    issue:     " + issue + "\n"
                        + "    maturity:  " + maturity + "\n" + "    coupon:    " + coupons[k] + "\n"
                        + "    frequency: " + frequencies[l] + "\n\n" + "    yield:  " + yields[m] + " "
View Full Code Here

                  dated, maturity,
              new Period(frequency), calendar,
              accrualConvention, accrualConvention,
              Rule.Backward, false);

          final FixedRateBond bond = new FixedRateBond(
                  settlementDays, faceAmount, sch,
              new double[] { coupon },
              bondDayCount, paymentConvention,
              redemption, issue);

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

          for (final double yield : yields) {

            rate.setValue(yield);

            final double price = bond.cleanPrice(yield, bondDayCount, Compounding.Continuous, frequency);
            final double calculatedPrice = bond.cleanPrice();

            if (Math.abs(price-calculatedPrice) > tolerance) {
              fail(
                  "price calculation failed:"
                  + "\n    issue:     " + issue
                  + "\n    maturity:  " + maturity
                  + "\n    coupon:    " + coupon
                  + "\n    frequency: " + frequency + "\n"
                  + "\n    yield:  " + yield
                  + "\n    expected:    " + price
                  + "\n    calculated': " + calculatedPrice
                  + "\n    error':      " + (price-calculatedPrice));
            }

            final double calculatedYield = bond.yield(
                bondDayCount, Compounding.Continuous, frequency,
                tolerance, maxEvaluations);
            if (Math.abs(yield-calculatedYield) > tolerance) {
                            fail(
                  "yield calculation failed:"
View Full Code Here

      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.cleanPrice();
      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.cleanPrice();
      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,
                          new double[] {0.02875},
                          new ActualActual(ActualActual.Convention.ISMA),
                          BusinessDayConvention.ModifiedFollowing,
                          100.0, new Date(30,Month.November,2004));

      bond3.setPricingEngine(bondEngine);

      final double marketYield3 = 0.02997;

      final Date settlementDate = new Date(30,Month.November,2004);
      final double cachedPrice3 = 99.764874;

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

      // this should give the same result since the issue date is the
      // earliest possible settlement date

      settings.setEvaluationDate(new Date(22,Month.November,2004));

      price = bond3.cleanPrice(marketYield3, bondDayCount, Compounding.Compounded, freq);
      if (Math.abs(price-cachedPrice3) > tolerance) {
        fail("failed to reproduce cached price:"
                     + "\n    calculated: " + price + ""
                     + "\n    expected:   " + cachedPrice3 + ""
                     + "\n    error:      " + (price-cachedPrice3));
View Full Code Here

      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.cleanPrice();
      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.cleanPrice();
      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));

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

      bond3.setPricingEngine(bondEngine);

      final double cachedPrice3 = 100.382794;

      price = bond3.cleanPrice();
      if (Math.abs(price-cachedPrice3) > tolerance) {
          fail("failed to reproduce cached price:\n"
                     + "    calculated: " + price + "\n"
                     + "    expected:   " + cachedPrice3 + "\n"
                     + "    error:      " + (price-cachedPrice3));
View Full Code Here

        vars.no_callability, vars.creditSpread, vars.issueDate,
        vars.settlementDays, coupons, vars.dayCounter, schedule,
        vars.redemption);
    amFixed.setPricingEngine(engine);

    final FixedRateBond fixed = new FixedRateBond(vars.settlementDays,
        vars.faceAmount, schedule, coupons, vars.dayCounter,
        BusinessDayConvention.Following, vars.redemption,
        vars.issueDate);

    fixed.setPricingEngine(bondEngine);

    tolerance = 2.0e-2 * (vars.faceAmount / 100.0);

    error = Math.abs(euFixed.NPV() - fixed.settlementValue());
    if (error > tolerance) {
      fail("failed to reproduce fixed-coupon bond price:"
          + "\n    calculated: " + euFixed.NPV()
          + "\n    expected:   " + fixed.settlementValue()
          + "\n    error:      " + error);
    }

    error = Math.abs(amFixed.NPV() - fixed.settlementValue());
    if (error > tolerance) {
      fail("failed to reproduce fixed-coupon bond price:"
          + "\n    calculated: " + amFixed.NPV()
          + "\n    expected:   " + fixed.settlementValue()
          + "\n    error:      " + error);
    }

    // floating-rate

View Full Code Here

TOP

Related Classes of org.jquantlib.instruments.bonds.FixedRateBond

Copyright © 2018 www.massapicom. All rights reserved.
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.