Ejemplo n.º 1
0
 /// <summary>
 /// Calculates the ISMA dirty bond price.
 /// </summary>
 /// <param name="accrualYearFraction">The first accrual coupon year fraction.</param>
 /// <param name="finalAccrualYearFraction">The final coupon year fraction. If regular this is zero.</param>
 /// <param name="numberOfFullCoupons">The number of full coupon periods remaining until redemption.
 /// The number of remaining coupon periods is therefore n+1;</param>
 /// <param name="nextCoupon">The next coupon payment. This may be partial or zero if the bond is trading ex div.</param>
 /// <param name="next2Coupon">The next 2 coupon.</param>
 /// <param name="annualCoupon">The annual coupon payment for 100 unit of face value.</param>
 /// <param name="finalCoupon">The final coupon with an odd final period. This is zero for all other bonds.</param>
 /// <param name="couponsPerYear">The number of coupon periods in a year.</param>
 /// <param name="periodDiscountFactor">The discount factor for one period, v = 1/(1+y/h)</param>
 /// <param name="annualYield">The required annual nominal redemption yield expressed as a decimal.</param>
 /// <returns>Te dirty price according to ISMA convention.</returns>
 public double ISMADirtyPrice(double accrualYearFraction, double finalAccrualYearFraction, int numberOfFullCoupons,
                              double nextCoupon, double next2Coupon, double annualCoupon, double finalCoupon, int couponsPerYear,
                              double periodDiscountFactor, double annualYield)
 {
     return(BondAnalytics.ISMADirtyPrice(accrualYearFraction, finalAccrualYearFraction, numberOfFullCoupons,
                                         nextCoupon, next2Coupon, annualCoupon, finalCoupon, couponsPerYear, periodDiscountFactor, annualYield));
 }
Ejemplo n.º 2
0
        ///<summary>
        ///</summary>
        ///<param name="settlement"></param>
        ///<param name="maturity"></param>
        ///<param name="imBp"></param>
        ///<param name="tmBp"></param>
        ///<param name="pmtFreq"></param>
        ///<param name="rateSet"></param>
        ///<param name="rateToNextCoup"></param>
        ///<param name="swapRate"></param>
        ///<param name="dayCount"></param>
        ///<param name="exInt"></param>
        ///<param name="xlHolidays"></param>
        ///<returns></returns>
        public double FRNPrice(DateTime settlement, DateTime maturity, double imBp, double tmBp, int pmtFreq,
                               double rateSet, double rateToNextCoup, double swapRate, int dayCount, int exInt, [Optional] Excel.Range xlHolidays)
        {
            if (pmtFreq < 0 | rateSet < 0 | rateToNextCoup < 0 | swapRate < 0 | exInt < 0)
            {
                return(0);
            }
            if (settlement > maturity)
            {
                return(0);
            }
            object[,] values = xlHolidays.get_Value(System.Reflection.Missing.Value) as object[, ];
            object[,] holidays;
            if (values.GetType().Name == "Missing")
            {
                holidays       = new Object[1, 1];
                holidays[0, 0] = new DateTime(1, 1, 1);
            }
            else
            {
                holidays = ArrayHelper.RangeToMatrix(values);
            }
            Double output = BondAnalytics.FRNPrice(settlement, maturity, imBp, tmBp, pmtFreq, rateSet, rateToNextCoup, swapRate, dayCount, exInt, holidays);

            return(output);
        }
Ejemplo n.º 3
0
        public void TestISMADirtyPrice1_1()
        {
            double accrualYearFraction = 297.0 / 365.0;

            int finalAccrualYearFraction = 0;

            int i = 8;

            double nextCoupon = 7.0;

            double next2Coupon = 7.0;

            double annualCoupon = 7.0;

            double finalCoupon = 0.0;

            int numberOfCouponPeriodsInAYear = 1;

            double ytm = .06;

            double discountFactorForOnePeriod = 1 / (1 + ytm / numberOfCouponPeriodsInAYear);

            var result = BondAnalytics.ISMADirtyPrice(accrualYearFraction,
                                                      finalAccrualYearFraction,
                                                      i,
                                                      nextCoupon,
                                                      next2Coupon,
                                                      annualCoupon, finalCoupon, numberOfCouponPeriodsInAYear, discountFactorForOnePeriod, ytm);

            Debug.WriteLine(String.Format("dirty price : {0}", result));
        }
Ejemplo n.º 4
0
        ///<summary>
        ///</summary>
        ///<param name="settlement"></param>
        ///<param name="maturity"></param>
        ///<param name="couponRate"></param>
        ///<param name="yield"></param>
        ///<param name="couponFreq"></param>
        ///<param name="kt"></param>
        ///<param name="p"></param>
        ///<param name="exIntPeriod"></param>
        ///<returns></returns>
        public double CIBPrice(DateTime settlement, DateTime maturity, double couponRate, double yield, int couponFreq, double kt, double p, int exIntPeriod)
        {
            if (couponRate < 0 | yield < 0 | couponFreq <= 0 | kt < 0 | exIntPeriod < 0)
            {
                return(0);
            }
            if (settlement > maturity)
            {
                return(0);
            }
            Double output = BondAnalytics.CIBPrice(settlement, maturity, couponRate, yield, couponFreq, kt, p, exIntPeriod);

            return(output);
        }
