CSVGrid.java

  1. package org.drip.feed.loader;

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

  81. /**
  82.  * <i>CSVGrid</i> Holds the Outputs of a CSV Parsing Exercise.
  83.  *
  84.  *  <br><br>
  85.  *  <ul>
  86.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  87.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationSupportLibrary.md">Computation Support</a></li>
  88.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/feed/README.md">Load, Transform, and compute Target Metrics across Feeds</a></li>
  89.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/feed/loader/README.md">Reference/Market Data Feed Loader</a></li>
  90.  *  </ul>
  91.  * 
  92.  * @author Lakshmi Krishnamurthy
  93.  */

  95. public class CSVGrid {
  96.     private java.lang.String[] _astrHeader = null;
  97.     private java.util.List<java.lang.String[]> _lsastr = null;

  99.     /**
  100.      * Convert the String Element to double. Fall back is NaN.
  101.      * 
  102.      * @param strElement String Element
  103.      * 
  104.      * @return The Return Value
  105.      */

  107.     public static final double ToDouble (
  108.         final java.lang.String strElement)
  109.     {
  110.         if (null == strElement || strElement.trim().isEmpty()) return java.lang.Double.NaN;

  112.         try {
  113.             return java.lang.Double.parseDouble (strElement);
  114.         } catch (java.lang.Exception e) {
  115.             e.printStackTrace();
  116.         }

  118.         return java.lang.Double.NaN;
  119.     }

  121.     /**
  122.      * Convert the String Element to int. Fall back is MIN_VALUE.
  123.      * 
  124.      * @param strElement String Element
  125.      * 
  126.      * @return The Return Value
  127.      */

  129.     public static final int ToInteger (
  130.         final java.lang.String strElement)
  131.     {
  132.         if (null == strElement || strElement.trim().isEmpty()) return java.lang.Integer.MIN_VALUE;

  134.         try {
  135.             return java.lang.Integer.parseInt (strElement);
  136.         } catch (java.lang.Exception e) {
  137.             e.printStackTrace();
  138.         }

  140.         return java.lang.Integer.MIN_VALUE;
  141.     }

  143.     /**
  144.      * Convert the String Element to a JulianDate Instance.
  145.      * 
  146.      * @param strElement String Element
  147.      * 
  148.      * @return The Return Value
  149.      */

  151.     public static final org.drip.analytics.date.JulianDate ToDate (
  152.         final java.lang.String strElement)
  153.     {
  154.         org.drip.analytics.date.JulianDate dt = org.drip.analytics.date.DateUtil.CreateFromDDMMMYYYY
  155.             (strElement.trim());

  157.         if (null != dt || null != (dt = org.drip.analytics.date.DateUtil.MakeJulianFromDDMMMYY (strElement,
  158.             "-")))
  159.             return dt;

  161.         return org.drip.analytics.date.DateUtil.CreateFromMDY (strElement, "-");
  162.     }

  164.     /**
  165.      * Empty CSVGrid Constructor
  166.      */

  168.     public CSVGrid()
  169.     {
  170.     }

  172.     /**
  173.      * Retrieve the Underlying CSV Grid
  174.      * 
  175.      * @return The Underlying CSV Field Grid
  176.      */

  178.     public java.util.List<java.lang.String[]> grid()
  179.     {
  180.         return _lsastr;
  181.     }

  183.     /**
  184.      * Retrieve the Size of the Sample Set
  185.      * 
  186.      * @return Size of the Sample Set
  187.      */

  189.     public int size()
  190.     {
  191.         return null == _lsastr ? 0 : _lsastr.size();
  192.     }

  194.     /**
  195.      * Set the Column Headers
  196.      * 
  197.      * @param astrHeader The Column Headers
  198.      * 
  199.      * @return TRUE - Column Headers successfully set
  200.      */

  202.     public boolean setHeader (
  203.         final java.lang.String[] astrHeader)
  204.     {
  205.         if (null == astrHeader || 0 == astrHeader.length) return false;

  207.         _astrHeader = astrHeader;
  208.         return true;
  209.     }

  211.     /**
  212.      * Add a String Array to the Grid
  213.      * 
  214.      * @param astr The String Array
  215.      * 
  216.      * @return TRUE - The String Array successfully added
  217.      */

  219.     public boolean add (
  220.         final java.lang.String[] astr)
  221.     {
  222.         if (null == astr || 0 == astr.length) return false;

  224.         if (null == _lsastr) _lsastr = new java.util.ArrayList<java.lang.String[]>();

  226.         _lsastr.add (astr);

  228.         return true;
  229.     }

  231.     /**
  232.      * Retrieve the Array of Headers
  233.      * 
  234.      * @return The Header Array
  235.      */

  237.     public java.lang.String[] headers()
  238.     {
  239.         return _astrHeader;
  240.     }

  242.     /**
  243.      * Retrieve the Header identified by the Index
  244.      * 
  245.      * @param iIndex The Index
  246.      * 
  247.      * @return The Header identified by the Index
  248.      */

  250.     public java.lang.String header (
  251.         final int iIndex)
  252.     {
  253.         return null == _astrHeader || _astrHeader.length <= iIndex ? null : _astrHeader[iIndex];
  254.     }

  256.     /**
  257.      * 
  258.      * Retrieve the Array of String Values corresponding to the specified Column Index
  259.      * 
  260.      * @param iColumn The Column Index
  261.      * 
  262.      * @return The Array of Strings
  263.      */

  265.     public java.lang.String[] stringArrayAtColumn (
  266.         final int iColumn)
  267.     {
  268.         if (0 > iColumn) return null;

  270.         int iRow = 0;

  272.         java.lang.String[] astrColumn = new java.lang.String[_lsastr.size()];

  274.         for (java.lang.String[] astr : _lsastr) {
  275.             if (null == astr || astr.length <= iColumn) return null;

  277.             astrColumn[iRow++] = astr[iColumn];
  278.         }

  280.         return astrColumn;
  281.     }

  283.     /**
  284.      * Retrieve the Array of Integer Values corresponding to the specified Column Index
  285.      * 
  286.      * @param iColumn The Column Index
  287.      * 
  288.      * @return The Array of Integers
  289.      */

  291.     public int[] intArrayAtColumn (
  292.         final int iColumn)
  293.     {
  294.         if (0 > iColumn) return null;

  296.         int iRow = 0;

  298.         int[] ai = new int[_lsastr.size()];

  300.         for (java.lang.String[] astr : _lsastr) {
  301.             if (null == astr || astr.length <= iColumn) return null;

  303.             ai[iRow++] = ToInteger (astr[iColumn]);
  304.         }

  306.         return ai;
  307.     }

  309.     /**
  310.      * Retrieve the Array of Double Values corresponding to the specified Column Index
  311.      * 
  312.      * @param iColumn The Column Index
  313.      * @param dblScaler The Scaling Multiplier
  314.      * 
  315.      * @return The Array of Doubles
  316.      */

  318.     public double[] doubleArrayAtColumn (
  319.         final int iColumn,
  320.         final double dblScaler)
  321.     {
  322.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblScaler) || 0 > iColumn) return null;

  324.         int iRow = 0;

  326.         double[] adbl = new double[_lsastr.size()];

  328.         for (java.lang.String[] astr : _lsastr) {
  329.             if (null == astr || astr.length <= iColumn) return null;

  331.             adbl[iRow++] = dblScaler * ToDouble (astr[iColumn]);
  332.         }

  334.         return adbl;
  335.     }

  337.     /**
  338.      * Retrieve the Array of Double Values corresponding to the specified Column Index
  339.      * 
  340.      * @param iColumn The Column Index
  341.      * 
  342.      * @return The Array of Doubles
  343.      */

  345.     public double[] doubleArrayAtColumn (
  346.         final int iColumn)
  347.     {
  348.         return doubleArrayAtColumn (iColumn, 1.);
  349.     }

  351.     /**
  352.      * Retrieve the Array of JulianDate corresponding to the specified Column Index
  353.      * 
  354.      * @param iColumn The Column Index
  355.      * 
  356.      * @return The Array of JulianDate
  357.      */

  359.     public org.drip.analytics.date.JulianDate[] dateArrayAtColumn (
  360.         final int iColumn)
  361.     {
  362.         if (0 > iColumn) return null;

  364.         int iRow = 0;

  366.         org.drip.analytics.date.JulianDate[] adt = new org.drip.analytics.date.JulianDate[_lsastr.size()];

  368.         for (java.lang.String[] astr : _lsastr) {
  369.             if (null == astr || astr.length <= iColumn) return null;

  371.             adt[iRow++] = ToDate (astr[iColumn]);
  372.         }

  374.         return adt;
  375.     }

  377.     /**
  378.      * Construct a Historical Map of Scaled/Keyed Double
  379.      * 
  380.      * @param dblScaler The Scale to be applied
  381.      * 
  382.      * @return Historical Map of Scaled/Keyed Double
  383.      */

  385.     public java.util.Map<org.drip.analytics.date.JulianDate, java.util.Map<java.lang.Double,
  386.         java.lang.Double>>
  387.             doubleMap (
  388.                 final double dblScaler)
  389.     {
  390.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblScaler) || null == _lsastr) return null;

  392.         int iNumClose = _lsastr.size();

  394.         if (0 == iNumClose) return null;

  396.         java.lang.String[] astrHeader = _lsastr.get (0);

  398.         int iNumMark = astrHeader.length;
  399.         double adblHeader[] = new double[iNumMark];

  401.         for (int i = 1; i < iNumMark; ++i) {
  402.             if (null == astrHeader[i] || astrHeader[i].isEmpty()) return null;

  404.             double dblHeader = java.lang.Double.NaN;

  406.             java.lang.String strHeader = astrHeader[i].trim();

  408.             if (null == strHeader || strHeader.isEmpty()) return null;

  410.             try {
  411.                 dblHeader = java.lang.Double.parseDouble (strHeader);
  412.             } catch (java.lang.Exception e) {
  413.                 e.printStackTrace();

  415.                 return null;
  416.             }

  418.             if (!org.drip.numerical.common.NumberUtil.IsValid (dblHeader)) return null;

  420.             adblHeader[i] = dblHeader;;
  421.         }

  423.         java.util.Map<org.drip.analytics.date.JulianDate, java.util.Map<java.lang.Double, java.lang.Double>>
  424.             mapClose = new java.util.TreeMap<org.drip.analytics.date.JulianDate,
  425.                 java.util.Map<java.lang.Double, java.lang.Double>>();

  427.         for (int i = 1; i < iNumClose; ++i) {
  428.             java.util.Map<java.lang.Double, java.lang.Double> mapClosingMark = new
  429.                 java.util.TreeMap<java.lang.Double, java.lang.Double>();

  431.             java.lang.String[] astrClosingMark = _lsastr.get (i);

  433.             for (int j = 1; j < iNumMark; ++j) {
  434.                 double dblClosingMark = java.lang.Double.NaN;

  436.                 java.lang.String strClosingMark = null == astrClosingMark[j] || astrClosingMark[j].isEmpty()
  437.                     ? null : astrClosingMark[j].trim();

  439.                 try {
  440.                     if (null != strClosingMark && !strClosingMark.isEmpty())
  441.                         dblClosingMark = java.lang.Double.parseDouble (strClosingMark);
  442.                 } catch (java.lang.Exception e) {
  443.                 }

  445.                 if (org.drip.numerical.common.NumberUtil.IsValid (dblClosingMark))
  446.                     mapClosingMark.put (adblHeader[j], dblScaler * dblClosingMark);
  447.             }

  449.             if (0 != mapClosingMark.size())
  450.                 mapClose.put (org.drip.analytics.date.DateUtil.CreateFromDDMMMYYYY (astrClosingMark[0]),
  451.                     mapClosingMark);
  452.         }

  454.         return mapClose;
  455.     }

  457.     /**
  458.      * Construct a Historical Map of Scaled/Keyed/Tenor Ordered Double
  459.      * 
  460.      * @param dblScaler The Scale to be applied
  461.      * 
  462.      * @return Historical Map of Scaled/Keyed/Tenor Ordered Double
  463.      */

  465.     public java.util.Map<org.drip.analytics.date.JulianDate, org.drip.feed.loader.InstrumentSetTenorQuote>
  466.         groupedOrderedDouble (
  467.             final double dblScaler)
  468.     {
  469.         if (!org.drip.numerical.common.NumberUtil.IsValid (dblScaler) || null == _lsastr) return null;

  471.         int iNumClose = _lsastr.size();

  473.         if (0 == iNumClose) return null;

  475.         java.lang.String[] astrHeader = _lsastr.get (0);

  477.         int iNumMark = astrHeader.length;
  478.         java.lang.String[] astrTenor = new java.lang.String[iNumMark - 1];
  479.         java.lang.String[] astrInstrument = new java.lang.String[iNumMark - 1];

  481.         for (int i = 1; i < iNumMark; ++i) {
  482.             astrHeader[i].trim();

  484.             if (null == astrHeader[i] || astrHeader[i].isEmpty()) astrHeader[i] = "@:#";

  486.             java.lang.String[] astrInstrumentTenor = org.drip.numerical.common.StringUtil.Split
  487.                 (astrHeader[i].trim(), ":");

  489.             if (null == astrInstrumentTenor || 2 != astrInstrumentTenor.length) return null;

  491.             astrTenor[i - 1] = astrInstrumentTenor[1];
  492.             astrInstrument[i - 1] = astrInstrumentTenor[0];
  493.         }

  495.         java.util.Map<org.drip.analytics.date.JulianDate, org.drip.feed.loader.InstrumentSetTenorQuote>
  496.             mapISTQ = new java.util.TreeMap<org.drip.analytics.date.JulianDate,
  497.                 org.drip.feed.loader.InstrumentSetTenorQuote>();

  499.         for (int i = 1; i < iNumClose; ++i) {
  500.             java.lang.String[] astrClosingMark = _lsastr.get (i);

  502.             org.drip.feed.loader.InstrumentSetTenorQuote istq = new
  503.                 org.drip.feed.loader.InstrumentSetTenorQuote();

  505.             for (int j = 1; j < iNumMark; ++j) {
  506.                 double dblClosingMark = java.lang.Double.NaN;

  508.                 java.lang.String strClosingMark = null == astrClosingMark[j] || astrClosingMark[j].isEmpty()
  509.                     ? null : astrClosingMark[j].trim();

  511.                 try {
  512.                     if (null != strClosingMark && !strClosingMark.isEmpty())
  513.                         dblClosingMark = java.lang.Double.parseDouble (strClosingMark);
  514.                 } catch (java.lang.Exception e) {
  515.                 }

  517.                 istq.add (astrInstrument[j - 1], astrTenor[j - 1], dblClosingMark, dblScaler);
  518.             }

  520.             if (!istq.isEmpty())
  521.                 mapISTQ.put (org.drip.analytics.date.DateUtil.CreateFromDDMMMYYYY (astrClosingMark[0]),
  522.                     istq);
  523.         }

  525.         return mapISTQ;
  526.     }
  527. }
Created with JaCoCo 0.7.9.201702052155