/// TNodeNet::TNodeI::GetInNId
Range of NodeN: 0 <= NodeN < GetInDeg().
///

/// TNodeNet::TNodeI::GetOutNId
Range of NodeN: 0 <= NodeN < GetOutDeg().
///

/// TNodeNet::TNodeI::GetNbrNId
Range of NodeN: 0 <= NodeN < GetNbrDeg().
///

/// TNodeNet::LoadShM(TShMIn& ShMIn)
The object is read-only. It does not support operations that edit the edge
vectors of nodes or perform illegal operations on the NodeH, EdgeH
(deletion or swapping keys).
///

/// TNodeNet::AddNode (int NId = -1)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.
///

/// TNodeNet::AddNodeUnchecked (int NId = -1)
Returns -1, if the node NId already exists.
Otherwise, it returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
///

/// TNodeNet::AddNode-1 (int NId, const TNodeData& NodeDat)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.
///

/// TNodeNet::DelNode
If the node of ID NId does not exist the function aborts.
///

/// TNodeNet::AddEdge
If the edge already exists return -2. If the edge was successfully added
return -1.
Normally the function should return an ID of the edge added but since edges in
TNodeNet have no IDs we return -1.
Function aborts if SrcNId or DstNId are not nodes in the network.
///

/// TNodeNet::DelEdge
If the edge (SrcNId, DstNId) does not exist in the network function still
completes.
But the function aborts if SrcNId or DstNId are not nodes in the network.
///

/// TNodeNet::Defrag
After performing many node and edge insertions and deletions to a network,
the network data structure will be fragmented in memory.
This function compacts down the network data structure and frees unneeded
memory.
///

/// TNodeNet::IsOk
For each node in the network check that its neighbors are also nodes in the
network.
///

/// TNodeEDatNet::TNodeI::GetInNId
Range of NodeN: 0 <= NodeN < GetInDeg().
///

/// TNodeEDatNet::TNodeI::GetOutNId
Range of NodeN: 0 <= NodeN < GetOutDeg().
///

/// TNodeEDatNet::TNodeI::GetNbrNId
Range of NodeN: 0 <= NodeN < GetNbrDeg().
///

/// TNodeEDatNet::LoadShM(TShMIn& ShMIn)
The object is read-only. It does not support operations that edit the edge
vectors of nodes or perform illegal operations on the NodeH, EdgeH
(deletion or swapping keys).
///

/// TNodeEDatNet::AddNode (int NId = -1)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.
///

/// TNodeEDatNet::AddNodeUnchecked (int NId = -1)
Returns -1, if the node NId already exists.
Otherwise, it returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
///

/// TNodeEDatNet::AddNode-1 (int NId, const TNodeData& NodeDat)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.
///

/// TNodeEDatNet::DelNode
If the node of ID NId does not exist the function aborts.
///

/// TNodeEDatNet::AddEdge (const int& SrcNId, const int& DstNId)
If the edge already exists return -2.
If the edge does not exist and was successfully added return -1.
Normally the function should return an ID of the edge added but since edges in
TNodeEDatNet have no IDs we return -1.
Function aborts if SrcNId or DstNId are not nodes in the network.
///

/// TNodeEDatNet::AddEdge-1 (const int& SrcNId, const int& DstNId, const TEdgeData& EdgeData)
If the edge already exists, set edges data and returns -2.
If the edge does not exist and was successfully added returns -1.
Normally the function should return an ID of the edge added but since edges in
TNodeEDatNet have no IDs it returns -1.
Function aborts if SrcNId or DstNId are not nodes in the network.
///

/// TNodeEDatNet::DelEdge
If the edge (SrcNId, DstNId) does not exist in the network function still
completes.
But the function aborts if SrcNId or DstNId are not nodes in the network.
///

/// TNodeEDatNet::GetEDat (const int& SrcNId, const int& DstNId, TEdgeData& Data)
Returns true, if the edge was found. Otherwise, returns false.
///

/// TNodeEDatNet::Defrag
After performing many node and edge insertions and deletions to a network,
the network data structure will be fragmented in memory.
This function compacts down the network data structure and frees unneeded
memory.
///

/// TNodeEDatNet::IsOk
For each node in the network check that its neighbors are also nodes in the
network.
///

/// TNodeEdgeNet::TNodeI::GetInNId
Range of NodeN: 0 <= NodeN < GetInDeg().
///

/// TNodeEdgeNet::TNodeI::GetOutNId
Range of NodeN: 0 <= NodeN < GetOutDeg().
///

