Mercurial > repos > deepakjadmin > mayatool3_test3
diff mayachemtools/docs/modules/txt/Graph.txt @ 0:73ae111cf86f draft
Uploaded
author | deepakjadmin |
---|---|
date | Wed, 20 Jan 2016 11:55:01 -0500 |
parents | |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mayachemtools/docs/modules/txt/Graph.txt Wed Jan 20 11:55:01 2016 -0500 @@ -0,0 +1,1266 @@ +NAME + Graph + +SYNOPSIS + use Graph; + + use Graph qw(:all); + +DESCRIPTION + Graph class provides the following methods: + + new, AddCycle, AddEdge, AddEdges, AddPath, AddVertex, AddVertices, + ClearCycles, Copy, CopyEdgesProperties, CopyVerticesAndEdges, + CopyVerticesProperties, DeleteCycle, DeleteEdge, DeleteEdgeProperties, + DeleteEdgeProperty, DeleteEdges, DeleteEdgesProperties, + DeleteEdgesProperty, DeleteGraphProperties, DeleteGraphProperty, + DeletePath, DeleteVertex, DeleteVertexProperties, DeleteVertexProperty, + DeleteVertices, DeleteVerticesProperty, DetectCycles, + GetAdjacencyMatrix, GetAdmittanceMatrix, GetAllPaths, + GetAllPathsStartingAt, GetAllPathsStartingAtWithLength, + GetAllPathsStartingAtWithLengthUpto, GetAllPathsWithLength, + GetAllPathsWithLengthUpto, GetCircumference, + GetConnectedComponentsVertices, GetCycles, GetCyclesWithEvenSize, + GetCyclesWithOddSize, GetCyclesWithSize, GetCyclesWithSizeGreaterThan, + GetCyclesWithSizeLessThan, GetDegree, GetDegreeMatrix, + GetDistanceMatrix, GetEdgeCycles, GetEdgeCyclesWithEvenSize, + GetEdgeCyclesWithOddSize, GetEdgeCyclesWithSize, + GetEdgeCyclesWithSizeGreaterThan, GetEdgeCyclesWithSizeLessThan, + GetEdgeProperties, GetEdgeProperty, GetEdges, GetEdgesProperty, + GetFusedAndNonFusedCycles, GetGirth, GetGraphProperties, + GetGraphProperty, GetIncidenceMatrix, GetIsolatedVertices, + GetKirchhoffMatrix, GetLaplacianMatrix, GetLargestCycle, + GetLargestEdgeCycle, GetLargestVertexCycle, GetLeafVertices, + GetMaximumDegree, GetMininumDegree, GetNeighborhoodVertices, + GetNeighborhoodVerticesWithRadiusUpto, + GetNeighborhoodVerticesWithSuccessors, + GetNeighborhoodVerticesWithSuccessorsAndRadiusUpto, GetNeighbors, + GetNormalizedLaplacianMatrix, GetNumOfCycles, + GetNumOfCyclesWithEvenSize, GetNumOfCyclesWithOddSize, + GetNumOfCyclesWithSize, GetNumOfCyclesWithSizeGreaterThan, + GetNumOfCyclesWithSizeLessThan, GetNumOfEdgeCycles, + GetNumOfEdgeCyclesWithEvenSize, GetNumOfEdgeCyclesWithOddSize, + GetNumOfEdgeCyclesWithSize, GetNumOfEdgeCyclesWithSizeGreaterThan, + GetNumOfEdgeCyclesWithSizeLessThan, GetNumOfVertexCycles, + GetNumOfVertexCyclesWithEvenSize, GetNumOfVertexCyclesWithOddSize, + GetNumOfVertexCyclesWithSize, GetNumOfVertexCyclesWithSizeGreaterThan, + GetNumOfVertexCyclesWithSizeLessThan, GetPaths, GetPathsBetween, + GetPathsStartingAt, GetPathsStartingAtWithLength, + GetPathsStartingAtWithLengthUpto, GetPathsWithLength, + GetPathsWithLengthUpto, GetSiedelAdjacencyMatrix, GetSizeOfLargestCycle, + GetSizeOfLargestEdgeCycle, GetSizeOfLargestVertexCycle, + GetSizeOfSmallestCycle, GetSizeOfSmallestEdgeCycle, + GetSizeOfSmallestVertexCycle, GetSmallestCycle, GetSmallestEdgeCycle, + GetSmallestVertexCycle, GetTopologicallySortedVertices, GetVertex, + GetVertexCycles, GetVertexCyclesWithEvenSize, + GetVertexCyclesWithOddSize, GetVertexCyclesWithSize, + GetVertexCyclesWithSizeGreaterThan, GetVertexCyclesWithSizeLessThan, + GetVertexProperties, GetVertexProperty, GetVertexWithLargestDegree, + GetVertexWithSmallestDegree, GetVertices, GetVerticesProperty, + GetVerticesWithDegreeLessThan, HasCycle, HasEdge, HasEdgeProperty, + HasEdges, HasFusedCycles, HasGraphProperty, HasPath, HasVertex, + HasVertexProperty, HasVertices, IsAcyclic, IsAcyclicEdge, + IsAcyclicVertex, IsCyclic, IsCyclicEdge, IsCyclicVertex, IsGraph, + IsIsolatedVertex, IsLeafVertex, IsUnicyclic, IsUnicyclicEdge, + IsUnicyclicVertex, SetActiveCyclicPaths, SetEdgeProperties, + SetEdgeProperty, SetEdgesProperty, SetGraphProperties, SetGraphProperty, + SetVertexProperties, SetVertexProperty, SetVerticesProperty, + StringifyEdgesProperties, StringifyGraph, StringifyGraphProperties, + StringifyProperties, StringifyVerticesAndEdges, + StringifyVerticesProperties, UpdateEdgeProperty, UpdateVertexProperty + + METHODS + new + $NewGraph = new Graph([@VertexIDs]); + + Using specified *Graph* *VertexIDs*, new method creates a new Graph + object and returns newly created Graph object. + + Examples: + + $Graph = new Graph(); + $Graph = new Graph(@VertexIDs); + + AddCycle + $Graph->AddCycle(@VertexIDs); + + Adds edges between successive pair of *VertexIDs* including an + additional edge from the last to first vertex ID to complete the + cycle to *Graph* and returns *Graph*. + + AddEdge + $Graph->AddEdge($VertexID1, $VertexID2); + + Adds an edge between *VertexID1* and *VertexID2* in a *Graph* and + returns *Graph*. + + AddEdges + $Graph->AddEdges(@VertexIDs); + + Adds edges between successive pair of *VertexIDs* in a *Graph* and + returns *Graph*. + + AddPath + $Graph->AddPath(@VertexIDs); + + Adds edges between successive pair of *VertexIDs* in a *Graph* and + returns *Graph*. + + AddVertex + $Graph->AddVertex($VertexID); + + Adds *VertexID* to *Graph* and returns *Graph*. + + AddVertices + $Graph->AddVertices(@VertexIDs); + + Adds vertices using *VertexIDs* to *Graph* and returns *Graph*. + + ClearCycles + $Graph->ClearCycles(); + + Delete all cycle properties assigned to graph, vertices, and edges + by *DetectCycles* method. + + Copy + $NewGraph = $Graph->Copy(); + + Copies *Graph* and its associated data using Storable::dclone and + returns a new Graph object. + + CopyEdgesProperties + $OtherGraph = $Graph->CopyEdgesProperties($OtherGraph); + + Copies all properties associated with edges from *Graph* to + *$OtherGraph* and returns *OtherGraph*. + + CopyVerticesAndEdges + $OtherGraph = $Graph->CopyVerticesAndEdges($OtherGraph); + + Copies all vertices and edges from *Graph* to *$OtherGraph* and + returns *OtherGraph*. + + CopyVerticesProperties + $OtherGraph = $Graph->CopyVerticesProperties($OtherGraph); + + Copies all properties associated with vertices from *Graph* to + *$OtherGraph* and returns *OtherGraph*. + + DeleteCycle + $Graph->DeleteCycle(@VertexIDs); + + Deletes edges between successive pair of *VertexIDs* including an + additional edge from the last to first vertex ID to complete the + cycle to *Graph* and returns *Graph*. + + DeleteEdge + $Graph->DeleteEdge($VertexID1, $VertexID2); + + Deletes an edge between *VertexID1* and *VertexID2* in a *Graph* and + returns *Graph*. + + DeleteEdgeProperties + $Graph->DeleteEdgeProperties($VertexID1, $VertexID2); + + Deletes all properties associated with edge between *VertexID1* and + *VertexID2* in a *Graph* and returns *Graph*. + + DeleteEdgeProperty + $Graph->DeleteEdgeProperty($PropertyName, $VertexID1, $VertexID2); + + Deletes *PropertyName* associated with edge between *VertexID1* and + *VertexID2* in a *Graph* and returns *Graph*. + + DeleteEdges + $Graph->DeleteEdges(@VertexIDs); + + Deletes edges between successive pair of *VertexIDs* and returns + *Graph*. + + DeleteEdgesProperties + $Graph->DeleteEdgesProperties(@VertexIDs); + + Deletes all properties associated with edges between successive pair + of *VertexIDs* and returns *Graph*. + + DeleteEdgesProperty + $Graph->DeleteEdgesProperty($PropertyName, @VertexIDs); + + Deletes *PropertyName* associated with edges between successive pair + of *VertexIDs* and returns *Graph*. + + DeleteGraphProperties + $Graph->DeleteGraphProperties(); + + Deletes all properties associated as graph not including properties + associated to vertices or edges and returns *Graph*. + + DeleteGraphProperty + $Graph->DeleteGraphProperty($PropertyName); + + Deletes a *PropertyName* associated as graph property and returns + *Graph*. + + DeletePath + $Graph->DeletePath(@VertexIDs); + + Deletes edges between successive pair of *VertexIDs* in a *Graph* + and returns *Graph*. + + DeleteVertex + $Graph->DeleteVertex($VertexID); + + Deletes *VertexID* to *Graph* and returns *Graph*. + + DeleteVertexProperties + $Graph->DeleteVertexProperties($VertexID); + + Deletes all properties associated with *VertexID* and returns + *Graph*. + + DeleteVertexProperty + $Graph->DeleteVertexProperty($PropertyName, $VertexID); + + Deletes a *PropertyName* associated with *VertexID* and returns + *Graph*. + + DeleteVertices + $Graph->DeleteVertices(@VertexIDs); + + Deletes vertices specified in *VertexIDs* and returns *Graph*. + + DeleteVerticesProperty + $Graph->DeleteVerticesProperty($PropertyName, @VertexIDs); + + Deletes a *PropertyName* associated with *VertexIDs* and returns + *Graph*. + + DetectCycles + $Graph->DetectCycles(); + + Detect cycles using CyclesDetection class and associate found cycles + to *Graph* object as graph properties: *ActiveCyclicPaths, + AllCyclicPaths, IndependentCyclicPaths*. + + Notes: + + . CyclesDetection class detects all cycles in the graph and filters + them to find independent cycles. + . All cycles related methods in the graph operate on + ActiveCyclicPaths. By default, active cyclic paths correspond + to IndependentCyclicPaths. This behavior can be changed + using SetActiveCyclicPaths method. + + GetAdjacencyMatrix + $GraphMatrix = $Graph->GetAdjacencyMatrix(); + + Returns adjacency matrix for *Graph* as a *GraphMatrix* object with + row and column indices corresponding to graph vertices returned by + GetVertices method. + + For a simple graph G with n vertices, the adjacency matrix for G is + a n x n square matrix and its elements Mij are: + + . 0 if i == j + . 1 if i != j and vertex Vi is adjacent to vertex Vj + . 0 if i != j and vertex Vi is not adjacent to vertex Vj + + GetAdmittanceMatrix + $GraphMatrix = $Graph->GetAdmittanceMatrix(); + + Returns admittance matrix for *Graph* as a *GraphMatrix* object with + row and column indices corresponding to graph vertices returned by + GetVertices method. + + For a simple graph G with n vertices, the adjacency matrix for G is + a n x n square matrix and its elements Mij are: + + . 0 if i == j + . 1 if i != j and vertex Vi is adjacent to vertex Vj + . 0 if i != j and vertex Vi is not adjacent to vertex Vj + + GetAllPaths + $PathsRef = $Graph->GetAllPaths([$AllowCycles]); + + Returns a reference to an array containing Path objects + corresponding to all possible lengths starting from each vertex in + graph with sharing of edges in paths traversed. By default, cycles + are included in paths. A path containing a cycle is terminated at a + vertex completing the cycle. Duplicate paths are not removed. + + GetAllPathsStartingAt + @Paths = $Graph->GetAllPathsStartingAt($StartVertexID, + [$AllowCycles]); + + Returns an array of *Path* objects starting from a *StartVertexID* + of any length with sharing of edges in paths traversed. By default, + cycles are included in paths. A path containing a cycle is + terminated at a vertex completing the cycle. + + GetAllPathsStartingAtWithLength + @Paths = $Graph->GetAllPathsStartingAtWithLength($StartVertexID, + $Length, [$AllowCycles]); + + Returns an array of *Path* objects starting from a *StartVertexID* + of specified *Length* with sharing of edges in paths traversed. By + default, cycles are included in paths. A path containing a cycle is + terminated at a vertex completing the cycle. + + GetAllPathsStartingAtWithLengthUpto + @Paths = $Graph->GetAllPathsStartingAtWithLengthUpto($StartVertexID, + $Length, [$AllowCycles]); + + Returns an array of *Path* objects starting from a *StartVertexID* + with length upto a *Length* with sharing of edges in paths + traversed. By default, cycles are included in paths. A path + containing a cycle is terminated at a vertex completing the cycle. + + GetAllPathsWithLength + $PathsRef = $Graph->GetAllPathsWithLength($Length, + [$AllowCycles]); + + Returns a reference to an array containing Path objects + corresponding to paths with *Length* starting from each vertex in + graph with sharing of edges in paths traversed. By default, cycles + are included in paths. A path containing a cycle is terminated at a + vertex completing the cycle. Duplicate paths are not removed. + + GetAllPathsWithLengthUpto + $PathsRef = $Graph->GetAllPathsWithLengthUpto($Length, + [$AllowCycles]); + + Returns a reference to an array containing Path objects + corresponding to paths up to specified *Length* starting from each + vertex in graph with sharing of edges in paths traversed. By + default, cycles are included in paths. A path containing a cycle is + terminated at a vertex completing the cycle. Duplicate paths are not + removed. + + GetCircumference + $Circumference = $Graph->GetCircumference(); + + Returns size of largest cycle in a *Graph* + + GetConnectedComponentsVertices + @ConnectedComponents = $Graph->GetConnectedComponentsVertices(); + + Returns an array *ConnectedComponents* containing referecens to + arrays with vertex IDs for each component sorted in order of their + decreasing size. + + GetCycles + @CyclicPaths = $Graphs->GetCycles(); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles in a *Graph*. + + GetCyclesWithEvenSize + @CyclicPaths = $Graph->GetCyclesWithEvenSize(); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with even size in a *Graph*. + + GetCyclesWithOddSize + @CyclicPaths = $Graph->GetCyclesWithOddSize(); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with odd size in a *Graph*. + + GetCyclesWithSize + @CyclicPaths = $Graph->GetCyclesWithSize($CycleSize); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with *CycleSize* in a *Graph*. + + GetCyclesWithSizeGreaterThan + @CyclicPaths = $Graph->GetCyclesWithSizeGreaterThan($CycleSize); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with size greater than *CycleSize* in a + *Graph*. + + GetCyclesWithSizeLessThan + @CyclicPaths = $Graph->GetCyclesWithSizeGreaterThan($CycleSize); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with size less than *CycleSize* in a + *Graph*. + + GetDegree + $Degree = $Graph->GetDegree($VertexID); + + Returns Degree for *VertexID* in a *Graph* corresponding to sum of + in and out vertex degree values. + + GetDegreeMatrix + $GraphMatrix = $Graph->GetDegreeMatrix(); + + Returns degree matrix for *Graph* as a *GraphMatrix* object with row + and column indices corresponding to graph vertices returned by + GetVertices method. + + For a simple graph G with n vertices, the degree matrix for G is a n + x n square matrix and its elements Mij are: + + . deg(Vi) if i == j and deg(Vi) is the degree of vertex Vi + . 0 otherwise + + GetDistanceMatrix + $GraphMatrix = $Graph->GetDistanceMatrix(); + + Returns distance matrix for *Graph* as a *GraphMatrix* object with + row and column indices corresponding to graph vertices returned by + GetVertices method. + + For a simple graph G with n vertices, the distance matrix for G is a + n x n square matrix and its elements Mij are: + + . 0 if i == j + . d if i != j and d is the shortest distance between vertex Vi and vertex Vj + + In the final matrix, value of constant BigNumber defined in + Constants.pm module corresponds to vertices with no edges. + + GetEdgeCycles + @CyclicPaths = $Graph->GetEdgeCycles($VertexID1, $VertexID2); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to all cycles containing edge between *VertexID1* and + *VertexID2* in a *Graph*. + + GetEdgeCyclesWithEvenSize + @CyclicPaths = $Graph->GetEdgeCyclesWithEvenSize($VertexID1, + $VertexID2); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with even size containing edge between + *VertexID1* and *VertexID2* in a *Graph*. + + GetEdgeCyclesWithOddSize + @CyclicPaths = $Graph->GetEdgeCyclesWithOddSize($VertexID1, + $VertexID2); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with odd size containing edge between + *VertexID1* and *VertexID2* in a *Graph*. + + GetEdgeCyclesWithSize + @CyclicPaths = $Graph->GetEdgeCyclesWithSize($VertexID1, $VertexID2, + $CycleSize); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with size *CycleSize* containing edge + between *VertexID1* and *VertexID2* in a *Graph*. + + GetEdgeCyclesWithSizeGreaterThan + @CyclicPaths = $Graph->GetEdgeCyclesWithSizeGreaterThan($VertexID1, + $VertexID2, $CycleSize); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with size greater than *CycleSize* + containing edge between *VertexID1* and *VertexID2* in a *Graph*. + + GetEdgeCyclesWithSizeLessThan + @CyclicPaths = $Graph->GetEdgeCyclesWithSizeLessThan($VertexID1, + $VertexID2, $CycleSize); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with size less than *CycleSize* containing + edge between *VertexID1* and *VertexID2*. + + GetEdgeProperties + %EdgeProperties = $Graph->GetEdgeProperties($VertexID1, $VertexID2); + + Returns a hash EdgeProperties containing all PropertyName and + PropertyValue pairs associated with an edge between *VertexID1* and + *VertexID2* in a *Graph*. + + GetEdgeProperty + $Value = $Graph->GetEdgeProperty($PropertyName, $VertexID1, $VertexID2); + + Returns value of *PropertyName* associated with an edge between + *VertexID1* and *VertexID2* in a *Graph*. + + GetEdges + @EdgeVertexIDs = $Graph->GetEdges($VertexID); + $NumOfEdges = $Graph->GetEdges($VertexID); + + Returns an array *EdgeVertexIDs* with successive pair of IDs + corresponding to edges involving *VertexID* or number of edges for + *VertexID* in a *Graph*. + + GetEdgesProperty + @PropertyValues = $Graph->GetEdgesProperty($PropertyName, @VertexIDs); + + Returns an array *PropertyValues* containing property values + corresponding to *PropertyName* associated with edges between + successive pair of *VertexIDs*. + + GetFusedAndNonFusedCycles + ($FusedCycleSetsRef, $NonFusedCyclesRef) = + $Graph->GetFusedAndNonFusedCycles(); + + Returns references to arrays *FusedCycleSetsRef* and + *NonFusedCyclesRef* containing references to arrays of cyclic *Path* + objects corresponding to fuses and non-fused cyclic paths. + + GetGirth + $Girth = $Graph->GetGirth(); + + Returns size of smallest cycle in a *Graph*. + + GetGraphProperties + %GraphProperties = $Graph->GetGraphProperties(); + + Returns a hash EdgeProperties containing all PropertyName and + PropertyValue pairs associated with graph in a *Graph*. + + GetGraphProperty + $PropertyValue = $Graph->GetGraphProperty($PropertyName); + + Returns value of *PropertyName* associated with graph in a *Graph*. + + GetIncidenceMatrix + $GraphMatrix = $Graph->GetIncidenceMatrix(); + + Returns incidence matrix for *Graph* as a *GraphMatrix* object with + row and column indices corresponding to graph vertices returned by + GetVertices method. + + For a simple graph G with n vertices and e edges, the incidence + matrix for G is a n x e matrix its elements Mij are: + + . 1 if vertex Vi and the edge Ej are incident; in other words, Vi and Ej are related + . 0 otherwise + + GetIsolatedVertices + @VertexIDs = $Graph->GetIsolatedVertices(); + + Returns an array *VertexIDs* containing vertices without any edges + in *Graph*. + + GetKirchhoffMatrix + $GraphMatrix = $Graph->GetGetKirchhoffMatrix(); + + Returns Kirchhoff matrix for *Graph* as a *GraphMatrix* object with + row and column indices corresponding to graph vertices returned by + GetVertices method. + + KirchhoffMatrix is another name for LaplacianMatrix. + + GetLaplacianMatrix + $GraphMatrix = $Graph->GetLaplacianMatrix(); + + Returns Laplacian matrix for *Graph* as a *GraphMatrix* object with + row and column indices corresponding to graph vertices returned by + GetVertices method. + + For a simple graph G with n vertices, the Laplacian matrix for G is + a n x n square matrix and its elements Mij are: + + . deg(Vi) if i == j and deg(Vi) is the degree of vertex Vi + . -1 if i != j and vertex Vi is adjacent to vertex Vj + . 0 otherwise + + GetLargestCycle + $CyclicPath = $Graph->GetLargestCycle(); + + Returns a cyclic *Path* object corresponding to largest cycle in a + *Graph*. + + GetLargestEdgeCycle + $CyclicPath = $Graph->GetLargestEdgeCycle($VertexID1, $VertexID2); + + Returns a cyclic *Path* object corresponding to largest cycle + containing edge between *VertexID1* and *VertexID2* in a *Graph*. + + GetLargestVertexCycle + $CyclicPath = $Graph->GetLargestVertexCycle($VertexID); + + Returns a cyclic *Path* object corresponding to largest cycle + containing *VertexID* in a *Graph*. + + GetLeafVertices + @VertexIDs = $Graph->GetLeafVertices(); + + Returns an array *VertexIDs* containing vertices with degree of 1 in + a *Graph*. + + GetMaximumDegree + $Degree = $Graph->GetMaximumDegree(); + + Returns value of maximum vertex degree in a *Graph*. + + GetMininumDegree + $Degree = $Graph->GetMininumDegree(); + + Returns value of minimum vertex degree in a *Graph*. + + GetNeighborhoodVertices + @VertexNeighborhoods = GetNeighborhoodVertices($StartVertexID); + + Returns an array *VertexNeighborhoods* containing references to + arrays corresponding to neighborhood vertices around a specified + *StartVertexID* at all possible radii levels. + + GetNeighborhoodVerticesWithRadiusUpto + @VertexNeighborhoods = GetNeighborhoodVerticesWithRadiusUpto( + $StartVertexID, $Radius); + + Returns an array *VertexNeighborhoods* containing references to + arrays corresponding to neighborhood vertices around a specified + *StartVertexID* upto specified *Radius* levels. + + GetNeighborhoodVerticesWithSuccessors + @VertexNeighborhoods = GetNeighborhoodVerticesWithSuccessors( + $StartVertexID); + + Returns vertex neighborhoods around a specified *StartVertexID*, + along with their successor connected vertices, collected at all + neighborhood radii as an array *VertexNeighborhoods* containing + references to arrays with first value corresponding to vertex ID and + second value as reference to an array containing its successor + connected vertices. + + For a neighborhood vertex at each radius level, the successor + connected vertices correspond to the neighborhood vertices at the + next radius level. Consequently, the neighborhood vertices at the + last radius level don't contain any successor vertices which fall + outside the range of specified radius. + + GetNeighborhoodVerticesWithSuccessorsAndRadiusUpto + @VertexNeighborhoods = GetNeighborhoodVerticesWithSuccessors( + $StartVertexID, $Radius); + + Returns vertex neighborhoods around a specified *StartVertexID*, + along with their successor connected vertices, collected with in a + specified *Radius* as an array *VertexNeighborhoods* containing + references to arrays with first value corresponding to vertex ID and + second value as reference to a list containing its successor + connected vertices. + + For a neighborhood vertex at each radius level, the successor + connected vertices correspond to the neighborhood vertices at the + next radius level. Consequently, the neighborhood vertices at the + last radius level don't contain any successor vertices which fall + outside the range of specified radius. + + GetNeighbors + @VertexIDs = $Graph->GetNeighbors($VertexID); + $NumOfNeighbors = $Graph->GetNeighbors($VertexID); + + Returns an array *VertexIDs* containing vertices connected to + *VertexID* of number of neighbors of a *VertextID* in a *Graph*. + + GetNormalizedLaplacianMatrix + $GraphMatrix = $Graph->GetNormalizedLaplacianMatrix(); + + Returns normalized Laplacian matrix for *Graph* as a *GraphMatrix* + object with row and column indices corresponding to graph vertices + returned by GetVertices method. + + For a simple graph G with n vertices, the normalized Laplacian + matrix L for G is a n x n square matrix and its elements Lij are: + + . 1 if i == j and deg(Vi) != 0 + . -1/SQRT(deg(Vi) * deg(Vj)) if i != j and vertex Vi is adjacent to vertex Vj + . 0 otherwise + + GetNumOfCycles + $NumOfCycles = $Graph->GetNumOfCycles(); + + Returns number of cycles in a *Graph*. + + GetNumOfCyclesWithEvenSize + $NumOfCycles = $Graph->GetNumOfCyclesWithEvenSize(); + + Returns number of cycles with even size in a *Graph*. + + GetNumOfCyclesWithOddSize + $NumOfCycles = $Graph->GetNumOfCyclesWithOddSize(); + + Returns number of cycles with odd size in a *Graph*. + + GetNumOfCyclesWithSize + $NumOfCycles = $Graph->GetNumOfCyclesWithSize($CycleSize); + + Returns number of cycles with *CyclesSize* in a *Graph*. + + GetNumOfCyclesWithSizeGreaterThan + $NumOfCycles = $Graph->GetNumOfCyclesWithSizeGreaterThan( + $CycleSize); + + Returns number of cycles with size greater than *CyclesSize* in a + *Graph*. + + GetNumOfCyclesWithSizeLessThan + $NumOfCycles = $Graph->GetNumOfCyclesWithSizeLessThan($CycleSize); + + Returns number of cycles with size less than *CyclesSize* in a + *Graph*. + + GetNumOfEdgeCycles + $NumOfCycles = $Graph->GetNumOfEdgeCycles($VertexID1, $VertexID2); + + Returns number of cycles containing edge between *VertexID1* and + *VertexID2* in a *Graph*. + + GetNumOfEdgeCyclesWithEvenSize + $NumOfCycles = $Graph->GetNumOfEdgeCyclesWithEvenSize($VertexID1, + $VertexID2); + + Returns number of cycles containing edge between *VertexID1* and + *VertexID2* with even size in a *Graph*. + + GetNumOfEdgeCyclesWithOddSize + $NumOfCycles = $Graph->GetNumOfEdgeCyclesWithOddSize($VertexID1, + $VertexID2); + + Returns number of cycles containing edge between *VertexID1* and + *VertexID2* with odd size in a *Graph*. + + GetNumOfEdgeCyclesWithSize + $NumOfCycles = $Graph->GetNumOfEdgeCyclesWithSize($VertexID1, + $VertexID2, $CycleSize); + + Returns number of cycles containing edge between *VertexID1* and + *VertexID2* with *CycleSize* size in a *Graph*. + + GetNumOfEdgeCyclesWithSizeGreaterThan + $NumOfCycles = $Graph->GetNumOfEdgeCyclesWithSizeGreaterThan( + $VertexID1, $VertexID2, $CycleSize); + + Returns number of cycles containing edge between *VertexID1* and + *VertexID2* with size greater than *CycleSize* size in a *Graph*. + + GetNumOfEdgeCyclesWithSizeLessThan + $NumOfCycles = $Graph->GetNumOfEdgeCyclesWithSizeLessThan( + $VertexID1, $VertexID2, $CycleSize); + + Returns number of cycles containing edge between *VertexID1* and + *VertexID2* with size less than *CycleSize* size in a *Graph*. + + GetNumOfVertexCycles + $NumOfCycles = $Graph->GetNumOfVertexCycles($VertexID); + + Returns number of cycles containing *VertexID* in a *Graph*. + + GetNumOfVertexCyclesWithEvenSize + $NumOfCycles = $Graph->GetNumOfVertexCyclesWithEvenSize($VertexID); + + Returns number of cycles containing *VertexID* with even size in a + *Graph*. + + GetNumOfVertexCyclesWithOddSize + $NumOfCycles = $Graph->GetNumOfVertexCyclesWithOddSize($VertexID); + + Returns number of cycles containing *VertexID* with odd size in a + *Graph*. + + GetNumOfVertexCyclesWithSize + $NumOfCycles = $Graph->GetNumOfVertexCyclesWithSize($VertexID); + + Returns number of cycles containing *VertexID* with even size in a + *Graph*. + + GetNumOfVertexCyclesWithSizeGreaterThan + $NumOfCycles = $Graph->GetNumOfVertexCyclesWithSizeGreaterThan( + $VertexID, $CycleSize); + + Returns number of cycles containing *VertexID* with size greater + than *CycleSize* in a *Graph*. + + GetNumOfVertexCyclesWithSizeLessThan + $NumOfCycles = $Graph->GetNumOfVertexCyclesWithSizeLessThan( + $VertexID, $CycleSize); + + Returns number of cycles containing *VertexID* with size less than + *CycleSize* in a *Graph*. + + GetPaths + $PathsRefs = $Graph->GetPaths([$AllowCycles]); + + Returns a reference to an array of *Path* objects corresponding to + paths of all possible lengths starting from each vertex with no + sharing of edges in paths traversed. By default, cycles are included + in paths. A path containing a cycle is terminated at a vertex + completing the cycle. + + GetPathsBetween + @Paths = $Graph->GetPathsBetween($StartVertexID, $EndVertexID); + + Returns an arrays of *Path* objects list of paths between + *StartVertexID* and *EndVertexID*. For cyclic graphs, the list + contains may contain more than one *Path* object. + + GetPathsStartingAt + @Paths = $Graph->GetPathsStartingAt($StartVertexID, [$AllowCycles]); + + Returns an array of *Path* objects corresponding to all possible + lengths starting from a specified *StartVertexID* with no sharing of + edges in paths traversed. By default, cycles are included in paths. + A path containing a cycle is terminated at a vertex completing the + cycle. + + GetPathsStartingAtWithLength + @Paths = $Graph->StartingAtWithLength($StartVertexID, $Length, + $AllowCycles); + + Returns an array of *Path* objects corresponding to all paths + starting from a specified *StartVertexID* with length *Length* and + no sharing of edges in paths traversed. By default, cycles are + included in paths. A path containing a cycle is terminated at a + vertex completing the cycle. + + GetPathsStartingAtWithLengthUpto + @Paths = $Graph->StartingAtWithLengthUpto($StartVertexID, $Length, + $AllowCycles); + + Returns an array of *Path* objects corresponding to all paths + starting from a specified *StartVertexID* with length upto *Length* + and no sharing of edges in paths traversed. By default, cycles are + included in paths. A path containing a cycle is terminated at a + vertex completing the cycle. + + GetPathsWithLength + @Paths = $Graph->GetPathsWithLength($Length, $AllowCycles); + + Returns an array of *Path* objects corresponding to to paths + starting from each vertex in graph with specified <Length> and no + sharing of edges in paths traversed. By default, cycles are included + in paths. A path containing a cycle is terminated at a vertex + completing the cycle. + + GetPathsWithLengthUpto + @Paths = $Graph->GetPathsWithLengthUpto($Length, $AllowCycles); + + Returns an array of *Path* objects corresponding to to paths + starting from each vertex in graph with length upto specified + *Length* and no sharing of edges in paths traversed. By default, + cycles are included in paths. A path containing a cycle is + terminated at a vertex completing the cycle. + + GetSiedelAdjacencyMatrix + $GraphMatrix = $Graph->GetSiedelAdjacencyMatrix(); + + Returns Siedel admittance matrix for *Graph* as a *GraphMatrix* + object with row and column indices corresponding to graph vertices + returned by GetVertices method. + + For a simple graph G with n vertices, the Siedal adjacency matrix + for G is a n x n square matrix and its elements Mij are: + + . 0 if i == j + . -1 if i != j and vertex Vi is adjacent to vertex Vj + . 1 if i != j and vertex Vi is not adjacent to vertex Vj + + GetSizeOfLargestCycle + $Size = $Graph->GetSizeOfLargestCycle(); + + Returns size of the largest cycle in a *Graph*. + + GetSizeOfLargestEdgeCycle + $Size = $Graph->GetSizeOfLargestEdgeCycle($VertexID1, $VertexID2); + + Returns size of the largest cycle containing egde between + *VertextID1* and *VertexID2* in a *Graph*. + + GetSizeOfLargestVertexCycle + $Size = $Graph->GetSizeOfLargestVertexCycle($VertexID); + + Returns size of the largest cycle containing *VertextID* in a + *Graph*. + + GetSizeOfSmallestCycle + $Size = $Graph->GetSizeOfSmallestCycle(); + + Returns size of the smallest cycle in a *Graph*. + + GetSizeOfSmallestEdgeCycle + $Size = $Graph->GetSizeOfSmallestEdgeCycle($VertexID1, $VertexID2); + + Returns size of the smallest cycle containing egde between + *VertextID1* and *VertexID2* in a *Graph*. + + GetSizeOfSmallestVertexCycle + $Size = $Graph->GetSizeOfSmallestVertexCycle($VertexID); + + Returns size of the smallest cycle containing *VertextID* in a + *Graph*. + + GetSmallestCycle + $CyclicPath = $Graph->GetSmallestCycle(); + + Returns a cyclic *Path* object corresponding to smallest cycle in a + *Graph*. + + GetSmallestEdgeCycle + $CyclicPath = $Graph->GetSmallestEdgeCycle($VertexID1, $VertexID2); + + Returns a cyclic *Path* object corresponding to smallest cycle + containing edge between *VertexID1* and *VertexID2* in a *Graph*. + + GetSmallestVertexCycle + $CyclicPath = $Graph->GetSmallestVertexCycle($VertexID); + + Returns a cyclic *Path* object corresponding to smallest cycle + containing *VertexID* in a *Graph*. + + GetTopologicallySortedVertices + @VertexIDs = $Graph->GetTopologicallySortedVertices( + [$RootVertexID]); + + Returns an array of *VertexIDs* sorted topologically starting from a + specified *RootVertexID* or from an arbitrary vertex ID. + + GetVertex + $VertexValue = $Graph->GetVertex($VertexID); + + Returns vartex value for *VertexID* in a *Graph*. Vartex IDs and + values are equivalent in the current implementation of Graph. + + GetVertexCycles + @CyclicPaths = $Graph->GetVertexCycles($VertexID); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to all cycles containing *VertexID* in a *Graph*. + + GetVertexCyclesWithEvenSize + @CyclicPaths = $Graph->GetVertexCyclesWithEvenSize($VertexID); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with even size containing *VertexID* in a + *Graph*. + + GetVertexCyclesWithOddSize + @CyclicPaths = $Graph->GetVertexCyclesWithOddSize($VertexID); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with odd size containing *VertexID* in a + *Graph*. + + GetVertexCyclesWithSize + @CyclicPaths = $Graph->GetVertexCyclesWithSize($VertexID, + $CycleSize); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with size *CycleSize* containing *VertexID* + in a *Graph*. + + GetVertexCyclesWithSizeGreaterThan + @CyclicPaths = $Graph->GetVertexCyclesWithSizeGreaterThan($VertexID, + $CycleSize); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with size greater than *CycleSize* + containing *VertexID* in a *Graph*. + + GetVertexCyclesWithSizeLessThan + @CyclicPaths = $Graph->GetVertexCyclesWithSizeLessThan($VertexID, + $CycleSize); + + Returns an array *CyclicPaths* containing *Path* objects + corresponding to cycles with size less than *CycleSize* containing + *VertexID* in a *Graph*. + + GetVertexProperties + %VertexProperties = $Graph->GetVertexProperties($VertexID); + + Returns a hash VertexProperties containing all PropertyName and + PropertyValue pairs associated with a *VertexID* in a *Graph*. + + GetVertexProperty + $Value = $Graph->GetVertexProperty($PropertyName, $VertexID); + + Returns value of *PropertyName* associated with a *VertexID* in a + *Graph*. + + GetVertexWithLargestDegree + $VertexID = $Graph->GetVertexWithLargestDegree(); + + Returns VertexID with largest degree in a *Graph*. + + GetVertexWithSmallestDegree + $VertexID = $Graph->GetVertexWithSmallestDegree(); + + Returns VertexID with smallest degree in a *Graph*. + + GetVertices + @VertexIDs = $Graph->GetVertices(); + $VertexCount = $Graph->GetVertices(); + + Returns an array of *VertexIDs* corresponding to all vertices in a + *Graph*; in a scalar context, number of vertices is returned. + + GetVerticesProperty + @PropertyValues = $Graph->GetVerticesProperty($PropertyName, @VertexIDs); + + Returns an array *PropertyValues* containing property values + corresponding to *PropertyName* associated with with *VertexIDs* in + a *Graph*. + + GetVerticesWithDegreeLessThan + @VertexIDs = $Graph->GetVerticesWithDegreeLessThan($Degree); + + Returns an array of *VertexIDs* containing vertices with degree less + than *Degree* in a *Graph*. + + HasCycle + $Status = $Graph->HasCycle(@VertexIDs); + + Returns 1 or 0 based on whether edges between successive pair of + *VertexIDs* including an additional edge from the last to first + vertex ID exists in a *Graph*. + + HasEdge + $Status = $Graph->HasEdge($VertexID1, $VertexID2); + + Returns 1 or 0 based on whether an edge between *VertexID1* and + *VertexID2* exist in a *Graph*. + + HasEdgeProperty + $Status = $Graph->HasEdgeProperty($PropertyName, $VertexID1, + $VertexID2); + + Returns 1 or 0 based on whether *PropertyName* has already been + associated with an edge between *VertexID1* and *VertexID2* in a + *Graph*. + + HasEdges + @EdgesStatus = $Graph->HasEdges(@VertexIDs); + $FoundEdgesCount = $Graph->HasEdges(@VertexIDs); + + Returns an array *EdgesStatus* containing 1s and 0s corresponding to + whether edges between successive pairs of *VertexIDs* exist in a + *Graph*. In a scalar context, number of edges found is returned. + + HasFusedCycles + $Status = $Graph->HasFusedCycles(); + + Returns 1 or 0 based on whether any fused cycles exist in a *Graph*. + + HasGraphProperty + $Status = $Graph->HasGraphProperty($PropertyName); + + Returns 1 or 0 based on whether *PropertyName* has already been + associated as a graph property as opposed to vertex or edge property + in a *Graph*. + + HasPath + $Status = $Graph->HasPath(@VertexIDs)); + + Returns 1 or 0 based on whether edges between all successive pairs + of *VertexIDs* exist in a *Graph*. + + HasVertex + $Status = $Graph->HasVertex($VertexID); + + Returns 1 or 0 based on whether *VertexID* exists in a *Graph*. + + HasVertexProperty + $Status = $Graph->HasGraphProperty($HasVertexProperty, $VertexID); + + Returns 1 or 0 based on whether *PropertyName* has already been + associated with *VertexID* in a *Graph*. + + HasVertices + @VerticesStatus = $Graph->HasVertices(@VertexIDs); + $VerticesFoundCount = $Graph->HasVertices(@VertexIDs); + + Returns an array ** containing 1s and 0s corresponding to whether + *VertexIDs* exist in a *Graph*. In a scalar context, number of + vertices found is returned. + + IsAcyclic + $Status = $Graph->IsAcyclic(); + + Returns 0 or 1 based on whether a cycle exist in a *Graph*. + + IsAcyclicEdge + $Status = $Graph->IsAcyclicEdge($VertexID1, $VertexID2); + + Returns 0 or 1 based on whether a cycle containing an edge between + *VertexID1* and *VertexID2* exists in a *Graph*. + + IsAcyclicVertex + $Status = $Graph->IsAcyclicVertex($VertexID1); + + Returns 0 or 1 based on whether a cycle containing a *VertexID* + exists in a *Graph*. + + IsCyclic + $Status = $Graph->IsCyclic(); + + Returns 1 or 0 based on whether a cycle exist in a *Graph*. + + IsCyclicEdge + $Status = $Graph->IsCyclicEdge($VertexID1, $VertexID2); + + Returns 1 or 0 based on whether a cycle containing an edge between + *VertexID1* and *VertexID2* exists in a *Graph*. + + IsCyclicVertex + $Status = $Graph->IsCyclicVertex($VertexID1); + + Returns 1 or 0 based on whether a cycle containing a *VertexID* + exists in a *Graph*. + + IsGraph + $Status = Graph::IsGraph($Object); + + Returns 1 or 0 based on whether *Object* is a Graph object. + + IsIsolatedVertex + $Status = $Graph->IsIsolatedVertex($VertexID); + + Returns 1 or 0 based on whether *VertexID* is an isolated vertex in + a *Graph*. A vertex with zero as its degree value is considered an + isolated vertex. + + IsLeafVertex + $Status = $Graph->IsLeafVertex($VertexID); + + Returns 1 or 0 based on whether *VertexID* is an isolated vertex in + a *Graph*. A vertex with one as its degree value is considered an + isolated vertex. + + IsUnicyclic + $Status = $Graph->IsUnicyclic(); + + Returns 1 or 0 based on whether only one cycle is present in a + *Graph*. + + IsUnicyclicEdge + $Status = $Graph->IsUnicyclicEdge($VertexID1, $VertexID2); + + Returns 1 or 0 based on whether only one cycle contains the edge + between *VertexID1* and *VertexID2* in a *Graph*. + + IsUnicyclicVertex + $Status = $Graph->IsUnicyclicVertex($VertexID); + + Returns 1 or 0 based on whether only one cycle contains *VertexID* + in a *Graph*. + + SetActiveCyclicPaths + $Graph->SetActiveCyclicPaths($CyclicPathsType); + + Sets the type of cyclic paths to use during all methods related to + cycles and returns *Graph*. Possible values for cyclic paths: + *Independent or All*. + + SetEdgeProperties + $Graph->SetEdgeProperties($VertexID1, $VertexID2, @NamesAndValues); + + Associates property names and values corresponding to successive + pairs of values in *NamesAndValues* to an edge between *VertexID1* + and *VertexID2* in a *Graph* and returns *Graph*. + + SetEdgeProperty + $Graph->SetEdgeProperty($Name, $Value, $VertexID1, $VertexID2); + + Associates property *Name* and *Value* to an edge between + *VertexID1* and *VertexID2* in a *Graph* and returns *Graph*. + + SetEdgesProperty + $Graph->SetEdgesProperty($Name, @ValuesAndVertexIDs); + + Associates a same property *Name* but different *Values* for + different edges specified using triplets of *PropertyValue, + $VertexID1, $VertexID2* via *ValuesAndVertexIDs* in a *graph*. + + SetGraphProperties + $Graph->SetGraphProperties(%NamesAndValues); + + Associates property names and values *NamesAndValues* hash to graph + as opposed to vertex or edge and returns *Graph*. + + SetGraphProperty + $Graph->SetGraphProperty($Name, $Value); + + Associates property *Name* and *Value* to graph as opposed to vertex + or edge and returns *Graph*. + + SetVertexProperties + $Graph->SetVertexProperties($VertexID, @NamesAndValues); + + Associates property names and values corresponding to successive + pairs of values in *NamesAndValues* to *VertexID* in a *Graph* and + returns *Graph*. + + SetVertexProperty + $Graph->SetVertexProperty($Name, $Value, $VertexID); + + Associates property *Name* and *Value* to *VertexID* in a *Graph* + and returns *Graph*. + + SetVerticesProperty + $Graph->SetVerticesProperty($Name, @ValuesAndVertexIDs)); + + Associates a same property *Name* but different *Values* for + different vertices specified using doublets of *PropertyValue, + $VertexID* via *ValuesAndVertexIDs* in a *graph*. + + StringifyEdgesProperties + $String = $Graph->StringifyEdgesProperties(); + + Returns a string containing information about properties associated + with all edges in a *Graph* object. + + StringifyGraph + $String = $Graph->StringifyGraph(); + + Returns a string containing information about *Graph* object. + + StringifyGraphProperties + $String = $Graph->StringifyGraphProperties(); + + Returns a string containing information about properties associated + with graph as opposed to vertex. or an edge in a *Graph* object + + StringifyProperties + $String = $Graph->StringifyProperties(); + + Returns a string containing information about properties associated + with graph, vertices, and edges in a *Graph* object. + + StringifyVerticesAndEdges + $String = $Graph->StringifyVerticesAndEdges(); + + Returns a string containing information about vertices and edges in + a *Graph* object. + + StringifyVerticesProperties + $String = $Graph->StringifyVerticesProperties(); + + Returns a string containing information about properties associated + with vertices a *Graph* object. + + UpdateEdgeProperty + $Graph->UpdateEdgeProperty($Name, $Value, $VertexID1, $VertexID2); + + Updates property *Value* for *Name* associated with an edge between + *VertexID1* and *VertexID1* and returns *Graph*. + + UpdateVertexProperty + $Graph->UpdateVertexProperty($Name, $Value, $VertexID); + + Updates property *Value* for *Name* associated with *VertexID* and + returns *Graph*. + +AUTHOR + Manish Sud <msud@san.rr.com> + +SEE ALSO + CyclesDetection.pm, Path.pm, PathGraph.pm, PathsTraversal.pm + +COPYRIGHT + Copyright (C) 2015 Manish Sud. All rights reserved. + + This file is part of MayaChemTools. + + MayaChemTools is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 3 of the License, or (at + your option) any later version. +