Example #1
0
            public override void setupArguments(IPricingEngineArguments args)
            {
                base.setupArguments(args);

                ConvertibleBond.option.Arguments moreArgs = args as Arguments;
                Utils.QL_REQUIRE(moreArgs != null, () => "wrong argument type");

                moreArgs.conversionRatio = conversionRatio_;

                Date settlement = bond_.settlementDate();

                int n = callability_.Count;

                if (moreArgs.callabilityDates == null)
                {
                    moreArgs.callabilityDates = new List <Date>();
                }
                else
                {
                    moreArgs.callabilityDates.Clear();
                }

                if (moreArgs.callabilityTypes == null)
                {
                    moreArgs.callabilityTypes = new List <Callability.Type>();
                }
                else
                {
                    moreArgs.callabilityTypes.Clear();
                }

                if (moreArgs.callabilityPrices == null)
                {
                    moreArgs.callabilityPrices = new List <double>();
                }
                else
                {
                    moreArgs.callabilityPrices.Clear();
                }

                if (moreArgs.callabilityTriggers == null)
                {
                    moreArgs.callabilityTriggers = new List <double?>();
                }
                else
                {
                    moreArgs.callabilityTriggers.Clear();
                }

                for (int i = 0; i < n; i++)
                {
                    if (!callability_[i].hasOccurred(settlement, false))
                    {
                        moreArgs.callabilityTypes.Add(callability_[i].type());
                        moreArgs.callabilityDates.Add(callability_[i].date());

                        if (callability_[i].price().type() == Callability.Price.Type.Clean)
                        {
                            moreArgs.callabilityPrices.Add(callability_[i].price().amount() +
                                                           bond_.accruedAmount(callability_[i].date()));
                        }
                        else
                        {
                            moreArgs.callabilityPrices.Add(callability_[i].price().amount());
                        }

                        SoftCallability softCall = callability_[i] as SoftCallability;
                        if (softCall != null)
                        {
                            moreArgs.callabilityTriggers.Add(softCall.trigger());
                        }
                        else
                        {
                            moreArgs.callabilityTriggers.Add(null);
                        }
                    }
                }

                List <CashFlow> cashflows = bond_.cashflows();

                if (moreArgs.couponDates == null)
                {
                    moreArgs.couponDates = new List <Date>();
                }
                else
                {
                    moreArgs.couponDates.Clear();
                }

                if (moreArgs.couponAmounts == null)
                {
                    moreArgs.couponAmounts = new List <double>();
                }
                else
                {
                    moreArgs.couponAmounts.Clear();
                }

                for (int i = 0; i < cashflows.Count - 1; i++)
                {
                    if (!cashflows[i].hasOccurred(settlement, false))
                    {
                        moreArgs.couponDates.Add(cashflows[i].date());
                        moreArgs.couponAmounts.Add(cashflows[i].amount());
                    }
                }

                if (moreArgs.dividends == null)
                {
                    moreArgs.dividends = new DividendSchedule();
                }
                else
                {
                    moreArgs.dividends.Clear();
                }

                if (moreArgs.dividendDates == null)
                {
                    moreArgs.dividendDates = new List <Date>();
                }
                else
                {
                    moreArgs.dividendDates.Clear();
                }

                for (int i = 0; i < dividends_.Count; i++)
                {
                    if (!dividends_[i].hasOccurred(settlement, false))
                    {
                        moreArgs.dividends.Add(dividends_[i]);
                        moreArgs.dividendDates.Add(dividends_[i].date());
                    }
                }

                moreArgs.creditSpread   = creditSpread_;
                moreArgs.issueDate      = issueDate_;
                moreArgs.settlementDate = settlement;
                moreArgs.settlementDays = settlementDays_;
                moreArgs.redemption     = redemption_;
            }
Example #2
0
        public DiscretizedConvertible(ConvertibleBond.option.Arguments args,
                                      GeneralizedBlackScholesProcess process, TimeGrid grid)
        {
            arguments_ = args;
            process_   = process;

            dividendValues_ = new Vector(arguments_.dividends.Count, 0.0);

            Date settlementDate = process.riskFreeRate().link.referenceDate();

            for (int i = 0; i < arguments_.dividends.Count; i++)
            {
                if (arguments_.dividends[i].date() >= settlementDate)
                {
                    dividendValues_[i] = arguments_.dividends[i].amount() *
                                         process.riskFreeRate().link.discount(arguments_.dividends[i].date());
                }
            }

            DayCounter dayCounter     = process.riskFreeRate().currentLink().dayCounter();
            Date       bondSettlement = arguments_.settlementDate;

            stoppingTimes_ = new InitializedList <double>(arguments_.exercise.dates().Count, 0.0);
            for (var i = 0; i < stoppingTimes_.Count; i++)
            {
                stoppingTimes_[i] = dayCounter.yearFraction(bondSettlement, arguments_.exercise.date(i));
            }

            callabilityTimes_ = new InitializedList <double>(arguments_.callabilityDates.Count, 0.0);
            for (var i = 0; i < callabilityTimes_.Count; i++)
            {
                callabilityTimes_[i] = dayCounter.yearFraction(bondSettlement, arguments_.callabilityDates[i]);
            }

            couponTimes_ = new InitializedList <double>(arguments_.couponDates.Count, 0.0);
            for (var i = 0; i < couponTimes_.Count; i++)
            {
                couponTimes_[i] = dayCounter.yearFraction(bondSettlement, arguments_.couponDates[i]);
            }

            dividendTimes_ = new InitializedList <double>(arguments_.dividendDates.Count, 0.0);
            for (var i = 0; i < dividendTimes_.Count; i++)
            {
                dividendTimes_[i] = dayCounter.yearFraction(bondSettlement, arguments_.dividendDates[i]);
            }

            if (!grid.empty())
            {
                // adjust times to grid
                for (var i = 0; i < stoppingTimes_.Count; i++)
                {
                    stoppingTimes_[i] = grid.closestTime(stoppingTimes_[i]);
                }

                for (var i = 0; i < couponTimes_.Count; i++)
                {
                    couponTimes_[i] = grid.closestTime(couponTimes_[i]);
                }

                for (var i = 0; i < dividendTimes_.Count; i++)
                {
                    dividendTimes_[i] = grid.closestTime(dividendTimes_[i]);
                }

                for (var i = 0; i < callabilityTimes_.Count; i++)
                {
                    callabilityTimes_[i] = grid.closestTime(callabilityTimes_[i]);
                }
            }
        }