/// TNodeEdgeNet::TNodeI::GetNbrNId
Range of NodeN: 0 <= NodeN < GetNbrDeg().
///

/// TNodeEdgeNet::New()
Call with: TPt <TNodeEdgeNet<TNodeData, TEdgeData> > Net = TNodeEdgeNet<TNodeData, TEdgeData>::New().
///

/// TNodeEdgeNet::LoadShM(TShMIn& ShMIn)
The object is read-only. It does not support operations that edit the edge
vectors of nodes or perform illegal operations on the NodeH, EdgeH
(deletion or swapping keys).
///

/// TNodeEdgeNet::AddNode (int NId = -1)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.
///

/// TNodeEdgeNet::AddNodeUnchecked (int NId = -1)
Returns -1, if the node NId already exists.
Otherwise, it returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
///

/// TNodeEdgeNet::AddNode-1 (int NId, const TNodeData& NodeDat)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.
///

/// TNodeEdgeNet::DelNode
If the node of ID NId does not exist the function aborts.
///

/// TNodeEdgeNet::AddEdge (const int& SrcNId, const int& DstNId, int EId = -1)
Returns the ID of the edge being added.
If EId is -1, edge ID is automatically assigned.
Aborts, if an edge with ID EId already exists.
Aborts, if SrcNId or DstNId are not nodes in the graph.
///

/// TNodeEdgeNet::AddEdge-1 (const int& SrcNId, const int& DstNId, int EId, const TEdgeData& EdgeDat);
Returns the ID of the edge being added.
If EId is -1, edge ID is automatically assigned.
Aborts, if an edge with ID EId already exists.
Aborts, if SrcNId or DstNId are not nodes in the graph.
///

/// TNodeEdgeNet::DelEdge
If the edge (SrcNId, DstNId) does not exist in the network function still
completes.
But the function aborts if SrcNId or DstNId are not nodes in the network.
///

/// TNodeEdgeNet::Defrag
After performing many node and edge insertions and deletions to a network,
the network data structure will be fragmented in memory.
This function compacts down the network data structure and frees unneeded
memory.
///

/// TNodeEdgeNet::IsOk
For each node in the network check that its neighbors are also nodes in the
network.
///

/// TNEANet::Class
Node IDs can be arbitrary non-negative integers. Edges have IDs.
There can be more than one directed edge from one source node to a destination
node.
Self loops (one per node) are allowed as well as multiple (parallel) edges.
Nodes and edges can have attributes/data associated with them.
The attributes can be added dynamically at runtime.
The directed multigraph data structure is implemented using sorted adjacency
lists.
This means adding a node takes constant time, while adding an edge takes
linear time (since adjacency list is kept sorted) in the node degree.
Accessing arbitrary node takes constant time and accessing any edge takes
logarithmic time in the node degree.
The attributes are organized in a columnar store, where each attribute column
is defined for all the nodes or edges in the network.
///

/// TNEANet::TNodeI::GetInNId
Range of NodeN: 0 <= NodeN < GetInDeg().
///

/// TNEANet::TNodeI::GetOutNId 
Range of NodeN: 0 <= NodeN < GetOutDeg().
/// 
    
/// TNEANet::TNodeI::GetNbrNId 
Range of NodeN: 0 <= NodeN < GetNbrDeg().
///

/// TNEANet::New
Call: PNEANet Net = TNEANet::New(Nodes, Edges).
///

/// TNEANet::LoadShM(TShMIn& ShMIn)
The object is read-only. It does not support operations that edit the edge
vectors of nodes or perform illegal operations on the NodeH, EdgeH
(deletion or swapping keys).
///
    
/// TNEANet::AddNode (int NId = -1)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.
/// 

/// TNEANet::AddNodeUnchecked (int NId = -1)
Returns -1, if the node NId already exists.
Otherwise, it returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
///

/// TNEANet::DelNode
If the node of ID NId does not exist the function aborts.
///

/// TNEANet::AddEdge
Returns the ID of the edge being added.
If EId is -1, edge ID is automatically assigned.
Aborts, if an edge with ID EId already exists.
Aborts, if SrcNId or DstNId are not nodes in the graph.
///

/// TNEANet::DelEdge
If the edge (SrcNId, DstNId) does not exist in the graph function still
completes.
But the function aborts if SrcNId or DstNId are not nodes in the graph.
///

/// TNEANet::Defrag
After performing many node and edge insertions and deletions to a graph,
the graph data structure will be fragmented in memory.
This function compacts down the graph data structure and frees unneeded
memory.
///

