QLNet.InterestRateIndex.fixing C# (CSharp) Метод

        public override double fixing(Date fixingDate, bool forecastTodaysFixing)
        {
            if (!isValidFixingDate(fixingDate))
                throw new ArgumentException("Fixing date " + fixingDate + " is not valid");

            TimeSeries<double> fixings = IndexManager.instance().getHistory(name()).value();
            if (fixings.ContainsKey(fixingDate))
            {
                return fixings[fixingDate];
            }

            Date today = Settings.evaluationDate();
            if (fixingDate < today
                || (fixingDate == today && !forecastTodaysFixing && Settings.enforcesTodaysHistoricFixings))
            {
                // must have been fixed
                if (IndexManager.MissingPastFixingCallBack == null)
                {
                    throw new ArgumentException("Missing " + name() + " fixing for " + fixingDate);
                }

                // try to load missing fixing from external source
                double fixing = IndexManager.MissingPastFixingCallBack(this, fixingDate);
                // add to history
                addFixing(fixingDate, fixing);
                return fixing;
            }

            if ((fixingDate == today) && !forecastTodaysFixing)
            {
                // might have been fixed but forecast since it does not exist
                // so fall through and forecast
            }

            // forecast
            return forecastFixing(fixingDate);
        }

        public override double swapletRate()
        {
            List <Date>       fixingDates = coupon_.fixingDates();
            InterestRateIndex index       = coupon_.index();

            int  cutoffDays = 0; // to be verified
            Date startDate  = coupon_.accrualStartDate() - cutoffDays,
                 endDate    = coupon_.accrualEndDate() - cutoffDays,
                 d1         = startDate,
                 d2         = startDate;

            if (!(fixingDates.Count > 0))
            {
                throw new ApplicationException("fixing date list empty");
            }
            if (!(index.valueDate(fixingDates.First()) <= startDate))
            {
                throw new ApplicationException("first fixing date valid after period start");
            }
            if (!(index.valueDate(fixingDates.Last()) >= endDate))
            {
                throw new ApplicationException("last fixing date valid before period end");
            }

            double avgBMA = 0.0;
            int    days   = 0;

            for (int i = 0; i < fixingDates.Count - 1; ++i)
            {
                Date valueDate     = index.valueDate(fixingDates[i]);
                Date nextValueDate = index.valueDate(fixingDates[i + 1]);

                if (fixingDates[i] >= endDate || valueDate >= endDate)
                {
                    break;
                }
                if (fixingDates[i + 1] < startDate || nextValueDate <= startDate)
                {
                    continue;
                }

                d2 = Date.Min(nextValueDate, endDate);

                avgBMA += index.fixing(fixingDates[i]) * (d2 - d1);

                days += d2 - d1;
                d1    = d2;
            }
            avgBMA /= (endDate - startDate);

            if (!(days == endDate - startDate))
            {
                throw new ApplicationException("averaging days " + days + " differ from " +
                                               "interest days " + (endDate - startDate));
            }

            return(coupon_.gearing() * avgBMA + coupon_.spread());
        }