Ejemplo n.º 5
0
        ///<summary>
        ///</summary>
        ///<param name="settlement"></param>
        ///<param name="maturity"></param>
        ///<param name="couponRate"></param>
        ///<param name="yield"></param>
        ///<returns></returns>
        public double RBABondPrice(DateTime settlement, DateTime maturity, double couponRate, double yield)
        {
            if (couponRate == 0 | yield == 0)
            {
                return(0);
            }
            if (settlement > maturity)
            {
                return(0);
            }
            Double output = BondAnalytics.RBABondPrice(settlement, maturity, couponRate, yield);

            return(output);
        }
Ejemplo n.º 6
0
        ///<summary>
        ///</summary>
        ///<param name="settlement"></param>
        ///<param name="maturity"></param>
        ///<param name="yield"></param>
        ///<param name="faceValue"></param>
        ///<returns></returns>
        public double BillPrice(DateTime settlement, DateTime maturity, double yield, double faceValue)
        {
            if (yield == 0 | faceValue == 0)
            {
                return(0);
            }
            if (settlement > maturity)
            {
                return(0);
            }
            Double output = BondAnalytics.BillPrice(settlement, maturity, yield, faceValue);

            return(output);
        }
Ejemplo n.º 7
0
        ///<summary>
        ///</summary>
        ///<param name="settlement"></param>
        ///<param name="maturity"></param>
        ///<param name="couponRate"></param>
        ///<param name="yield"></param>
        ///<param name="couponFreq"></param>
        ///<param name="exIntPeriod"></param>
        ///<returns></returns>
        public double BondPrice(DateTime settlement, DateTime maturity, double couponRate, double yield, int couponFreq, int exIntPeriod)
        {
            if (couponRate == 0 | yield == 0 | couponFreq == 0 | exIntPeriod < 0)
            {
                return(0);
            }
            if (settlement > maturity)
            {
                return(0);
            }
            Double output = BondAnalytics.BondPrice(settlement, maturity, couponRate, yield, couponFreq, exIntPeriod);

            return(output);
        }
Ejemplo n.º 8
0
        ///<summary>
        ///</summary>
        ///<param name="settlement"></param>
        ///<param name="maturity"></param>
        ///<param name="baseAnnuity"></param>
        ///<param name="yield"></param>
        ///<param name="pmtFreq"></param>
        ///<param name="cpiBase"></param>
        ///<param name="cpiLatest"></param>
        ///<param name="cpiPrevious"></param>
        ///<param name="nextPmtKnownFlag"></param>
        ///<param name="exIntPeriod"></param>
        ///<returns></returns>
        public double IABPrice(DateTime settlement, DateTime maturity, double baseAnnuity, double yield, int pmtFreq,
                               double cpiBase, double cpiLatest, double cpiPrevious, bool nextPmtKnownFlag, int exIntPeriod)
        {
            if (baseAnnuity < 0 | yield < 0 | pmtFreq <= 0 | cpiBase < 0 | exIntPeriod < 0)
            {
                return(0);
            }
            if (settlement > maturity)
            {
                return(0);
            }
            Double output = BondAnalytics.IABPrice(settlement, maturity, baseAnnuity, yield, pmtFreq, cpiBase, cpiLatest, cpiPrevious, nextPmtKnownFlag, exIntPeriod);

            return(output);
        }
Ejemplo n.º 9
0
        public void TestISMADirtyPrice0()
        {
            //var ytm = BondAnalytics.CalculateBondYTM(DateTime.Parse("15/05/13"), DateTime.Parse("15/11/08"),
            //.065, 2, 100, 113.27); 3.75-TYM
            //sorry should be around 3.7%
            DateTime matDate        = DateTime.Parse("15/05/13");
            DateTime lastCouponDate = DateTime.Parse("15/11/08");

            var couponRate = .065;

            double accrualYearFraction = (DateTime.Today - lastCouponDate).TotalDays / 365;

            //int finalAccrualYearFraction = 0;
            double finalAccrualYearFraction = 0.5 - accrualYearFraction;

            int numberOfCouponPeriodsInAYear = 2;

            //int i = (int)((matDate - lastCouponDate).TotalDays / 365) * numberOfCouponPeriodsInAYear;
            int i = 8;


            double nextCoupon = couponRate * 100 / numberOfCouponPeriodsInAYear;
            //double nextCoupon = 0;

            double next2Coupon = couponRate * 100 / numberOfCouponPeriodsInAYear;

            //double annualCoupon = couponRate * 100 / numberOfCouponPeriodsInAYear;
            double annualCoupon = couponRate * 100;

            //double finalCoupon = 0.0;
            double finalCoupon = couponRate * 100 * finalAccrualYearFraction;

            //double ytm = .037;
            double ytm = .037;

            double discountFactorForOnePeriod = 1 / (1 + ytm / numberOfCouponPeriodsInAYear);

            var result = BondAnalytics.ISMADirtyPrice(accrualYearFraction,
                                                      finalAccrualYearFraction,
                                                      i,
                                                      nextCoupon,
                                                      next2Coupon,
                                                      annualCoupon, finalCoupon, numberOfCouponPeriodsInAYear, discountFactorForOnePeriod, ytm);

            Debug.WriteLine(String.Format("dirty price : {0}", result));
        }
        /// <summary>
        /// Evaluates the npv.
        /// </summary>
        /// <returns></returns>
        private decimal EvaluateDirtyPrice()
        {
            var result = 0.0m;

            if (AnalyticParameters.IsYTMQuote)
            {
                var accrualYearFraction = Convert.ToDouble(AnalyticParameters.RemainingAccruedFactor);
                var periods             = AnalyticParameters.AccrualYearFractions.Length;
                var annualCoupon        = Convert.ToDouble(AnalyticParameters.CouponRate);
                var h           = AnalyticParameters.Frequency;
                var nextCoupon  = AnalyticParameters.IsExDiv ? 0.0 : annualCoupon / h;//TODO semi annual only.
                var next2Coupon = nextCoupon;
                var y           = Convert.ToDouble(AnalyticParameters.Quote);
                var v           = 1 / (1 + y / h);
                result = Convert.ToDecimal(BondAnalytics.ISMADP(accrualYearFraction, 0.0, periods - 1, nextCoupon,
                                                                next2Coupon, annualCoupon, 0, h, v, y));
            }
            return(result);
        }