/// TNEANet::IsOk
For each node in the graph check that its neighbors are also nodes in the
graph.
///

/// TNEANet::AddIntAttrDatN
Adds the key int value pair to the corresponding node attribute value vector.
///

/// TNEANet::AddIntVAttrDatN
Adds the key intv value pair to the corresponding node attribute value vector.
///

/// TNEANet::AddStrAttrDatN
Adds the key str value pair to the corresponding node attribute value vector.
///

/// TNEANet::AddFltAttrDatN
Adds the key flt value pair to the corresponding node attribute value vector.
///

/// TNEANet::AddIntAttrDatE
Adds the key int value pair to the corresponding edge attribute value vector.
///

/// TNEANet::AddIntVAttrDatE
Adds the key integer vector value pair to the corresponding edge attribute value vector.
///

/// TNEANet::AddFltVAttrDatE
Adds the key float vector value pair to the corresponding edge attribute value vector.
///

/// TNEANet::AddStrAttrDatE
Adds the key str value pair to the corresponding edge attribute value vector.
///

/// TNEANet::AddFltAttrDatE
Adds the key flt value pair to the corresponding edge attribute value vector.
///

/// TNEANet::GetSmallGraph
\verbatim
Edges:  0 -> 1, 0 -> 2, 0 -> 3, 0 -> 4, 1 -> 2, 1 -> 2
\endverbatim
///

/// TUndirNet::Class
Node IDs can be arbitrary non-negative integers. Nodes and edges can have
sparse attributes/data associated with them.
There is at most one undirected edge between a pair of nodes.
Self loops (one per node) are allowed but multiple (parallel) edges are not.
The undirected graph data structure is implemented using sorted adjacency
lists.
This means adding a node takes constant time, while adding an edge takes
linear time (since adjacency list is kept sorted) in the node degree.
Accessing arbitrary node takes constant time and accessing any edge takes
logarithmic time in the node degree.
///

/// TUndirNet::TNodeI::GetInNId
Range of NodeN: 0 <= NodeN < GetInDeg(). Since the graph is undirected
GetInNId(), GetOutNId() and GetNbrNId() all give the same output.
///

/// TUndirNet::TNodeI::GetOutNId
Range of NodeN: 0 <= NodeN < GetOutDeg(). Since the graph is undirected
GetInNId(), GetOutNId() and GetNbrNId() all give the same output.
///

/// TUndirNet::TNodeI::GetNbrNId
Range of NodeN: 0 <= NodeN < GetNbrDeg(). Since the graph is undirected
GetInNId(), GetOutNId() and GetNbrNId() all give the same output.
///

/// TUndirNet::New
Call: PUndirNet Net = TUndirNet::New(Nodes, Edges).
///

/// TUndirNet::LoadShM(TShMIn& ShMIn)
The object is read-only. It does not support operations that edit the edge
vectors of nodes or perform illegal operations on the NodeH, EdgeH
(deletion or swapping keys).
///

/// TUndirNet::AddNode (int NId = -1)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.
///

/// TUndirNet::AddNodeUnchecked (int NId = -1)
Returns -1, if the node NId already exists.
Otherwise, it returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
///

/// TUndirNet::AddNode-1 (const int& NId, const TIntV& NbrNIdV)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.

The operation can create inconsistent graphs when the neighboring nodes
in NbrNIdV vector do not exist.
Use TUndirNet::IsOk to check that the resulting graph is consistent
after the operation.
///

/// TUndirNet::AddNode-2 (const int& NId, const TVecPool<TInt>& Pool, const
//int& NIdVId)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.

The operation can create inconsistent graphs when the neighboring nodes
stored in the Pool vector are not explicitly added to the graph.
Use TUndirNet::IsOk to check that the resulting graph is consistent.
///

/// TUndirNet::DelNode
If the node of ID NId does not exist the function aborts.
///

/// TUndirNet::AddEdge
If the edge already exists return -2. If the edge was successfully added
return -1.
Normally the function should return an ID of the edge added but since edges in
TUndirNet have no IDs we return -1.
The function aborts if SrcNId or DstNId are not nodes in the graph.
///

/// TUndirNet::AddEdgeUnchecked
Returns -1.
The method assumes that SrcNId and DstNId are existing nodes in the graph and
adds new neighbor values at the end of their adjacency vectors.
No checks are performed to verify these assumptions.
Adjacency vectors must be sorted and have duplicates removed after a sequence
of these operations to assure consistency of data structures.
///

