Topography.java

  1. package org.drip.spaces.graph;

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

  78. /**
  79.  * <i>Topography</i> holds Vertexes and the Edges between them. The References are:
  80.  *
  81.  * <br><br>
  82.  *  <ul>
  83.  *      <li>
  84.  *          Wikipedia (2018a): Graph (Abstract Data Type)
  85.  *              https://en.wikipedia.org/wiki/Graph_(abstract_data_type)
  86.  *      </li>
  87.  *      <li>
  88.  *          Wikipedia (2018b): Graph Theory https://en.wikipedia.org/wiki/Graph_theory
  89.  *      </li>
  90.  *      <li>
  91.  *          Wikipedia (2018c): Graph (Discrete Mathematics)
  92.  *              https://en.wikipedia.org/wiki/Graph_(discrete_mathematics)
  93.  *      </li>
  94.  *      <li>
  95.  *          Wikipedia (2018d): Dijkstra's Algorithm https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
  96.  *      </li>
  97.  *      <li>
  98.  *          Wikipedia (2018e): Bellman-Ford Algorithm
  99.  *              https://en.wikipedia.org/wiki/Bellman%E2%80%93Ford_algorithm
  100.  *      </li>
  101.  *  </ul>
  102.  *
  103.  * <br><br>
  104.  *  <ul>
  105.  *      <li><b>Module </b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/ComputationalCore.md">Computational Core Module</a></li>
  106.  *      <li><b>Library</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/StatisticalLearningLibrary.md">Statistical Learning Library</a></li>
  107.  *      <li><b>Project</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/README.md">R<sup>1</sup> and R<sup>d</sup> Vector/Tensor Spaces (Validated and/or Normed), and Function Classes</a></li>
  108.  *      <li><b>Package</b> = <a href = "https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/spaces/graph/README.md">Graph Representation and Traversal Algorithms</a></li>
  109.  *  </ul>
  110.  * <br><br>
  111.  *
  112.  * @author Lakshmi Krishnamurthy
  113.  */

  115. public class Topography
  116. {
  117.     private org.drip.spaces.graph.TopographyEdgeMap _topographyEdgeMap = new
  118.         org.drip.spaces.graph.TopographyEdgeMap();

  120.     private java.util.Map<java.lang.String, org.drip.spaces.graph.Vertex> _vertexMap = new
  121.         org.drip.analytics.support.CaseInsensitiveHashMap<org.drip.spaces.graph.Vertex>();

  123.     /**
  124.      * Empty Topography Constructor
  125.      */

  127.     public Topography()
  128.     {
  129.     }

  131.     /**
  132.      * Retrieve The Vertex Name Set
  133.      * 
  134.      * @return The Vertex Name Set
  135.      */

  137.     public java.util.Set<java.lang.String> vertexNameSet()
  138.     {
  139.         return _vertexMap.keySet();
  140.     }

  142.     /**
  143.      * Add The Vertex
  144.      * 
  145.      * @param vertexName Name of the Vertex
  146.      * 
  147.      * @return TRUE - The Vertex successfully added
  148.      */

  150.     public boolean addVertex (
  151.         final java.lang.String vertexName)
  152.     {
  153.         if (null == vertexName || vertexName.isEmpty())
  154.         {
  155.             return false;
  156.         }

  158.         try
  159.         {
  160.             _vertexMap.put (
  161.                 vertexName,
  162.                 new org.drip.spaces.graph.Vertex (vertexName)
  163.             );
  164.         }
  165.         catch (java.lang.Exception e)
  166.         {
  167.             e.printStackTrace();
  168.         }

  170.         return false;
  171.     }

  173.     /**
  174.      * Verify if the Vertex is available
  175.      * 
  176.      * @param vertexName Name of the Vertex
  177.      * 
  178.      * @return TRUE - The Vertex is available
  179.      */

  181.     public boolean vertexExists (
  182.         final java.lang.String vertexName)
  183.     {
  184.         return null != vertexName && _vertexMap.containsKey (vertexName);
  185.     }

  187.     /**
  188.      * Retrieve the Named Vertex
  189.      * 
  190.      * @param vertexName Name of the Vertex
  191.      * 
  192.      * @return The Vertex
  193.      */

  195.     public org.drip.spaces.graph.Vertex vertex (
  196.         final java.lang.String vertexName)
  197.     {
  198.         return vertexExists (vertexName) ? _vertexMap.get (vertexName) : null;
  199.     }

  201.     /**
  202.      * Add an Edge
  203.      * 
  204.      * @param edge The Edge to be added
  205.      * 
  206.      * @return TRUE - The Edge successfully added
  207.      */

  209.     public boolean addEdge (
  210.         final org.drip.spaces.graph.Edge edge)
  211.     {
  212.         if (null == edge || !_topographyEdgeMap.addEdge (edge))
  213.         {
  214.             return false;
  215.         }

  217.         double weight = edge.weight();

  219.         java.lang.String source = edge.source();

  221.         java.lang.String destination = edge.destination();

  223.         org.drip.spaces.graph.Vertex sourceVertex = vertex (source);

  225.         org.drip.spaces.graph.Vertex destinationVertex = vertex (destination);

  227.         return null != sourceVertex && null != destinationVertex && sourceVertex.addEgress (
  228.             destination,
  229.             weight
  230.         ) && destinationVertex.addEgress (
  231.             source,
  232.             weight
  233.         );
  234.     }

  236.     /**
  237.      * Retrieve the Map of Vertex
  238.      * 
  239.      * @return The Map of Vertex
  240.      */

  242.     public java.util.Map<java.lang.String, org.drip.spaces.graph.Vertex> vertexMap()
  243.     {
  244.         return _vertexMap;
  245.     }

  247.     /**
  248.      * Retrieve the Topography Edge Map
  249.      * 
  250.      * @return The Topography Edge Map
  251.      */

  253.     public org.drip.spaces.graph.TopographyEdgeMap topographyEdgeMap()
  254.     {
  255.         return _topographyEdgeMap;
  256.     }

  258.     /**
  259.      * Indicate if the Pair of Vertexes are Adjacent
  260.      * 
  261.      * @param source The Source Vertex
  262.      * @param destination The Destination Vertex
  263.      * 
  264.      * @return TRUE - The Pair of Vertexes are Adjacent
  265.      */

  267.     public boolean adjacent (
  268.         final java.lang.String source,
  269.         final java.lang.String destination)
  270.     {
  271.         org.drip.spaces.graph.Vertex sourceVertex = vertex (source);

  273.         org.drip.spaces.graph.Vertex destinationVertex = vertex (destination);

  275.         if (null == sourceVertex || null == destinationVertex)
  276.         {
  277.             return false;
  278.         }

  280.         return sourceVertex.egressMap().containsKey (destination);
  281.     }

  283.     /**
  284.      * Compute the Weight between Source and Destination if Adjacent
  285.      * 
  286.      * @param source The Source Vertex
  287.      * @param destination The Destination Vertex
  288.      * 
  289.      * @return The Weight between Source and Destination if Adjacent
  290.      * 
  291.      * @throws java.lang.Exception Thrown if the Source and the Destination are not Adjacent
  292.      */

  294.     public double adjacentWeight (
  295.         final java.lang.String source,
  296.         final java.lang.String destination)
  297.         throws java.lang.Exception
  298.     {
  299.         if (!adjacent (
  300.             source,
  301.             destination
  302.         ))
  303.         {
  304.             throw new java.lang.Exception ("Topography::adjacentDistance => Invalid Adjacency Check");
  305.         }

  307.         return vertex (source).egressMap().get (destination);
  308.     }

  310.     /**
  311.      * Generate the Connection Map between valid Pairs of Source and Destination
  312.      * 
  313.      * @return The Connection Map
  314.      */

  316.     public java.util.Map<java.lang.String, java.lang.Double> connectionMap()
  317.     {
  318.         java.util.Set<java.lang.String> vertexNameSet = _vertexMap.keySet();

  320.         java.util.Map<java.lang.String, java.lang.Double> connectionMap = new
  321.             org.drip.analytics.support.CaseInsensitiveHashMap<java.lang.Double>();

  323.         for (String source : vertexNameSet)
  324.         {
  325.             for (String destination : vertexNameSet)
  326.             {
  327.                 try
  328.                 {
  329.                     if (adjacent (
  330.                         source,
  331.                         destination
  332.                     ))
  333.                     {
  334.                         double adjacentWeight = adjacent (
  335.                             source,
  336.                             destination
  337.                         ) ? adjacentWeight (
  338.                             source,
  339.                             destination
  340.                         ) : 0.;

  342.                         connectionMap.put (
  343.                             source + "_" + destination,
  344.                             adjacentWeight
  345.                         );

  347.                         connectionMap.put (
  348.                             destination + "_" + source,
  349.                             adjacentWeight
  350.                         );
  351.                     }
  352.                 }
  353.                 catch (java.lang.Exception e)
  354.                 {
  355.                     e.printStackTrace();
  356.                 }
  357.             }
  358.         }

  360.         return connectionMap;
  361.     }
  362. }
Created with JaCoCo 0.7.9.201702052155