Ejemplo n.º 11
0
        static void Main(string[] args)
        {
            string refDate   = "24/09/2014";
            var    analytics = new BondAnalytics(refDate);

            var xDoc   = XElement.Load("Bonds.xml");
            var xBonds = from xBond in xDoc.Descendants("Bond")
                         select xBond;

            var bonds = new List <Tuple <string, string, double> >();

            foreach (var xBond in xBonds)
            {
                bonds.Add(new Tuple <string, string, double>(xBond.Attribute("ISIN").Value,
                                                             xBond.Element("Description").Value,
                                                             double.Parse(xBond.Element("CleanPrice").Value)));

                analytics.Add(xBond.Attribute("ISIN").Value,
                              xBond.Element("IssueDate").Value,
                              xBond.Element("MaturityDate").Value,
                              double.Parse(xBond.Element("Coupon").Value));
            }

            foreach (var tuple in bonds)
            {
                var yield = analytics.Yield(tuple.Item1, tuple.Item3);

                Console.WriteLine("ISIN:              {0}", tuple.Item1);
                Console.WriteLine("Description:       {0}", tuple.Item2);
                Console.WriteLine("Clean Price:       {0}", tuple.Item3.ToString(".00"));
                Console.WriteLine("NPV:               {0}", analytics.NetPresentValue(tuple.Item1).ToString(".000000"));
                Console.WriteLine("Yield %:           {0}", (yield * 100.0).ToString(".000000"));
                Console.WriteLine("Modified Duration: {0}", analytics.ModifiedDuration(tuple.Item1, yield).ToString(".00")); //2.89
                Console.WriteLine();
            }

            Console.Read();
        }
Ejemplo n.º 12
0
 ///<summary>
 /// Calculated the bond yield to maturity.
 ///</summary>
 ///<param name="maturityDate">redemption date</param>
 ///<param name="lastCouponDate">last coupon date</param>
 ///<param name="couponRate">coupon rate</param>
 ///<param name="couponFrequency">coupons per year,1 for annual, 2 for semi, 4 for quarterly</param>
 ///<param name="faceValue">The bond face value.</param>
 ///<param name="dirtyPrice">dirty price</param>
 ///<returns>The yield to maturity.</returns>
 public double CalculateBondYTM(DateTime maturityDate, DateTime lastCouponDate, double couponRate, int couponFrequency, double faceValue, double dirtyPrice)
 {
     return(BondAnalytics.CalculateBondYTM(maturityDate, lastCouponDate, couponRate, couponFrequency, faceValue, dirtyPrice));
 }
Ejemplo n.º 13
0
        public static Series<DateTime,double> GetSavedRepoOisSpread(this ICarbonClient client, BondAnalytics.Country country)
        {
            var moniker = "rsch.repo.spreadvsois." + country.ToString().ToUpper() + ".RepoOisSpread";

            var df = client.GetFrameAsync<DateTime>(moniker, "AdHocData").Result;

            if (df == null) return null; // quit if it can't be found

            var repoSpdSrs = df.GetColumnAt<double>(0);
            return repoSpdSrs;
        }
Ejemplo n.º 14
0
 private static double? GetGcRateFromCache(BondAnalytics.Country country, DateTime date)
 {
     var key = string.Format("{0}-{1:yyyyMMdd}", country, date);
     double gcRate;
     if (!GcRatesCache.TryGetValue(key, out gcRate))
     {
         return null;
     }
     return gcRate;
 }
Ejemplo n.º 15
0
        public void CalculateYTM13()
        {
            var ytm = BondAnalytics.CalculateBondYTM(DateTime.Parse("15/06/11"), DateTime.Parse("15/12/08"), .0575, 2, 100, 107.36);

            Debug.WriteLine(String.Format("ytm : {0}", 100 * ytm));
        }
Ejemplo n.º 16
0
        public void CalculateYTM()
        {
            var ytm = BondAnalytics.CalculateBondYTM(DateTime.Today.AddMonths(9), DateTime.Today.AddMonths(-3), 0.06, 2, 100, 104);

            Debug.WriteLine(String.Format("ytm : {0}", 100 * ytm));
        }
Ejemplo n.º 17
0
        public void TestISMADirtyPrice3()
        {
            var result = BondAnalytics.ISMADirtyPrice(2.0 / 365.0, 0, 8, 7.0, 7.0, 7.0, 0.0, 1, 1 / (1.07), .07);

            Debug.WriteLine(String.Format("dirty price : {0}", result));
        }