/// TUndirNet::DelEdge
If the edge (SrcNId, DstNId) does not exist in the graph function still
completes.
But the function aborts if SrcNId or DstNId are not nodes in the graph.
///

/// TUndirNet::GetEI
Note that since this is an undirected graph GetEI(SrcNId, DstNId) has the same
effect as GetEI(DstNId, SrcNId).
///

/// TUndirNet::Defrag
After performing many node and edge insertions and deletions to a graph,
the graph data structure will be fragmented in memory.
This function compacts down the graph data structure and frees unneeded
memory.
///

/// TUndirNet::IsOk
For each node in the graph check that its neighbors are also nodes in the
graph.
///

/// TUndirNet::GetSmallGraph
\verbatim
Graph:   3--0--4
           /|
          1-2
\endverbatim
///

/// TDirNet::Class
Node IDs can be arbitrary non-negative integers. Nodes and edges can have
sparse attributes/data associated with them.
There is at most one directed edge from one source node to a destination
node.
There can be an edge between the same pair of nodes in the opposite direction.
Self loops (one per node) are allowed
but multiple (parallel) edges are not.
The directed graph data structure is implemented using sorted adjacency
lists.
This means adding a node takes constant time, while adding an edge takes
linear time (since adjacency list is kept sorted) in the node degree.
Accessing arbitrary node takes constant time and accessing any edge takes
logarithmic time in the node degree.
///

/// TDirNet::TNodeI::GetInNId
Range of NodeN: 0 <= NodeN < GetInDeg().
///

/// TDirNet::TNodeI::GetOutNId
Range of NodeN: 0 <= NodeN < GetOutDeg().
///

/// TDirNet::TNodeI::GetNbrNId
Range of NodeN: 0 <= NodeN < GetNbrDeg().
///

/// TDirNet::New
Call: PDirNet Net = TDirNet::New(Nodes, Edges).
///

/// TDirNet::LoadShM(TShMIn& ShMIn)
The object is read-only. It does not support operations that edit the edge
vectors of nodes or perform illegal operations on the NodeH, EdgeH
(deletion or swapping keys).
///

/// TDirNet::AddNode (int NId = -1)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.
///

/// TDirNet::AddNodeUnchecked (int NId = -1)
Returns -1, if the node NId already exists.
Otherwise, it returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
///

/// TDirNet::AddNode-1 (const int& NId, const TIntV& InNIdV, const TIntV&
//OutNIdV)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.

The operation can create inconsistent graphs when the neighboring nodes
in vectors InNIdV and OutNIdV do not exist.
Use TDirNet::IsOk to check that the resulting graph is consistent
after the operation.
///

/// TDirNet::AddNode-2 (const int& NId, const TVecPool<TInt>& Pool, const int&
//NIdVId)
Returns the ID of the node being added.
If NId is -1, node ID is automatically assigned.
Aborts, if a node with ID NId already exists.

The operation can create inconsistent graphs when the neighboring nodes
stored in the Pool vector are not explicitly added to the graph.
Use TDirNet::IsOk to check that the resulting graph is consistent.
///

/// TDirNet::DelNode
If the node of ID NId does not exist the function aborts.
///

/// TDirNet::AddEdge
If the edge already exists return -2. If the edge was successfully added
return -1.
Normally the function should return an ID of the edge added but since edges in
TDirNet have no IDs we return -1.
Function aborts if SrcNId or DstNId are not nodes in the graph.
///

/// TDirNet::AddEdgeUnchecked
Returns -1.
The method assumes that SrcNId and DstNId are existing nodes in the graph and
adds new neighbor values at the end of their adjacency vectors.
No checks are performed to verify these assumptions.
Adjacency vectors must be sorted and have duplicates removed after a sequence
of these operations to assure consistency of data structures.
///

/// TDirNet::DelEdge
If the edge (SrcNId, DstNId) does not exist in the graph function still
completes.
But the function aborts if SrcNId or DstNId are not nodes in the graph.
///

/// TDirNet::Defrag
After performing many node and edge insertions and deletions to a graph,
the graph data structure will be fragmented in memory.
This function compacts down the graph data structure and frees unneeded
memory.
///

/// TDirNet::IsOk
For each node in the graph check that its neighbors are also nodes in the
graph.
///

/// TDirNet::GetSmallGraph
\verbatim
Edges:  0 -> 1, 1 -> 2, 0 -> 2, 1 -> 3, 3 -> 4, 2 -> 3
\endverbatim
///

