frequency() private method

private frequency ( ) : Frequency
return Frequency
        /*! simple annual compounding coupon rates
         *  with internal schedule calculation */
        public FixedRateBond(int settlementDays,
                             Calendar calendar,
                             double faceAmount,
                             Date startDate,
                             Date maturityDate,
                             Period tenor,
                             List <double> coupons,
                             DayCounter accrualDayCounter,
                             BusinessDayConvention accrualConvention,
                             BusinessDayConvention paymentConvention,
                             double redemption,
                             Date issueDate,
                             Date stubDate,
                             DateGeneration.Rule rule,
                             bool endOfMonth,
                             Calendar paymentCalendar)
            : base(settlementDays, paymentCalendar == new Calendar() ? calendar : paymentCalendar,
                   issueDate)
        {
            frequency_    = tenor.frequency();
            dayCounter_   = accrualDayCounter;
            maturityDate_ = maturityDate;

            Date firstDate, nextToLastDate;

            switch (rule)
            {
            case DateGeneration.Rule.Backward:
                firstDate      = null;
                nextToLastDate = stubDate;
                break;

            case DateGeneration.Rule.Forward:
                firstDate      = stubDate;
                nextToLastDate = null;
                break;

            case DateGeneration.Rule.Zero:
            case DateGeneration.Rule.ThirdWednesday:
            case DateGeneration.Rule.Twentieth:
            case DateGeneration.Rule.TwentiethIMM:
                throw new ApplicationException("stub date (" + stubDate + ") not allowed with " + rule + " DateGeneration::Rule");

            default:
                throw new ApplicationException("unknown DateGeneration::Rule (" + rule + ")");
            }


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


            cashflows_ = new FixedRateLeg(schedule)
                         .withCouponRates(coupons, accrualDayCounter)
                         .withPaymentCalendar(calendar_)
                         .withNotionals(faceAmount)
                         .withPaymentAdjustment(paymentConvention);

            addRedemptionsToCashflows(new List <double>()
            {
                redemption
            });


            if (cashflows().Count == 0)
            {
                throw new ApplicationException("bond with no cashflows!");
            }

            if (redemptions_.Count != 1)
            {
                throw new ApplicationException("multiple redemptions created");
            }
        }
Example #2
0
      /*! simple annual compounding coupon rates
          with internal schedule calculation */
      public FixedRateBond(int settlementDays, 
                           Calendar calendar,
                           double faceAmount,
                           Date startDate,
                           Date maturityDate,
                           Period tenor,
                           List<double> coupons,
                           DayCounter accrualDayCounter,
                           BusinessDayConvention accrualConvention = BusinessDayConvention.Following,
                           BusinessDayConvention paymentConvention = BusinessDayConvention.Following,
                           double redemption = 100,
                           Date issueDate = null,
                           Date stubDate = null,
                           DateGeneration.Rule rule = DateGeneration.Rule.Backward,
                           bool endOfMonth = false,
                           Calendar paymentCalendar = null,
									Period exCouponPeriod = null,
                           Calendar exCouponCalendar = null,
									BusinessDayConvention exCouponConvention = BusinessDayConvention.Unadjusted,
                           bool exCouponEndOfMonth = false)
         : base(settlementDays, paymentCalendar == null ? calendar : paymentCalendar, 
                issueDate) 
      {

         frequency_ = tenor.frequency();
         dayCounter_ = accrualDayCounter;
         maturityDate_     = maturityDate;

         Date firstDate, nextToLastDate;

         switch (rule) 
         {
         
            case DateGeneration.Rule.Backward:
               firstDate = null;
               nextToLastDate = stubDate;
               break;

            case DateGeneration.Rule.Forward:
               firstDate = stubDate;
               nextToLastDate = null;
               break;

            case DateGeneration.Rule.Zero:
            case DateGeneration.Rule.ThirdWednesday:
            case DateGeneration.Rule.Twentieth:
            case DateGeneration.Rule.TwentiethIMM:
               throw new ApplicationException("stub date (" + stubDate + ") not allowed with " + rule + " DateGeneration::Rule");
              
            default:
               throw new ApplicationException("unknown DateGeneration::Rule (" + rule + ")");
         }


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

            
         cashflows_ = new FixedRateLeg(schedule)
            .withCouponRates(coupons, accrualDayCounter)
				.withExCouponPeriod(exCouponPeriod,
										  exCouponCalendar,
										  exCouponConvention,
										  exCouponEndOfMonth)
            .withPaymentCalendar(calendar_)
            .withNotionals(faceAmount)
            .withPaymentAdjustment(paymentConvention);

         addRedemptionsToCashflows(new List<double>() { redemption });


         if (cashflows().Count == 0)
            throw new ApplicationException("bond with no cashflows!");
         
         if (redemptions_.Count != 1)
            throw new ApplicationException("multiple redemptions created");
      }
Example #3
0
        /*! simple annual compounding coupon rates
         *  with internal schedule calculation */
        public FixedRateBond(int settlementDays,
                             Calendar calendar,
                             double faceAmount,
                             Date startDate,
                             Date maturityDate,
                             Period tenor,
                             List <double> coupons,
                             DayCounter accrualDayCounter,
                             BusinessDayConvention accrualConvention = BusinessDayConvention.Following,
                             BusinessDayConvention paymentConvention = BusinessDayConvention.Following,
                             double redemption         = 100,
                             Date issueDate            = null,
                             Date stubDate             = null,
                             DateGeneration.Rule rule  = DateGeneration.Rule.Backward,
                             bool endOfMonth           = false,
                             Calendar paymentCalendar  = null,
                             Period exCouponPeriod     = null,
                             Calendar exCouponCalendar = null,
                             BusinessDayConvention exCouponConvention = BusinessDayConvention.Unadjusted,
                             bool exCouponEndOfMonth = false)
            : base(settlementDays, paymentCalendar ?? calendar,
                   issueDate)
        {
            frequency_    = tenor.frequency();
            dayCounter_   = accrualDayCounter;
            maturityDate_ = maturityDate;

            Date firstDate = null, nextToLastDate = null;

            switch (rule)
            {
            case DateGeneration.Rule.Backward:
                firstDate      = null;
                nextToLastDate = stubDate;
                break;

            case DateGeneration.Rule.Forward:
                firstDate      = stubDate;
                nextToLastDate = null;
                break;

            case DateGeneration.Rule.Zero:
            case DateGeneration.Rule.ThirdWednesday:
            case DateGeneration.Rule.Twentieth:
            case DateGeneration.Rule.TwentiethIMM:
                Utils.QL_FAIL("stub date (" + stubDate + ") not allowed with " + rule + " DateGeneration::Rule");
                break;

            default:
                Utils.QL_FAIL("unknown DateGeneration::Rule (" + rule + ")");
                break;
            }


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


            cashflows_ = new FixedRateLeg(schedule)
                         .withCouponRates(coupons, accrualDayCounter)
                         .withExCouponPeriod(exCouponPeriod,
                                             exCouponCalendar,
                                             exCouponConvention,
                                             exCouponEndOfMonth)
                         .withPaymentCalendar(calendar_)
                         .withNotionals(faceAmount)
                         .withPaymentAdjustment(paymentConvention);

            addRedemptionsToCashflows(new List <double>()
            {
                redemption
            });


            Utils.QL_REQUIRE(cashflows().Count != 0, () => "bond with no cashflows!");
            Utils.QL_REQUIRE(redemptions_.Count == 1, () => "multiple redemptions created");
        }