Ejemplo n.º 18
0
        // Calc from persisted repo-ois spreads
        public static double[,] GetRepoRateFromSavedRepoOisSpread(this ICarbonClient client, BondAnalytics.Country country, List<DateTime> asOfDate, List<DateTime> forwardDates,
            List<DateTime> holidays, Dictionary<DateTime, Tuple<DateTime,double>[]> discCurves =null )
        {


            var repoSpdSrs = client.GetSavedRepoOisSpread(country);
            var result = client.CalcRepoRatesFromOisSpread(repoSpdSrs, country, asOfDate, forwardDates, holidays,
                discCurves);

            return result;

        }
Ejemplo n.º 19
0
        ///<summary>
        /// This is a coupon scheduler based on some old C++ code.
        ///</summary>
        ///<param name="valueDate">The value date of the bond.</param>
        ///<param name="settlementDate">The settlement date of the bond.</param>
        ///<param name="firstAccrualDate">The first accrual date of the bond.</param>
        ///<param name="firstCouponDate">The first coupon date of the bond. this may be null.</param>
        ///<param name="lastRegCouponDate">The last regular coupon date. This may be null.</param>
        ///<param name="maturityDate">The maturity date of the bond.</param>
        ///<param name="calendar">The payment calendar.</param>
        ///<param name="coupFreq">The coupon frequency.</param>
        ///<param name="rollDay">The roll day.</param>
        ///<param name="exdividendType">The ex div type.</param>
        ///<param name="prevCouponDate">The previous coupon date as calculated.</param>
        ///<param name="nextCouponDate">The next coupon date as calculated.</param>
        ///<param name="next2CouponDate">The next plus one coupon date as calculated.</param>
        ///<param name="regCouponsToMaturity">The regular coupons until maturity as calculated.</param>
        ///<param name="numCoupons">The number of coupon as calculated.</param>
        ///<param name="isXD">The exdiv state as calculated.</param>
        ///<returns>A boolean flag.</returns>
        ///<exception cref="Exception"></exception>
        public static Boolean GetBondCouponDates(DateTime valueDate, DateTime settlementDate, DateTime firstAccrualDate,
                                                 DateTime?firstCouponDate, DateTime?lastRegCouponDate, DateTime maturityDate, IBusinessCalendar calendar,
                                                 int coupFreq, int rollDay, ExDividendEnum exdividendType, out DateTime prevCouponDate,
                                                 out DateTime nextCouponDate, out DateTime?next2CouponDate, out int regCouponsToMaturity,
                                                 out int numCoupons, out bool isXD)
        {
            //var result = false;
            if (valueDate > maturityDate)
            {
                throw new Exception("Bond has matured");
            }
            var yf = maturityDate.Year;
            var mf = maturityDate.Month;
            var y  = valueDate.Year;
            var m  = valueDate.Month;
            var d  = valueDate.Day;

            numCoupons           = 0;
            regCouponsToMaturity = 0;
            isXD            = false;
            prevCouponDate  = firstAccrualDate;
            nextCouponDate  = firstAccrualDate;
            next2CouponDate = firstAccrualDate;
            if (firstCouponDate != null)
            {
                //result = true;
                var coupon = (DateTime)firstCouponDate;
                var y1     = coupon.Year;
                var m1     = coupon.Month;
                if (valueDate < firstCouponDate) // in first coupon period
                {
                    nextCouponDate       = (DateTime)firstCouponDate;
                    prevCouponDate       = firstAccrualDate;
                    regCouponsToMaturity = (12 * (yf - y1) + mf - m1) / coupFreq;
                    next2CouponDate      = new DateTime(yf, mf - (regCouponsToMaturity - 1) * coupFreq, rollDay);
                    if (next2CouponDate > maturityDate)
                    {
                        next2CouponDate = maturityDate;
                    }
                    isXD       = firstCouponDate < maturityDate && settlementDate >= new ExDivDate(exdividendType, nextCouponDate, calendar).Date;
                    numCoupons = (12 * (yf - y1) + mf - m1) / coupFreq - regCouponsToMaturity;
                    return(true);//result
                }
            }
            else if (lastRegCouponDate != null && valueDate >= lastRegCouponDate) // in irregular final period
            {
                prevCouponDate       = (DateTime)lastRegCouponDate;
                nextCouponDate       = maturityDate;
                regCouponsToMaturity = -1;
                numCoupons           = 1;
                next2CouponDate      = null;
                return(true);// result;
            }
            else // in regular part of schedule
            {
                regCouponsToMaturity = -BondAnalytics.CountCoupPdsEx(yf, mf, rollDay, y, m, d, coupFreq);
                nextCouponDate       = new DateTime(yf, mf - coupFreq * regCouponsToMaturity, rollDay);
                next2CouponDate      = new DateTime(yf, mf - coupFreq * (regCouponsToMaturity - 1), rollDay);
                prevCouponDate       = new DateTime(yf, mf - coupFreq * (regCouponsToMaturity + 1), rollDay);
                isXD = regCouponsToMaturity > 0 && settlementDate >= new ExDivDate(exdividendType, nextCouponDate, calendar).Date;
                //result = true;
                return(true); //result;
            }
            return(false);
        }
