Example #1
0
        double GetDefaultIncrement(BankRateEvent curEvent, DateTime curDate)
        {
            int remainDays = (curEvent.EndDate - curDate).Days;

            if (remainDays < 0)
            {
                return 0.0;
            }

            if (remainDays < 90)
            {
                double y = (double)remainDays / 90;
                double increment = y * curEvent.TargetIncrement * (-1);
                return increment;
            }
            else if (remainDays <= 670)
            {
                return curEvent.TargetIncrement * (-1);
            }
            else
            {
                double daysAfterStart = (365 * 2 + 1) - remainDays;
                Trace.Assert(daysAfterStart <= 60);
                if (daysAfterStart < 0)
                {
                    return 0.0;
                }
                Trace.Assert(daysAfterStart >= 0);
                double y = daysAfterStart / 60;
                double increment = y * curEvent.TargetIncrement * (-1);
                return increment;
            }
        }
Example #2
0
        public double GetIncrement(BankRateEvent lastEvent, List<BankRateEvent> events, DateTime curDate, double weight)
        {
            List<double> increments = new List<double>();
            foreach (BankRateEvent ev in events)
            {
                double curIncrement = GetIncrementEach(lastEvent, ev, curDate);
                increments.Add(curIncrement);
            }

            double totalIncrement = weight * (1.0 + increments.Sum());

            totalIncrement = MathUtil.CapAndFloor(totalIncrement);

            if (totalIncrement < 0.0)
            {
                logger.Warn("BankRate TotalIncrement < 0.0 ({0})", totalIncrement);
                totalIncrement = 0.0;
            }

            return totalIncrement;
        }
Example #3
0
        double GetDoubleDownFactor(BankRateEvent lastEvent, BankRateEvent curEvent)
        {
            Trace.Assert(lastEvent.UpDown != UpDown.Same);
            Trace.Assert(lastEvent.UpDown != UpDown.Unknown);
            Trace.Assert(curEvent.UpDown != UpDown.Same);
            Trace.Assert(curEvent.UpDown != UpDown.Unknown);

            double factor = 1;
            const double kFactor = 1.3;
            //const double kFactor = 1000;
            double devide = kFactor;
            if (lastEvent.UpDown != curEvent.UpDown)
            {
                devide = kFactor;
            }

            int diff = lastEvent.EventKey - curEvent.EventKey;
            for (int i = 0; i < diff; ++i)
            {
                factor /= devide;
            }
            return factor;
        }
Example #4
0
        double GetIncrementEach(
            BankRateEvent lastEvent,
            BankRateEvent curEvent,
            DateTime curDate)
        {
            if (curEvent.EndDate < curDate)
            {
                // 기한이 지났다.
                return 0;
            }
            double doubleDownFactor = GetDoubleDownFactor(lastEvent, curEvent);
            double defaultIncrement = GetDefaultIncrement(curEvent, curDate);

            double ret = defaultIncrement * doubleDownFactor;
            return ret;
        }
Example #5
0
        double CalculateBankRateAdj()
        {
            double adjValue = 1.0;

            for (int i = 1; i < _sortedCalendarData.Count; ++i)
            {
                Tuple<DateTime, double> prev = _sortedCalendarData[i - 1];
                Tuple<DateTime, double> cur = _sortedCalendarData[i];

                double prevValue = prev.Item2;
                double curValue = cur.Item2;

                if (!DoubleUtil.IsSameDouble(prevValue, curValue, 4))
                {
                    double increment = curValue / prevValue - 1;
                    // 금리 변동이 있다.
                    BankRateEvent ev = new BankRateEvent();
                    ev.TargetIncrement = increment;
                    ev.StartDate = cur.Item1;
                    ev.EndDate = ev.StartDate.AddYears(kEventDuration);
                    ev.EventKey = _eventKeyGenerator++;
                    ev.UpDown = increment > 0 ? UpDown.Up : UpDown.Down;

                    _events.Add(ev);
                    _lastEvent = ev;
                }
            }
            adjValue = _policy.GetIncrement(_lastEvent, _events, _dtEnd, _weight);

            return adjValue;
        }