DateUtil.java

  1. package org.drip.analytics.date;

  3. /*
  4.  * -*- mode: java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  5.  */

  7. /*!
  8.  * Copyright (C) 2020 Lakshmi Krishnamurthy
  9.  * Copyright (C) 2019 Lakshmi Krishnamurthy
  10.  * Copyright (C) 2018 Lakshmi Krishnamurthy
  11.  * Copyright (C) 2017 Lakshmi Krishnamurthy
  12.  * Copyright (C) 2016 Lakshmi Krishnamurthy
  13.  * Copyright (C) 2015 Lakshmi Krishnamurthy
  14.  * Copyright (C) 2014 Lakshmi Krishnamurthy
  15.  * 
  16.  *  This file is part of DROP, an open-source library targeting analytics/risk, transaction cost analytics,
  17.  *      asset liability management analytics, capital, exposure, and margin analytics, valuation adjustment
  18.  *      analytics, and portfolio construction analytics within and across fixed income, credit, commodity,
  19.  *      equity, FX, and structured products. It also includes auxiliary libraries for algorithm support,
  20.  *      numerical analysis, numerical optimization, spline builder, model validation, statistical learning,
  21.  *      and computational support.
  22.  *  
  23.  *      https://lakshmidrip.github.io/DROP/
  24.  *  
  25.  *  DROP is composed of three modules:
  26.  *  
  27.  *  - DROP Product Core - https://lakshmidrip.github.io/DROP-Product-Core/
  28.  *  - DROP Portfolio Core - https://lakshmidrip.github.io/DROP-Portfolio-Core/
  29.  *  - DROP Computational Core - https://lakshmidrip.github.io/DROP-Computational-Core/
  30.  * 
  31.  *  DROP Product Core implements libraries for the following:
  32.  *  - Fixed Income Analytics
  33.  *  - Loan Analytics
  34.  *  - Transaction Cost Analytics
  35.  * 
  36.  *  DROP Portfolio Core implements libraries for the following:
  37.  *  - Asset Allocation Analytics
  38.  *  - Asset Liability Management Analytics
  39.  *  - Capital Estimation Analytics
  40.  *  - Exposure Analytics
  41.  *  - Margin Analytics
  42.  *  - XVA Analytics
  43.  * 
  44.  *  DROP Computational Core implements libraries for the following:
  45.  *  - Algorithm Support
  46.  *  - Computation Support
  47.  *  - Function Analysis
  48.  *  - Model Validation
  49.  *  - Numerical Analysis
  50.  *  - Numerical Optimizer
  51.  *  - Spline Builder
  52.  *  - Statistical Learning
  53.  * 
  54.  *  Documentation for DROP is Spread Over:
  55.  * 
  56.  *  - Main                     => https://lakshmidrip.github.io/DROP/
  57.  *  - Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
  58.  *  - GitHub                   => https://github.com/lakshmiDRIP/DROP
  59.  *  - Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
  60.  *  - Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
  61.  *  - Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
  62.  *  - Release Versions         => https://lakshmidrip.github.io/DROP/version.html
  63.  *  - Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
  64.  *  - Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues
  65.  *  - JUnit                    => https://lakshmidrip.github.io/DROP/junit/index.html
  66.  *  - Jacoco                   => https://lakshmidrip.github.io/DROP/jacoco/index.html
  67.  * 
  68.  *  Licensed under the Apache License, Version 2.0 (the "License");
  69.  *      you may not use this file except in compliance with the License.
  70.  *   
  71.  *  You may obtain a copy of the License at
  72.  *      http://www.apache.org/licenses/LICENSE-2.0
  73.  *  
  74.  *  Unless required by applicable law or agreed to in writing, software
  75.  *      distributed under the License is distributed on an "AS IS" BASIS,
  76.  *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  77.  *  
  78.  *  See the License for the specific language governing permissions and
  79.  *      limitations under the License.
  80.  */

  82. /**
  83.  * <i>DateUtil</i> contains Various Utilities for manipulating Date. The Julian Date - Gregorian Date Inter
  84.  * Conversion follows the following References:
  85.  *
  86.  *  <br><br>
  87.  *  <ul>
  88.  *      <li>
  89.  *          Fliegel, H. F., and T. C. van Flandern (1968): A Machine Algorithm for Processing Calendar Dates 
  90.  *              <i>Communications of the ACM</i> <b>11</b> 657
  91.  *      </li>
  92.  *      <li>
  93.  *          Fenton, D. (2001): Julian to Calendar Date Conversion
  94.  *              http://mathforum.org/library/drmath/view/51907.html
  95.  *      </li>
  96.  *  </ul>
  97.  *
  98.  *  <br><br>
  99.  *  <ul>
  100.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ProductCore.md">Product Core Module</a></li>
  101.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/FixedIncomeAnalyticsLibrary.md">Fixed Income Analytics</a></li>
  102.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/analytics/README.md">Date, Cash Flow, and Cash Flow Period Measure Generation Utilities</a></li>
  103.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/analytics/date/README.md">Date and Time Creation, Manipulation, and Usage</a></li>
  104.  *  </ul>
  105.  * 
  106.  * @author Lakshmi Krishnamurthy
  107.  */

  109. public class DateUtil {

  111.     /**
  112.      * HALF_SECOND Constant for Julian Date Construction
  113.      */

  115.     public static double HALFSECOND = 0.5;

  117.     /**
  118.      * JGREG Constant for Julian Date Construction
  119.      */

  121.     public static int JGREG = 15 + 31 * (10 + 12 * 1582);

  123.     /**
  124.      * LEFT_INCLUDE includes the start date in the Feb29 check
  125.      */

  127.     public static final int LEFT_INCLUDE = 1;

  129.     /**
  130.      * RIGHT_INCLUDE includes the end date in the Feb29 check
  131.      */

  133.     public static final int RIGHT_INCLUDE = 2;

  135.     /**
  136.      * Days of the week - Monday
  137.      */

  139.     public static final int MONDAY = 0;

  141.     /**
  142.      * Days of the week - Tuesday
  143.      */

  145.     public static final int TUESDAY = 1;

  147.     /**
  148.      * Days of the week - Wednesday
  149.      */

  151.     public static final int WEDNESDAY = 2;

  153.     /**
  154.      * Days of the week - Thursday
  155.      */

  157.     public static final int THURSDAY = 3;

  159.     /**
  160.      * Days of the week - Friday
  161.      */

  163.     public static final int FRIDAY = 4;

  165.     /**
  166.      * Days of the week - Saturday
  167.      */

  169.     public static final int SATURDAY = 5;

  171.     /**
  172.      * Days of the week - Sunday
  173.      */

  175.     public static final int SUNDAY = 6;

  177.     /**
  178.      * Integer Month - January
  179.      */

  181.     public static final int JANUARY = 1;

  183.     /**
  184.      * Integer Month - February
  185.      */

  187.     public static final int FEBRUARY = 2;

  189.     /**
  190.      * Integer Month - March
  191.      */

  193.     public static final int MARCH = 3;

  195.     /**
  196.      * Integer Month - April
  197.      */

  199.     public static final int APRIL = 4;

  201.     /**
  202.      * Integer Month - May
  203.      */

  205.     public static final int MAY = 5;

  207.     /**
  208.      * Integer Month - June
  209.      */

  211.     public static final int JUNE = 6;

  213.     /**
  214.      * Integer Month - July
  215.      */

  217.     public static final int JULY = 7;

  219.     /**
  220.      * Integer Month - August
  221.      */

  223.     public static final int AUGUST = 8;

  225.     /**
  226.      * Integer Month - September
  227.      */

  229.     public static final int SEPTEMBER = 9;

  231.     /**
  232.      * Integer Month - October
  233.      */

  235.     public static final int OCTOBER = 10;

  237.     /**
  238.      * Integer Month - November
  239.      */

  241.     public static final int NOVEMBER = 11;

  243.     /**
  244.      * Integer Month - December
  245.      */

  247.     public static final int DECEMBER = 12;

  249.     /**
  250.      * Convert YMD to an Integer Julian Date.
  251.      * 
  252.      * @param iYear Year
  253.      * @param iMonth Month
  254.      * @param iDay Day
  255.      * 
  256.      * @return Integer representing the Julian Date
  257.      * 
  258.      * @throws java.lang.Exception Thrown if the Inputs are invalid
  259.      */

  261.     public static int ToJulian (
  262.         final int iYear,
  263.         final int iMonth,
  264.         final int iDay)
  265.         throws java.lang.Exception
  266.     {
  267.         if (0 > iYear || 0 > iMonth || 0 > iDay)
  268.             throw new java.lang.Exception ("DateUtil::ToJulian => Invalid Inputs");

  270.         int iM1 = (iMonth - 14) / 12;
  271.         int iY1 = iYear + 4800;
  272.         return 1461 * (iY1 + iM1) / 4 + 367 * (iMonth - 2 - 12 * iM1) / 12 -
  273.             (3 * ((iY1 + iM1 + 100) / 100)) / 4 + iDay - 32075;
  274.     }

  276.     /**
  277.      * Create an YYYY/MM/DD String from the Input Julian Integer
  278.      * 
  279.      * @param iJulian Integer representing Julian Date
  280.      * 
  281.      * @return YYYY/MM/DD Date String
  282.      */

  284.     public static java.lang.String YYYYMMDD (
  285.         final int iJulian)
  286.     {
  287.         int iP = iJulian + 68569;
  288.         int iQ = 4 * iP / 146097;
  289.         int iR = iP - (146097 * iQ + 3) / 4;
  290.         int iS = 4000 * (iR + 1) / 1461001;
  291.         int iT = iR - (1461 * iS / 4) + 31;
  292.         int iU = 80 * iT / 2447;
  293.         int iV = iU / 11;
  294.         int iY = 100 * (iQ - 49) + iS + iV;
  295.         int iM = iU + 2 - 12 * iV;
  296.         int iD = iT - (2447 * iU / 80);

  298.         return "" + iY + "/" + org.drip.numerical.common.FormatUtil.FormatDouble (iM, 2, 0, 1., false) + "/" +
  299.             org.drip.numerical.common.FormatUtil.FormatDouble (iD, 2, 0, 1., false);
  300.     }

  302.     /**
  303.      * Create an DD/MMM/YYYY String from the Input Julian Integer
  304.      * 
  305.      * @param iJulian Integer representing Julian Date
  306.      * 
  307.      * @return DD/MMM/YYYY Date String
  308.      */

  310.     public static java.lang.String DDMMMYYYY (
  311.         final int iJulian)
  312.     {
  313.         int iP = iJulian + 68569;
  314.         int iQ = 4 * iP / 146097;
  315.         int iR = iP - (146097 * iQ + 3) / 4;
  316.         int iS = 4000 * (iR + 1) / 1461001;
  317.         int iT = iR - (1461 * iS / 4) + 31;
  318.         int iU = 80 * iT / 2447;
  319.         int iV = iU / 11;
  320.         int iY = 100 * (iQ - 49) + iS + iV;
  321.         int iM = iU + 2 - 12 * iV;
  322.         int iD = iT - (2447 * iU / 80);

  324.         return org.drip.numerical.common.FormatUtil.FormatDouble (iD, 2, 0, 1., false) + "-" + MonthTrigram (iM)
  325.             + "-" + iY;
  326.     }

  328.     /**
  329.      * Return the Year corresponding to the Julian Date
  330.      * 
  331.      * @param iJulian Integer representing Julian Date
  332.      * 
  333.      * @return integer representing the month
  334.      * 
  335.      * @throws java.lang.Exception Thrown if the Input Date in invalid
  336.      */

  338.     public static int Year (
  339.         final int iJulian)
  340.         throws java.lang.Exception
  341.     {
  342.         int iP = iJulian + 68569;
  343.         int iQ = 4 * iP / 146097;
  344.         int iR = iP - (146097 * iQ + 3) / 4;
  345.         int iS = 4000 * (iR + 1) / 1461001;
  346.         int iT = iR - (1461 * iS / 4) + 31;
  347.         int iU = 80 * iT / 2447;
  348.         int iV = iU / 11;
  349.         return 100 * (iQ - 49) + iS + iV;
  350.     }

  352.     /**
  353.      * Return the Month given the Julian Date represented by the Integer.
  354.      * 
  355.      * @param iJulian Integer representing Julian Date
  356.      * 
  357.      * @return Integer representing the Month
  358.      * 
  359.      * @throws java.lang.Exception Thrown if the Input Date is invalid
  360.      */

  362.     public static int Month (
  363.         final int iJulian)
  364.         throws java.lang.Exception
  365.     {
  366.         int iP = iJulian + 68569;
  367.         int iQ = 4 * iP / 146097;
  368.         int iR = iP - (146097 * iQ + 3) / 4;
  369.         int iS = 4000 * (iR + 1) / 1461001;
  370.         int iT = iR - (1461 * iS / 4) + 31;
  371.         int iU = 80 * iT / 2447;
  372.         int iV = iU / 11;
  373.         return iU + 2 - 12 * iV;
  374.     }

  376.     /**
  377.      * Return the Date given the Julian Date represented by the Integer.
  378.      * 
  379.      * @param iJulian Integer representing Julian Date
  380.      * 
  381.      * @return Integer representing the Date
  382.      * 
  383.      * @throws java.lang.Exception Thrown if the Input Date is invalid
  384.      */

  386.     public static int Date (
  387.         final int iJulian)
  388.         throws java.lang.Exception
  389.     {
  390.         int iP = iJulian + 68569;
  391.         int iQ = 4 * iP / 146097;
  392.         int iR = iP - (146097 * iQ + 3) / 4;
  393.         int iS = 4000 * (iR + 1) / 1461001;
  394.         int iT = iR - (1461 * iS / 4) + 31;
  395.         int iU = 80 * iT / 2447;
  396.         return iT - (2447 * iU / 80);
  397.     }

  399.     /**
  400.      * Return the Vintage corresponding to the Julian Date
  401.      * 
  402.      * @param iJulian Integer representing Julian Date
  403.      * 
  404.      * @return String Representing the Vintage
  405.      */

  407.     public static java.lang.String Vintage (
  408.         final int iJulian)
  409.     {
  410.         int iP = iJulian + 68569;
  411.         int iQ = 4 * iP / 146097;
  412.         int iR = iP - (146097 * iQ + 3) / 4;
  413.         int iS = 4000 * (iR + 1) / 1461001;
  414.         int iT = iR - (1461 * iS / 4) + 31;
  415.         int iU = 80 * iT / 2447;
  416.         int iV = iU / 11;
  417.         int iY = 100 * (iQ - 49) + iS + iV;
  418.         int iM = iU + 2 - 12 * iV;

  420.         return MonthTrigram (iM) + "-" + iY;
  421.     }

  423.     /**
  424.      * Number of Days elapsed in the Year represented by the given Julian Date
  425.      * 
  426.      * @param iDate Integer representing Julian Date
  427.      * 
  428.      * @return Integer representing the Number of Days in the Current Year
  429.      * 
  430.      * @throws java.lang.Exception Thrown if the Input Date is invalid
  431.      */

  433.     public static final int DaysElapsed (
  434.         final int iDate)
  435.         throws java.lang.Exception
  436.     {
  437.         return iDate - ToJulian (Year (iDate), JANUARY, 1);
  438.     }

  440.     /**
  441.      * Number of Days remaining in the Year represented by the given Julian Date
  442.      * 
  443.      * @param iDate Integer representing Julian Date
  444.      * 
  445.      * @return Integer representing the Number of Days remaining in the Current Year
  446.      * 
  447.      * @throws java.lang.Exception Thrown if the Input Date is invalid
  448.      */

  450.     public static final int DaysRemaining (
  451.         final int iDate)
  452.         throws java.lang.Exception
  453.     {
  454.         return ToJulian (Year (iDate), DECEMBER, 31) - iDate;
  455.     }

  457.     /**
  458.      * Indicate if the Year of the given Julian Date is a Leap Year
  459.      * 
  460.      * @param iDate Input Date
  461.      * 
  462.      * @return TRUE - Date falls on a Leap Year
  463.      * 
  464.      * @throws java.lang.Exception Thrown if Input is invalid
  465.      */

  467.     public static final boolean IsLeapYear (
  468.         final int iDate)
  469.         throws java.lang.Exception
  470.     {
  471.         return 0 == (Year (iDate) % 4);
  472.     }

  474.     /**
  475.      * Indicate whether there is at least One Leap Day between 2 given Dates
  476.      * 
  477.      * @param iStartDate The Start Date
  478.      * @param iEndDate The End Date
  479.      * @param iIncludeSide INCLUDE_LEFT or INCLUDE_RIGHT indicating whether the starting date, the ending
  480.      *  date, or both dates are to be included
  481.      *  
  482.      * @return TRUE - There is at least One Feb29 between the Dates
  483.      * 
  484.      * @throws java.lang.Exception If inputs are invalid
  485.      */

  487.     public static final boolean ContainsFeb29 (
  488.         final int iStartDate,
  489.         final int iEndDate,
  490.         final int iIncludeSide)
  491.         throws java.lang.Exception
  492.     {
  493.         if (iStartDate >= iEndDate) return false;

  495.         int iLeftDate = iStartDate;
  496.         int iRightDate = iEndDate;

  498.         if (0 == (iIncludeSide & LEFT_INCLUDE)) ++iLeftDate;

  500.         if (0 == (iIncludeSide & RIGHT_INCLUDE)) --iRightDate;

  502.         for (int iDate = iLeftDate; iDate <= iRightDate; ++iDate) {
  503.             if (FEBRUARY == Month (iDate) && 29 == Date (iDate)) return true;
  504.         }

  506.         return false;
  507.     }

  509.     /**
  510.      * Calculate how many Leap Days exist between the 2 given Dates
  511.      * 
  512.      * @param iStartDate The Start Date
  513.      * @param iEndDate The End Date
  514.      * @param iIncludeSide INCLUDE_LEFT or INCLUDE_RIGHT indicating whether the starting date, the ending
  515.      *  date, or both dates are to be included
  516.      * 
  517.      * @return Number of Leap Days
  518.      * 
  519.      * @throws java.lang.Exception Thrown if the Inputs are invalid
  520.      */

  522.     public static final int NumFeb29 (
  523.         final int iStartDate,
  524.         final int iEndDate,
  525.         final int iIncludeSide)
  526.         throws java.lang.Exception
  527.     {
  528.         int iNumFeb29 = 0;
  529.         boolean bLoop = true;
  530.         int iDate = iStartDate;

  532.         while (bLoop) {
  533.             int iPeriodEndDate = iDate + 365;

  535.             if (iPeriodEndDate > iEndDate) {
  536.                 bLoop = false;
  537.                 iPeriodEndDate = iEndDate;
  538.             }

  540.             if (ContainsFeb29 (iDate, iPeriodEndDate, iIncludeSide)) ++iNumFeb29;

  542.             iDate = iPeriodEndDate;
  543.         }

  545.         return iNumFeb29;
  546.     }

  548.     /**
  549.      * Return the English word corresponding to the input integer month
  550.      *  
  551.      * @param iMonth Integer representing the month
  552.      * 
  553.      * @return String of the English word
  554.      */

  556.     public static final java.lang.String MonthChar (
  557.         final int iMonth)
  558.     {
  559.         if (JANUARY == iMonth) return "January";

  561.         if (FEBRUARY == iMonth) return "February";

  563.         if (MARCH == iMonth) return "March";

  565.         if (APRIL == iMonth) return "April";

  567.         if (MAY == iMonth) return "May";

  569.         if (JUNE == iMonth) return "June";

  571.         if (JULY == iMonth) return "July";

  573.         if (AUGUST == iMonth) return "August";

  575.         if (SEPTEMBER == iMonth) return "September";

  577.         if (OCTOBER == iMonth) return "October";

  579.         if (NOVEMBER == iMonth) return "November";

  581.         if (DECEMBER == iMonth) return "December";

  583.         return null;
  584.     }

  586.     /**
  587.      * Return the Month Trigram corresponding to the Input Integer Month
  588.      * 
  589.      * @param iMonth Integer representing the Month
  590.      * 
  591.      * @return String representing the Month Trigram (used, e.g., in Oracle DB)
  592.      */

  594.     public static java.lang.String MonthTrigram (
  595.         final int iMonth)
  596.     {
  597.         if (JANUARY == iMonth) return "JAN";

  599.         if (FEBRUARY == iMonth) return "FEB";

  601.         if (MARCH == iMonth) return "MAR";

  603.         if (APRIL == iMonth) return "APR";

  605.         if (MAY == iMonth) return "MAY";

  607.         if (JUNE == iMonth) return "JUN";

  609.         if (JULY == iMonth) return "JUL";

  611.         if (AUGUST == iMonth) return "AUG";

  613.         if (SEPTEMBER == iMonth) return "SEP";

  615.         if (OCTOBER == iMonth) return "OCT";

  617.         if (NOVEMBER == iMonth) return "NOV";

  619.         if (DECEMBER == iMonth) return "DEC";

  621.         return null;
  622.     }

  624.     /**
  625.      * Convert the month trigram/word to the corresponding month integer
  626.      * 
  627.      * @param strMonth Month trigram or English Word
  628.      * 
  629.      * @return Integer representing the Month
  630.      * 
  631.      * @throws java.lang.Exception Thrown on Invalid Input Month
  632.      */

  634.     public static final int MonthFromMonthChars (
  635.         final java.lang.String strMonth)
  636.         throws java.lang.Exception
  637.     {
  638.         if (null == strMonth || strMonth.isEmpty())
  639.             throw new java.lang.Exception ("DateUtil::MonthFromMonthChars => Invalid Month!");

  641.         if (strMonth.equalsIgnoreCase ("JAN") || strMonth.equalsIgnoreCase ("JANUARY")) return JANUARY;

  643.         if (strMonth.equalsIgnoreCase ("FEB") || strMonth.equalsIgnoreCase ("FEBRUARY")) return FEBRUARY;

  645.         if (strMonth.equalsIgnoreCase ("MAR") || strMonth.equalsIgnoreCase ("MARCH")) return MARCH;

  647.         if (strMonth.equalsIgnoreCase ("APR") || strMonth.equalsIgnoreCase ("APRIL")) return APRIL;

  649.         if (strMonth.equalsIgnoreCase ("MAY")) return MAY;

  651.         if (strMonth.equalsIgnoreCase ("JUN") || strMonth.equalsIgnoreCase ("JUNE")) return JUNE;

  653.         if (strMonth.equalsIgnoreCase ("JUL") || strMonth.equalsIgnoreCase ("JULY")) return JULY;

  655.         if (strMonth.equalsIgnoreCase ("AUG") || strMonth.equalsIgnoreCase ("AUGUST")) return AUGUST;

  657.         if (strMonth.equalsIgnoreCase ("SEP") || strMonth.equalsIgnoreCase ("SEPTEMBER") ||
  658.             strMonth.equalsIgnoreCase ("SEPT"))
  659.             return SEPTEMBER;

  661.         if (strMonth.equalsIgnoreCase ("OCT") || strMonth.equalsIgnoreCase ("OCTOBER")) return OCTOBER;

  663.         if (strMonth.equalsIgnoreCase ("NOV") || strMonth.equalsIgnoreCase ("NOVEMBER")) return NOVEMBER;

  665.         if (strMonth.equalsIgnoreCase ("DEC") || strMonth.equalsIgnoreCase ("DECEMBER")) return DECEMBER;

  667.         throw new java.lang.Exception ("DateUtil::MonthFromMonthChars => Invalid Month: " + strMonth);
  668.     }

  670.     /**
  671.      * Get the English word for day corresponding to the input integer
  672.      * 
  673.      * @param iDay Integer representing the day
  674.      * 
  675.      * @return String representing the English word for the day
  676.      */

  678.     public static java.lang.String DayChars (
  679.         final int iDay)
  680.     {
  681.         if (MONDAY == iDay) return "Monday";

  683.         if (TUESDAY == iDay) return "Tuesday";

  685.         if (WEDNESDAY == iDay) return "Wednesday";

  687.         if (THURSDAY == iDay) return "Thursday";

  689.         if (FRIDAY == iDay) return "Friday";

  691.         if (SATURDAY == iDay) return "Saturday";

  693.         if (SUNDAY == iDay) return "Sunday";

  695.         return "";
  696.     }

  698.     /**
  699.      * Get the maximum number of days in the given month and year
  700.      * 
  701.      * @param iMonth Integer representing the month
  702.      * @param iYear Integer representing the year
  703.      * 
  704.      * @return Integer representing the maximum days
  705.      * 
  706.      * @throws java.lang.Exception Thrown if inputs are invalid
  707.      */

  709.     public static final int DaysInMonth (
  710.         final int iMonth,
  711.         final int iYear)
  712.         throws java.lang.Exception
  713.     {
  714.         if (JANUARY == iMonth) return 31;

  716.         if (FEBRUARY == iMonth) return 0 == (iYear % 4) ? 29 : 28;

  718.         if (MARCH == iMonth) return 31;

  720.         if (APRIL == iMonth) return 30;

  722.         if (MAY == iMonth) return 31;

  724.         if (JUNE == iMonth) return 30;

  726.         if (JULY == iMonth) return 31;

  728.         if (AUGUST == iMonth) return 31;

  730.         if (SEPTEMBER == iMonth) return 30;

  732.         if (OCTOBER == iMonth) return 31;

  734.         if (NOVEMBER == iMonth) return 30;

  736.         if (DECEMBER == iMonth) return 31;

  738.         throw new java.lang.Exception ("DateUtil::DaysInMonth => Invalid Month: " + iMonth);
  739.     }

  741.     /**
  742.      * Indicate if the given Date corresponds to a Month End
  743.      * 
  744.      * @param iDate The Date
  745.      * 
  746.      * @return TRUE - Date Corresponds to EOM
  747.      * 
  748.      * @throws java.lang.Exception Thrown if input date is invalid
  749.      */

  751.     public static final boolean IsEOM (
  752.         final int iDate)
  753.         throws java.lang.Exception
  754.     {
  755.         return Date (iDate) == DaysInMonth (Month (iDate), Year (iDate)) ? true : false;
  756.     }

  758.     /**
  759.      * Create a JulianDate from the Year/Month/Date
  760.      *  
  761.      * @param iYear Year
  762.      * @param iMonth Month
  763.      * @param iDate Date
  764.      * 
  765.      * @return Julian Date corresponding to the specified Year/Month/Date
  766.      */

  768.     public static final org.drip.analytics.date.JulianDate CreateFromYMD (
  769.         final int iYear,
  770.         final int iMonth,
  771.         final int iDate)
  772.     {
  773.         try {
  774.             return new org.drip.analytics.date.JulianDate (ToJulian (iYear, iMonth, iDate));
  775.         } catch (java.lang.Exception e) {
  776.             e.printStackTrace();
  777.         }

  779.         return null;
  780.     }

  782.     /**
  783.      * Return a Julian Date corresponding to Today
  784.      *  
  785.      * @return JulianDate corresponding to Today
  786.      */

  788.     public static final org.drip.analytics.date.JulianDate Today()
  789.     {
  790.         java.util.Date dtNow = new java.util.Date();

  792.         try {
  793.             return CreateFromYMD (Year (dtNow), Month (dtNow), Day (dtNow));
  794.         } catch (java.lang.Exception e) {
  795.             e.printStackTrace();
  796.         }

  798.         return null;
  799.     }

  801.     /**
  802.      * Create a JulianDate from a String containing the Date in the DDMMMYYYY Format
  803.      * 
  804.      * @param strDate String containing the Date in the DDMMMYYYY Format
  805.      * 
  806.      * @return The JulianDate Instance
  807.      */

  809.     public static final JulianDate CreateFromDDMMMYYYY (
  810.         final java.lang.String strDate)
  811.     {
  812.         if (null == strDate || strDate.isEmpty()) return null;

  814.         java.lang.String[] astrParts = strDate.split ("-");

  816.         if (3 != astrParts.length) return null;

  818.         try {
  819.             return CreateFromYMD (java.lang.Integer.parseInt (astrParts[2]), MonthFromMonthChars (astrParts[1]),
  820.                 java.lang.Integer.parseInt (astrParts[0]));
  821.         } catch (java.lang.Exception e) {
  822.         }

  824.         return null;
  825.     }

  827.     /**
  828.      * Create a JulianDate from a String containing Date in the DDMMYYYY Format
  829.      * 
  830.      * @param strMDY String containing Date in the MM/DD/YYYY Format
  831.      * @param strDelim String Delimiter
  832.      * 
  833.      * @return The JulianDate Instance
  834.      */

  836.     public static final org.drip.analytics.date.JulianDate CreateFromMDY (
  837.         final java.lang.String strMDY,
  838.         final java.lang.String strDelim)
  839.     {
  840.         if (null == strMDY || strMDY.isEmpty() || null == strDelim || strDelim.isEmpty()) return null;

  842.         java.lang.String[] astrParts = strMDY.split (strDelim);

  844.         if (3 != astrParts.length) return null;

  846.         try {
  847.             return CreateFromYMD (java.lang.Integer.parseInt (astrParts[2]), java.lang.Integer.parseInt (astrParts[0]),
  848.                 java.lang.Integer.parseInt (astrParts[1]));
  849.         } catch (java.lang.Exception e) {
  850.         }

  852.         return null;
  853.     }

  855.     /**
  856.      * Create a JulianDate from a String containing Date in the YYYYMMDD Format
  857.      * 
  858.      * @param strYMD String containing Date in the YYYYMMDD Format
  859.      * @param strDelim String Delimiter
  860.      * 
  861.      * @return The JulianDate Instance
  862.      */

  864.     public static final org.drip.analytics.date.JulianDate CreateFromYMD (
  865.         final java.lang.String strYMD,
  866.         final java.lang.String strDelim)
  867.     {
  868.         if (null == strYMD || strYMD.isEmpty() || null == strDelim || strDelim.isEmpty()) return null;

  870.         java.lang.String[] astrParts = strYMD.split (strDelim);

  872.         if (3 != astrParts.length) return null;

  874.         try {
  875.             return CreateFromYMD (java.lang.Integer.parseInt (astrParts[0]), java.lang.Integer.parseInt (astrParts[1]),
  876.                 java.lang.Integer.parseInt (astrParts[2]));
  877.         } catch (java.lang.Exception e) {
  878.         }

  880.         return null;
  881.     }

  883.     /**
  884.      * Return the Day of the Week corresponding to the java.util.Date Instance
  885.      * 
  886.      * @param dt The java.util.Date Instance
  887.      * 
  888.      * @return The Day Of The Week
  889.      * 
  890.      * @throws java.lang.Exception Thrown if Input Date is invalid
  891.      */

  893.     public static final int DayOfTheWeek (
  894.         final java.util.Date dt)
  895.         throws java.lang.Exception
  896.     {
  897.         if (null == dt) throw new java.lang.Exception ("DateUtil::DayOfTheWeek => Invalid Date");

  899.         java.util.Calendar cal = java.util.Calendar.getInstance();

  901.         cal.setTime (dt);

  903.         return cal.get (java.util.Calendar.DAY_OF_WEEK);
  904.     }

  906.     /**
  907.      * Return the Day corresponding to the java.util.Date Instance
  908.      * 
  909.      * @param dt The java.util.Date Instance
  910.      * 
  911.      * @return The Day
  912.      * 
  913.      * @throws java.lang.Exception Thrown if Inputs are Invalid
  914.      */

  916.     public static final int Day (
  917.         final java.util.Date dt)
  918.         throws java.lang.Exception
  919.     {
  920.         if (null == dt) throw new java.lang.Exception ("DateUtil::Day => Invalid Date");

  922.         java.util.Calendar cal = java.util.Calendar.getInstance();

  924.         cal.setTime (dt);

  926.         return cal.get (java.util.Calendar.DATE);
  927.     }

  929.     /**
  930.      * Return the Month corresponding to the java.util.Date Instance. 1 is January, and 12 is December
  931.      * 
  932.      * @param dt The java.util.Date Instance
  933.      * 
  934.      * @return The Month
  935.      * 
  936.      * @throws java.lang.Exception Thrown if Inputs are Invalid
  937.      */

  939.     public static final int Month (
  940.         final java.util.Date dt)
  941.         throws java.lang.Exception
  942.     {
  943.         if (null == dt) throw new java.lang.Exception ("DateUtil::Month => Invalid Date");

  945.         java.util.Calendar cal = java.util.Calendar.getInstance();

  947.         cal.setTime (dt);

  949.         return cal.get (java.util.Calendar.MONTH) + 1;
  950.     }

  952.     /**
  953.      * Return the Year corresponding to the java.util.Date Instance
  954.      * 
  955.      * @param dt The java.util.Date Instance
  956.      * 
  957.      * @return The Year
  958.      * 
  959.      * @throws java.lang.Exception Thrown if Inputs are Invalid
  960.      */

  962.     public static final int Year (
  963.         final java.util.Date dt)
  964.         throws java.lang.Exception
  965.     {
  966.         if (null == dt) throw new java.lang.Exception ("DateUtil::Year => Invalid Date");

  968.         java.util.Calendar cal = java.util.Calendar.getInstance();

  970.         cal.setTime (dt);

  972.         return cal.get (java.util.Calendar.YEAR);
  973.     }

  975.     /**
  976.      * Create an Oracle Date Trigram from a YYYYMMDD String
  977.      * 
  978.      * @param strYYYYMMDD Date String in the YYYYMMDD Format.
  979.      * 
  980.      * @return Oracle Date Trigram String
  981.      */

  983.     public static java.lang.String MakeOracleDateFromYYYYMMDD (
  984.         final java.lang.String strYYYYMMDD)
  985.     {
  986.         if (null == strYYYYMMDD || strYYYYMMDD.isEmpty()) return null;

  988.         try {
  989.             return strYYYYMMDD.substring (6) + "-" + MonthTrigram ((java.lang.Integer.parseInt
  990.                 (strYYYYMMDD.substring (4, 6)))) + "-" + strYYYYMMDD.substring (0, 4);
  991.         } catch (java.lang.Exception e) {
  992.             e.printStackTrace();
  993.         }

  995.         return null;
  996.     }

  998.     /**
  999.      * Create an Oracle date trigram from a Bloomberg date string
  1000.      * 
  1001.      * @param strBBGDate Bloomberg date string
  1002.      * 
  1003.      * @return Oracle date trigram string
  1004.      */

  1006.     public static java.lang.String MakeOracleDateFromBBGDate (
  1007.         final java.lang.String strBBGDate)
  1008.     {
  1009.         if (null == strBBGDate || strBBGDate.isEmpty()) return null;

  1011.         java.util.StringTokenizer st = new java.util.StringTokenizer (strBBGDate, "/");

  1013.         try {
  1014.             java.lang.String strMonth = MonthTrigram (java.lang.Integer.parseInt (st.nextToken()));

  1016.             if (null == strMonth) return null;

  1018.             return st.nextToken() + "-" + strMonth + "-" + st.nextToken();
  1019.         } catch (java.lang.Exception e) {
  1020.             e.printStackTrace();
  1021.         }

  1023.         return null;
  1024.     }

  1026.     /**
  1027.      * Create a JulianDate from the java Date
  1028.      * 
  1029.      * @param dt Java Date input
  1030.      * 
  1031.      * @return JulianDate output
  1032.      */

  1034.     public static final org.drip.analytics.date.JulianDate MakeJulianFromRSEntry (
  1035.         final java.util.Date dt)
  1036.     {
  1037.         if (null == dt) return null;

  1039.         try {
  1040.             return CreateFromYMD (Year (dt), Month (dt), Day (dt));
  1041.         } catch (java.lang.Exception e) {
  1042.             e.printStackTrace();
  1043.         }

  1045.         return null;
  1046.     }

  1048.     /**
  1049.      * Retrieve a Java Date Instance from the Julian Date Instance
  1050.      * 
  1051.      * @param dt Julian Date Instance
  1052.      * 
  1053.      * @return The Java Date Instance
  1054.      */

  1056.     public static final java.util.Date JavaDateFromJulianDate (
  1057.         final org.drip.analytics.date.JulianDate dt)
  1058.     {
  1059.         if (null == dt) return null;

  1061.         java.util.Calendar cal = java.util.Calendar.getInstance();

  1063.         int iDate = dt.julian();

  1065.         try {
  1066.             cal.set (Year (iDate), Month (iDate) - 1, Date (iDate));
  1067.         } catch (java.lang.Exception e) {
  1068.             e.printStackTrace();

  1070.             return null;
  1071.         }

  1073.         return cal.getTime();
  1074.     }

  1076.     /**
  1077.      * Create a JulianDate from the DD MMM YY
  1078.      * 
  1079.      * @param strDDMMMYY Java Date input as delimited DD MMM YY
  1080.      * @param strDelim Delimiter
  1081.      * 
  1082.      * @return JulianDate output
  1083.      */

  1085.     public static final org.drip.analytics.date.JulianDate MakeJulianFromDDMMMYY (
  1086.         final java.lang.String strDDMMMYY,
  1087.         final java.lang.String strDelim)
  1088.     {
  1089.         if (null == strDDMMMYY || strDDMMMYY.isEmpty() || null == strDelim || strDelim.isEmpty())
  1090.             return null;

  1092.         java.lang.String[] astrDMY = strDDMMMYY.split (strDelim);

  1094.         if (null == astrDMY || 3 != astrDMY.length) return null;

  1096.         try {
  1097.             return CreateFromYMD (2000 + java.lang.Integer.parseInt (astrDMY[2].trim()), MonthFromMonthChars
  1098.                 (astrDMY[1].trim()), java.lang.Integer.parseInt (astrDMY[0].trim()));
  1099.         } catch (java.lang.Exception e) {
  1100.             e.printStackTrace();
  1101.         }

  1103.         return null;
  1104.     }

  1106.     /**
  1107.      * Create a JulianDate from the YYYY MM DD
  1108.      * 
  1109.      * @param strYYYYMMDD Java Date input as delimited YYYY MM DD
  1110.      * @param strDelim Delimiter
  1111.      * 
  1112.      * @return JulianDate output
  1113.      */

  1115.     public static final org.drip.analytics.date.JulianDate MakeJulianFromYYYYMMDD (
  1116.         final java.lang.String strYYYYMMDD,
  1117.         final java.lang.String strDelim)
  1118.     {
  1119.         if (null == strYYYYMMDD || strYYYYMMDD.isEmpty() || null == strDelim || strDelim.isEmpty())
  1120.             return null;

  1122.         java.lang.String[] astrYYYYMMDD = strYYYYMMDD.split (strDelim);

  1124.         if (null == astrYYYYMMDD || 3 != astrYYYYMMDD.length) return null;

  1126.         try {
  1127.             return CreateFromYMD (java.lang.Integer.parseInt (astrYYYYMMDD[0].trim()), java.lang.Integer.parseInt
  1128.                 (astrYYYYMMDD[1].trim()), java.lang.Integer.parseInt (astrYYYYMMDD[2].trim()));
  1129.         } catch (java.lang.Exception e) {
  1130.             e.printStackTrace();
  1131.         }

  1133.         return null;
  1134.     }

  1136.     /**
  1137.      * Create a JulianDate from the MDY
  1138.      * 
  1139.      * @param strMDY Java Date input as delimited M/D/Y
  1140.      * @param strDelim Delimiter
  1141.      * 
  1142.      * @return JulianDate output
  1143.      */

  1145.     public static final org.drip.analytics.date.JulianDate FromMDY (
  1146.         final java.lang.String strMDY,
  1147.         final java.lang.String strDelim)
  1148.     {
  1149.         if (null == strMDY || strMDY.isEmpty() || null == strDelim || strDelim.isEmpty())
  1150.             return null;

  1152.         java.lang.String[] astrDMY = strMDY.split (strDelim);

  1154.         if (null == astrDMY || 3 != astrDMY.length) return null;

  1156.         try {
  1157.             return CreateFromYMD (java.lang.Integer.parseInt (astrDMY[2].trim()), java.lang.Integer.parseInt
  1158.                 (astrDMY[0].trim()), java.lang.Integer.parseInt (astrDMY[1].trim()));
  1159.         } catch (java.lang.Exception e) {
  1160.             e.printStackTrace();
  1161.         }

  1163.         return null;
  1164.     }

  1166.     /**
  1167.      * Create a JulianDate from Bloomberg date string
  1168.      * 
  1169.      * @param strBBGDate Bloomberg date string
  1170.      * 
  1171.      * @return The new JulianDate
  1172.      */

  1174.     public static final org.drip.analytics.date.JulianDate MakeJulianDateFromBBGDate (
  1175.         final java.lang.String strBBGDate)
  1176.     {
  1177.         if (null == strBBGDate || strBBGDate.isEmpty()) return null;

  1179.         java.lang.String[] astrFields = strBBGDate.split ("/");

  1181.         if (3 != astrFields.length) return null;

  1183.         try {
  1184.             return CreateFromYMD (
  1185.                 (int) java.lang.Double.parseDouble (astrFields[2].trim()),
  1186.                 (int) java.lang.Double.parseDouble (astrFields[0].trim()),
  1187.                 (int) java.lang.Double.parseDouble (astrFields[1].trim())
  1188.             );
  1189.         } catch (java.lang.Exception e) {
  1190.             e.printStackTrace();
  1191.         }

  1193.         return null;
  1194.     }

  1196.     /**
  1197.      * Retrieve the Month corresponding to the Month Digit Code
  1198.      * 
  1199.      * @param ch The Month Digit Code
  1200.      * 
  1201.      * @return The Month corresponding to the Month Digit Code
  1202.      * 
  1203.      * @throws java.lang.Exception Thrown if the Digit Code is Invalid
  1204.      */

  1206.     public static final int MonthFromCode (
  1207.         final char ch)
  1208.         throws java.lang.Exception
  1209.     {
  1210.         if ('F' == ch) return JANUARY;

  1212.         if ('G' == ch) return FEBRUARY;

  1214.         if ('H' == ch) return MARCH;

  1216.         if ('J' == ch) return APRIL;

  1218.         if ('K' == ch) return MAY;

  1220.         if ('M' == ch) return JUNE;

  1222.         if ('N' == ch) return JULY;

  1224.         if ('Q' == ch) return AUGUST;

  1226.         if ('U' == ch) return SEPTEMBER;

  1228.         if ('V' == ch) return OCTOBER;

  1230.         if ('X' == ch) return NOVEMBER;

  1232.         if ('Z' == ch) return DECEMBER;

  1234.         throw new java.lang.Exception ("DateUtil::MonthFromCode => Invalid Character: " + ch);
  1235.     }

  1237.     /**
  1238.      * Retrieve the Digit Code corresponding to the Month
  1239.      * 
  1240.      * @param iMonth The Month
  1241.      * 
  1242.      * @return The Digit Code corresponding to the Month
  1243.      * 
  1244.      * @throws java.lang.Exception Thrown if the Digit Code cannot be computed
  1245.      */

  1247.     public static final char CodeFromMonth (
  1248.         final int iMonth)
  1249.         throws java.lang.Exception
  1250.     {
  1251.         if (JANUARY == iMonth) return 'F';

  1253.         if (FEBRUARY == iMonth) return 'G';

  1255.         if (MARCH == iMonth) return 'H';

  1257.         if (APRIL == iMonth) return 'J';

  1259.         if (MAY == iMonth) return 'K';

  1261.         if (JUNE == iMonth) return 'M';

  1263.         if (JULY == iMonth) return 'N';

  1265.         if (AUGUST == iMonth) return 'Q';

  1267.         if (SEPTEMBER == iMonth) return 'U';

  1269.         if (OCTOBER == iMonth) return 'V';

  1271.         if (NOVEMBER == iMonth) return 'X';

  1273.         if (DECEMBER == iMonth) return 'Z';

  1275.         throw new java.lang.Exception ("DateUtil::CodeFromMonth => Invalid Month: " + iMonth);
  1276.     }
  1277. }
Created with JaCoCo 0.7.9.201702052155