Ejemplo n.º 20
0
        //  Alternative that allows for an arbitrary set of forward dates
        public static double[,] GetRepoRate(this ICarbonClient client, BondAnalytics.Country country,
            List<DateTime> asOfDate, List<DateTime> forwardDates, List<DateTime> holidays, bool bCalcRate)
        {
            int nDates = asOfDate.Count;
            double[,] result = new double[nDates, 2];
            result[0, 0] = -1.0;
            var discCurves = new SortedDictionary<DateTime, Tuple<DateTime, double>[]>();
            //var spreads = new SortedDictionary<DateTime, double>();
            int nAvDates = 20;
            String ccy = getRepoCCYFromCountry(country);

            // Check that asOfDates and forwardDates have same length
            if (asOfDate.Count != forwardDates.Count)
                return result;

            // Setup
            var datelist = new List<DateTime>();
            for (var k = 0; k < nDates; k++)
            {
                var dateSeries = new List<DateTime> { asOfDate[k] };

                for (var i = 1; i < nAvDates; i++)
                {
                    dateSeries.Add(BondAnalytics.PrevBusDay(dateSeries.Last().AddDays(-1), holidays));
                }

                datelist.AddRange(dateSeries);
            }

            datelist = datelist.Distinct().ToList();

            var curvesResult = client.BulkGetHistoricEodDiscountCurves(datelist, ccy, true);
            var repoois = GetRepoOISSpread(client, country, datelist, holidays);

            if (repoois.Count < 0) return result; // skip if no repos

            // Enhance results with repo rates
            for (var k = 0; k < nDates; k++)
            {
                if (repoois.ContainsKey(asOfDate[k]))
                {

                    // Setup spread.
                    double repoSpread = repoois[asOfDate[k]];
                    result[k, 0] = repoSpread;

                    // Setup repo rate
                    if (bCalcRate)
                    {
                        // Get Curves...
                        List<DateTime> dateSeries = new List<DateTime> { asOfDate[k] };
                        //  Need 20 business days prior to asOfDate[k]
                        for (int i = 1; i < nAvDates; i++)
                        {
                            dateSeries.Add(BondAnalytics.PrevBusDay(dateSeries.Last().AddDays(-1), holidays));
                        }
                        //  Need discount curves for each date. May already have them.
                        for (int i = 0; i < nAvDates; i++)
                        {
                            if (!discCurves.ContainsKey(dateSeries[i]))
                            {
                                DiscountCurve curve;
                                curvesResult.TryGetValue(dateSeries[i], out curve);
                                if (curve != null)
                                    discCurves.Add(dateSeries[i], curve.AsTuples());
                            }
                        }

                        // Calc repo rate
                        double oisSwap = -1.0;
                        //  Have already caught the case of missing discount curve above.
                        if (discCurves.ContainsKey(asOfDate[k]))
                        {
                            DateTime[] discDfDates = discCurves[asOfDate[k]].Select(x => x.Item1).ToArray();
                            double[] discDfs = discCurves[asOfDate[k]].Select(x => x.Item2).ToArray();

                            BondAnalytics.DayCountType oisDct = (country == BondAnalytics.Country.CA ||
                                                                 country == BondAnalytics.Country.UK
                                ? BondAnalytics.DayCountType.Act365
                                : BondAnalytics.DayCountType.Act360);
                            oisSwap = asOfDate[k] < forwardDates[k]
                                ? BondAnalytics.CalcMMS(asOfDate[k], forwardDates[k], oisDct, 12, 12, discDfDates,
                                    discDfs,
                                    discDfDates, discDfs, holidays, null, null, null, null, null, DateTime.MinValue, 5)
                                : 0.0;
                        }
                        double repoRate = (oisSwap > -1.0 ? oisSwap + repoSpread : -1.0);
                        result[k, 1] = repoRate;
                    }
                }
            }

            return result;
        }
Ejemplo n.º 21
0
        public static SortedDictionary<DateTime, double> GetRepoOISSpread(this ICarbonClient client, BondAnalytics.Country country, List<DateTime> asOfDate, List<DateTime> holidays)
        {
            // Not the most efficient function, but split out from original
            object o = null;
            int nDates = asOfDate.Count;
            //double[,] result = new double[nDates, 2];
            //result[0, 0] = -1.0;
            var discCurves = new SortedDictionary<DateTime, Tuple<DateTime, double>[]>();
            var spreads = new SortedDictionary<DateTime, double>();
            var result = new SortedDictionary<DateTime, double>();
            int nAvDates = 20;

            string ccy = getRepoCCYFromCountry(country);

            if (ccy == null)
            {
                // This country hasn't been configured yet.
                return result;
            }

            var datelist = new List<DateTime>();
            for (var k = 0; k < nDates; k++)
            {
                var dateSeries = new List<DateTime> { asOfDate[k] };

                for (var i = 1; i < nAvDates; i++)
                {
                    dateSeries.Add(BondAnalytics.PrevBusDay(dateSeries.Last().AddDays(-1), holidays));
                }

                datelist.AddRange(dateSeries);
            }

            datelist = datelist.Distinct().ToList();

            var curvesResult = client.BulkGetHistoricEodDiscountCurves(datelist, ccy, true);
            var gcRatesResult = GetGcRates(client, country, datelist);

            for (int k = 0; k < nDates; k++)
            {
                List<DateTime> dateSeries = new List<DateTime> { asOfDate[k] };
                //  Need 20 business days prior to asOfDate[k]
                for (int i = 1; i < nAvDates; i++)
                {
                    dateSeries.Add(BondAnalytics.PrevBusDay(dateSeries.Last().AddDays(-1), holidays));
                }

                //  Need discount curves for each date. May already have them.
                for (int i = 0; i < nAvDates; i++)
                {
                    if (!discCurves.ContainsKey(dateSeries[i]))
                    {
                        DiscountCurve curve;
                        curvesResult.TryGetValue(dateSeries[i], out curve);
                        if (curve != null)
                            discCurves.Add(dateSeries[i], curve.AsTuples());
                    }
                }
                //  Need repo spread history for each date. May already have it.
                //  If US then use Nomura data, otherwise use ICAP via Carbon
                //                var gmcrProvider = new GenericPricePropertyProvider("gcmr", 1M);
                for (int i = 0; i < nAvDates; i++)
                {
                    if (spreads.ContainsKey(dateSeries[i]))
                        continue;

                    double scaleFactor = 0.01;
                    if (country == BondAnalytics.Country.US)
                    {
                        try
                        {
                            double value;
                            if (gcRatesResult.TryGetValue(dateSeries[i], out value))
                            {
                                o = value;
                            }
                            scaleFactor = 1.0;
                        }
                        catch
                        {
                            //  Missing data
                        }
                    }
                    else if (country == BondAnalytics.Country.DE)
                    {
                        try
                        {
                            o = client.GetCbnTimeSeriesDataCell("GC_GERMAN_SUB_10YR", "eod-icaprepo", dateSeries[i],
                                "wtdRate", new Dictionary<string, string> { { "term", "T-N" } });
                        }
                        catch
                        {
                            //  Missing data
                        }
                    }
                    else if (country == BondAnalytics.Country.FR)
                    {
                        try
                        {
                            o = client.GetCbnTimeSeriesDataCell("GC_FRANCE_FIXED_SUB_10YR", "eod-icaprepo",
                                dateSeries[i], "wtdRate", new Dictionary<string, string> { { "term", "T-N" } });
                        }
                        catch
                        {
                            //  Missing data
                        }
                    }
                    else if (country == BondAnalytics.Country.IT)
                    {
                        try
                        {
                            o = client.GetCbnTimeSeriesDataCell("GC_ITALY_CCP_ALL_BONDS", "eod-icaprepo", dateSeries[i],
                                "wtdRate");
                        }
                        catch
                        {
                            //  Missing data
                        }
                    }
                    else if (country == BondAnalytics.Country.ES)
                    {
                        try
                        {
                            o = client.GetCbnTimeSeriesDataCell("GC_CNET_SPAIN", "eod-icaprepo", dateSeries[i],
                                "wtdRate");
                        }
                        catch
                        {
                            //  Missing data
                        }
                    }
                    else if (country == BondAnalytics.Country.UK)
                    {
                        try
                        {
                            o = client.GetCbnTimeSeriesDataCell("GC_GILT_LCH", "eod-icaprepo", dateSeries[i], "wtdRate",
                                new Dictionary<string, string> { { "term", "O" } });
                        }
                        catch
                        {
                            //  Missing data
                        }
                    }
                    else if (country == BondAnalytics.Country.JP)
                    {
                        try
                        {
                            o = client.GetCbnTimeSeriesDataCell("JPYGCRate", "eod", dateSeries[i], "gcRate");
                        }
                        catch
                        {
                            //  Missing data
                        }
                    }

                    if (discCurves.ContainsKey(dateSeries[i]))
                    {
                        spreads.Add(dateSeries[i],
                            ((o as double?) * scaleFactor ?? 0.0) -
                            Math.Round(
                                (1.0 / discCurves[dateSeries[i]].ElementAt(1).Item2 - 1.0) * 360.0 /
                                (discCurves[dateSeries[i]].ElementAt(1).Item1 -
                                 discCurves[dateSeries[i]].ElementAt(0).Item1).TotalDays, 5));
                    }
                }
                double repoSpread = 0.0;
                for (int i = 0; i < nAvDates; i++)
                {
                    if (spreads.ContainsKey(dateSeries[i]))
                        repoSpread += spreads[dateSeries[i]] / nAvDates;
                }
                //result[k, 0] = repoSpread;
                result[asOfDate[k]] = repoSpread;
            }
            return result;
        }
Ejemplo n.º 22
0
        // This controls which countries are enabled for RepoRates
        public static string getRepoCCYFromCountry(BondAnalytics.Country repoCountry)
        {
            string ccy;
            switch (repoCountry)
            {
                case BondAnalytics.Country.US:
                    ccy = "USD";
                    break;
                case BondAnalytics.Country.BE:
                case BondAnalytics.Country.DE:
                case BondAnalytics.Country.ES:
                case BondAnalytics.Country.FR:
                case BondAnalytics.Country.IT:
                    ccy = "EUR";
                    break;
                case BondAnalytics.Country.UK:
                    ccy = "GBP";
                    break;
                case BondAnalytics.Country.JP:
                    ccy = "JPY";
                    break;
                default:
                    ccy = "";
                    break;
                //case BondAnalytics.Country.CA:
                //    return ccy;


            }
            return ccy;
        }
Ejemplo n.º 23
0
        private static IReadOnlyDictionary<DateTime, double> GetGcRates(ICarbonClient client, BondAnalytics.Country country, List<DateTime> dates)
        {
            var result = new Dictionary<DateTime, double>();
            var inputDateKind = dates.FirstOrDefault().Kind;

            switch (country)
            {
                case BondAnalytics.Country.US:
                    var datesToRequest = new List<DateTime>();
                    foreach (var date in dates)
                    {
                        var d = GetGcRateFromCache(country, date);
                        if (d.HasValue)
                        {
                            result[date] = d.Value;
                        }
                        else if (date <= DateTime.Today)
                        {
                            datesToRequest.Add(date);
                        }
                    }
                    if (datesToRequest.Count == 0) return result;
                    var nomgcRateDates = datesToRequest.Where(d => d < new DateTime(2016, 6, 25)).ToList();
                    var usgcRateDates = datesToRequest.Where(d => d >= new DateTime(2016, 6, 25)).ToList();
                    if (nomgcRateDates.Count > 0)
                    {
                        var end = nomgcRateDates.Max();
                        var start = nomgcRateDates.Min();

                        SLog.log.InfoFormat("Request gc rates for {0} days", nomgcRateDates.Count);

                        start = new DateTime(start.Year, start.Month, start.Day, 0, 0, 0, DateTimeKind.Utc);
                        end = new DateTime(end.Year, end.Month, end.Day, 0, 0, 0, DateTimeKind.Utc);
                        var datas = client.GetTimeSeriesData("NomuraGCRate", "eod", start, end, "gcRate");
                        if (datas != null)
                        {
                            foreach (var data in datas)
                            {
                                try
                                {
                                    var gcRate = data.Value.AsDouble();
                                    var date = new DateTime(data.Key.Year, data.Key.Month, data.Key.Day, 0, 0, 0, inputDateKind);
                                    result[date] = gcRate;
                                    AddGcRateToCache(country, date, gcRate);
                                }
                                catch (Exception ex)
                                {
                                    // ignored
                                }
                            }
                        }
                    }

                    if (usgcRateDates.Count > 0)
                    {
                        var end = usgcRateDates.Max();
                        var start = usgcRateDates.Min();

                        SLog.log.InfoFormat("Request gc rates for {0} days", usgcRateDates.Count);

                        start = new DateTime(start.Year, start.Month, start.Day, 0, 0, 0, DateTimeKind.Utc);
                        end = new DateTime(end.Year, end.Month, end.Day, 0, 0, 0, DateTimeKind.Utc);

                        var datas = client.GetTimeSeriesData("USGCRate", "eod", start, end, "gcRate");
                        if (datas != null)
                        {
                            foreach (var data in datas)
                            {
                                try
                                {
                                    var gcRate = data.Value.AsDouble();
                                    var date = new DateTime(data.Key.Year, data.Key.Month, data.Key.Day, 0, 0, 0, inputDateKind);
                                    result[date] = gcRate;
                                    AddGcRateToCache(country, date, gcRate);
                                }
                                catch (Exception ex)
                                {
                                    // ignored
                                }
                            }
                        }
                    }

                    break;
                case BondAnalytics.Country.DE:
                    break;
                case BondAnalytics.Country.FR:
                    break;
                case BondAnalytics.Country.IT:
                    break;
                case BondAnalytics.Country.ES:
                    break;
                case BondAnalytics.Country.UK:
                    break;
            }
            return result;
        }
Ejemplo n.º 24
0
 private static void AddGcRateToCache(BondAnalytics.Country country, DateTime date, double gcRate)
 {
     var key = string.Format("{0}-{1:yyyyMMdd}", country, date);
     GcRatesCache.AddOrUpdate(key, gcRate, (s, d) => gcRate);
 }
Ejemplo n.º 25
0
 /// <summary>
 /// Compounding frequency to convert to Compounding frequency to convert from Yield to convert
 /// </summary>
 /// <param name="toCompoundingFrequency">The result compounding frequency.</param>
 /// <param name="fromCompoundingFrequency">The base compounding frequency.</param>
 /// <param name="yield">The current yield.</param>
 /// <returns></returns>
 public double ConvertCompoundingFrequencySensitivity(short toCompoundingFrequency, short fromCompoundingFrequency, double yield)
 {
     return(BondAnalytics.ConvertCompFreqSens(toCompoundingFrequency, fromCompoundingFrequency, yield));
 }
Ejemplo n.º 26
0
 /// <summary>
 /// AnnDF
 /// </summary>
 /// <param name="yield"></param>
 /// <param name="compoundingFrequency"></param>
 /// <returns></returns>
 public double AnnDF(double yield, int compoundingFrequency)
 {
     return(BondAnalytics.AnnDF(yield, compoundingFrequency));
 }
Ejemplo n.º 27
0
 /// <summary>
 /// PeriodDF
 /// </summary>
 /// <param name="couponFrequency"></param>
 /// <param name="yield"></param>
 /// <param name="compoundingFrequency"></param>
 /// <returns></returns>
 public double PeriodDF(int couponFrequency, double yield, int compoundingFrequency)
 {
     return(BondAnalytics.PeriodDF(couponFrequency, yield, compoundingFrequency));
 }
Ejemplo n.º 28
0
        public void TestISMADirtyPrice2()//On coupon date, but ex div.
        {
            var result = BondAnalytics.ISMADirtyPrice(0.0, 0, 8, 0.0, 7.0, 7.0, 0.0, 1, 1 / (1.07), .07);

            Debug.WriteLine(String.Format("dirty price : {0}", result));
        }
Ejemplo n.º 29
0
 /// <summary>
 /// IsmaPVBP
 /// </summary>
 /// <param name="c1"></param>
 /// <param name="c"></param>
 /// <param name="cf"></param>
 /// <param name="r"></param>
 /// <param name="q"></param>
 /// <param name="n"></param>
 /// <param name="k"></param>
 /// <param name="v"></param>
 /// <returns></returns>
 public double IsmaPVBP(double c1, double c, double cf, double r, double q, short n,
                        double k, double v)
 {
     return(BondAnalytics.IsmaPVBP(c1, c, cf, r, q, n,
                                   k, v));
 }
Ejemplo n.º 30
0
        public void TestISMADP()
        {
            var result = BondAnalytics.ISMADP(297.0 / 365.0, 0, 8, .07, .07, .07, 0.0, 1, .9434, .06);

            Debug.WriteLine(String.Format("dirty price : {0}", result));
        }
Ejemplo n.º 31
0
 /// <summary>
 /// BondMoosPVBP
 /// </summary>
 /// <param name="c1"></param>
 /// <param name="c"></param>
 /// <param name="cf"></param>
 /// <param name="r"></param>
 /// <param name="q"></param>
 /// <param name="n"></param>
 /// <param name="k"></param>
 /// <param name="h"></param>
 /// <param name="y"></param>
 /// <returns></returns>
 public double BondMoosPVBP(double c1, double c, double cf, double r, double q, short n,
                            double k, short h, double y)
 {
     return(BondAnalytics.BondMoosPVBP(c1, c, cf, r, q, n,
                                       k, h, y));
 }
Ejemplo n.º 32
0
        public void CalculateYTM1()
        {
            var ytm = BondAnalytics.CalculateBondYTM(DateTime.Parse("15/05/13"), DateTime.Parse("15/11/08"), .065, 2, 100, 113.27);

            Debug.WriteLine(String.Format("ytm : {0}", 100 * ytm));
        }
Ejemplo n.º 33
0
 /// <summary>
 /// d2Pdv2
 /// </summary>
 /// <param name="q"></param>
 /// <param name="c1"></param>
 /// <param name="periodDiscountFactor"></param>
 /// <param name="c"></param>
 /// <param name="n"></param>
 /// <param name="r"></param>
 /// <param name="cf"></param>
 /// <param name="k"></param>
 /// <returns></returns>
 public double D2Pdv2(double q, double c1, double periodDiscountFactor, double c, int n, double r, double cf,
                      double k)
 {
     return(BondAnalytics.d2Pdv2(q, c1, periodDiscountFactor, c, n, r, cf,
                                 k));
 }
Ejemplo n.º 34
0
 /// <summary>
 /// CountCoupPdsEx
 /// </summary>
 /// <param name="ys"></param>
 /// <param name="ms"></param>
 /// <param name="rollDay"></param>
 /// <param name="ye"></param>
 /// <param name="me"></param>
 /// <param name="de"></param>
 /// <param name="couponFrequency"></param>
 /// <returns></returns>
 public int CountCoupPdsEx(int ys, int ms, int rollDay, int ye, int me, int de, int couponFrequency)
 {
     return(BondAnalytics.CountCoupPdsEx(ys, ms, rollDay, ye, me, de, couponFrequency));
 }
Ejemplo n.º 35
0
        // Compute repo rates based on an input repo-ois spread
        public static double[,] CalcRepoRatesFromOisSpread(this ICarbonClient client, Series<DateTime, double> repoSpdSrs, BondAnalytics.Country country, List<DateTime> asOfDate, List<DateTime> forwardDates,
            List<DateTime> holidays, Dictionary<DateTime, Tuple<DateTime, double>[]> discCurves = null)
        {
            // Init
            var holSet = new HashSet<DateTime>(holidays);
            var ccy = getRepoCCYFromCountry(country);

            // Checks
            if (asOfDate.Count != forwardDates.Count)
            {
                throw new ArgumentException("#Error: as of dates and forward dates need to have the same length!");
            }

            
            // Get swap curves if not specified
            if (discCurves == null)
            {
                discCurves = new Dictionary<DateTime, Tuple<DateTime, double>[]>();
                var rawCurves = client.BulkGetHistoricEodDiscountCurves(asOfDate, ccy, true);

                foreach (var kvp in rawCurves)
                {
                    discCurves[kvp.Key] = kvp.Value.AsTuples();
                }
            }

            // Get Results
            double[,] results = new double[asOfDate.Count, 2];
            for (int i = 0; i < asOfDate.Count; ++i)
            {
                var dte = asOfDate[i];
                var fwddte = forwardDates[i];
                var spdAttempt = repoSpdSrs.TryGet(dte);
                double repoRate;
                double repoSpread;

                if (spdAttempt.HasValue && !holSet.Contains(dte))
                {

                    // Calc repo rate
                    repoSpread = spdAttempt.Value;
                    double oisSwap = double.NaN;

                    //  Have already caught the case of missing discount curve above.
                    if (discCurves.ContainsKey(dte))
                    {
                        var tups = discCurves[dte];
                        DateTime[] discDfDates = tups.Select(x => x.Item1).ToArray();
                        double[] discDfs = tups.Select(x => x.Item2).ToArray();

                        BondAnalytics.DayCountType oisDct = (country == BondAnalytics.Country.CA ||
                                                             country == BondAnalytics.Country.UK
                            ? BondAnalytics.DayCountType.Act365
                            : BondAnalytics.DayCountType.Act360);

                        oisSwap = dte < fwddte
                            ? BondAnalytics.CalcMMS(dte, fwddte, oisDct, 12, 12, discDfDates,
                                discDfs,
                                discDfDates, discDfs, holidays, null, null, null, null, null, DateTime.MinValue, 5)
                            : double.NaN;
                    }

                    repoRate = double.IsNaN(oisSwap) ? double.NaN : oisSwap + repoSpread;
                }
                else
                {
                    repoRate = double.NaN;
                    repoSpread = double.NaN;
                }

                results[i, 0] = repoSpread;
                results[i, 1] = repoRate;
            }
            return results;
        }