public static String Report(HasseNodeCollection nodes, HasseNode rootNode)
{
int countLeaves = 0;
int countReals = 0;
foreach (HasseNode node in nodes.Values)
{
if (node.IsLeafNode()) countLeaves++;
if (node.HasNodeType (HasseNode.HasseNodeTypes.REAL)) countReals ++;
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("Leaf count: " + countLeaves.ToString () );
sb.AppendLine("REAL count: " + countReals.ToString () );
// how selective are the root nodes?
// the average root node, how many parents, of all?
List<HasseNodeCollection> NodesInLevel = new List<HasseNodeCollection>();
int CountUpwardEdges = 0;
int CountLeafNodes = 0;
int countAllLeaves = 0;
HasseNodeCollection NodesOnThisLevel = new HasseNodeCollection();
NodesOnThisLevel.Add(rootNode.KeyString , rootNode);
HasseNodeCollection NodesOnThisLevelPlusOne = new HasseNodeCollection();
for (int level = 1; ;level++ )
{
CountUpwardEdges = 0;
CountLeafNodes = 0;
foreach (HasseNode node in NodesOnThisLevel.Values)
{
node.LevelFromRoot = level;
foreach (HasseEdge EdgeUpToParent in node.EdgesToCovering )
{
HasseNode Parent = EdgeUpToParent.UpperNode;
CountUpwardEdges++;
if (!NodesOnThisLevelPlusOne.ContainsKey(Parent.KeyString))
{
NodesOnThisLevelPlusOne.Add(Parent.KeyString, Parent);
}
}
if (node.EdgesToCovering.Count == 0)
{ CountLeafNodes++; countAllLeaves++; }
}
sb.AppendLine("at level " + level.ToString() + ";\tnodes: " + NodesOnThisLevel.Count.ToString() + "\tsum upward edges: " + CountUpwardEdges.ToString() + "\t count leaf nodes: " + CountLeafNodes.ToString());
NodesInLevel.Add(NodesOnThisLevel);
if (NodesOnThisLevelPlusOne.Count ==0) {break;}
NodesOnThisLevel = NodesOnThisLevelPlusOne;
NodesOnThisLevelPlusOne = new HasseNodeCollection();
}
sb.AppendLine("total node count: " + nodes.Count.ToString());
sb.AppendLine("total leaves count: " + countAllLeaves.ToString());
return sb.ToString ();
}
public HasseDiagram Generate(List <GraphNode> NodesForGraph)
{
//LargerThanTest(NodesForGraph);
HasseDiagram HDM = new HasseDiagram(HasseNodeFactory.NodeType.STRING);
HasseNodeCollection elements = new HasseNodeCollection();
foreach (GraphNode node in NodesForGraph)
{
HasseNode hasseNode = node as HasseNode;
HDM.AddNode(node);
}
return(HDM);
}
public FingerPrintChemHasseNode(IndigoChemistry mol, HasseNodeTypes ElementType, HasseNodeCollection globalElementCollection, string debugInfo)
: base(ElementType, globalElementCollection, debugInfo)
{
if (ElementType == HasseNodeTypes.ROOT)
{
// molecule = null;
this.keyString = "";
return;
}
ChemObject = mol;
this.keyString = ChemObject.keystr;
_isvalid = ChemObject.ChemistryIsValid;
base.size = ChemObject.heavyAtomCount;
}
public FingerPrintChemHasseNode(string StrMolecule, HasseNodeTypes ElementType, HasseNodeCollection globalElementCollection, string debugInfo)
: base(ElementType, globalElementCollection, debugInfo)
{
ChemObject = new IndigoChemistry();
if (ElementType == HasseNodeTypes.ROOT)
{
this.keyString = "0";
}
else
{
ChemObject.InitMolecule(StrMolecule);
this.keyString = ChemObject.keystr;
_isvalid = ChemObject.ChemistryIsValid;
base.size = ChemObject.heavyAtomCount;
}
}
// ==========================================
public HasseDiagram(HasseNodeFactory.NodeType t )
{
// construct new HasseDiagram
HasseDiagramNodes = new HasseNodeCollection(); //collection nodes in diagram
DifferenceNodes = new HasseNodeCollection(); //collection of objects expressing difference
//ElementaryHasseNodes = new HasseNodeCollection(); // collection of elements
// factory for nodes, set its nodetype and let it have access to global elements collection
diagramNodeFactory = new HasseNodeFactory(t);
differenceNodeFactory = new HasseNodeFactory(t);
// a queue for nodes to be created after current node is fully processed
FragmentInsertionQueue = new HasseFragmentInsertionQueue(HasseDiagramNodes);
// create the root node as part of construction
RootNode = diagramNodeFactory.NewNode("", HasseNode.HasseNodeTypes.ROOT,"");
HasseDiagramNodes.Add("{}", RootNode);
}
private List<HasseEdge> InsertNodeBetweenGlbAndLub(
HasseNode newNode,
HasseNodeCollection collectionLUB,
HasseNodeCollection collectionGLB, bool debug)
{
bool dbg = Convert.ToBoolean(DEBUGLEVEL & LOG_INSERTIONS);
List<HasseEdge> AddedEdges = new List<HasseEdge>();
// break any existing relations between LUBs and GLBs
// first make list of edges to delete
List<HasseEdge> EdgesToBeDeleted = new List<HasseEdge>();
foreach (HasseNode v_low in collectionGLB.Values)
{
foreach (HasseNode v_high in collectionLUB.Values)
{
System.Diagnostics.Debug.WriteLineIf(dbg, "cut " + v_low.KeyString + " - " + v_high.KeyString);
foreach (HasseEdge E in v_low.EdgesToCovering)
{
if (E.UpperNode == v_high)
EdgesToBeDeleted.Add(E);
}
}
}
foreach (HasseEdge E in EdgesToBeDeleted)
{
RemoveEdge(E);
}
//make differences between elements and new
foreach (HasseNode v_low in collectionGLB.Values)
{
System.Diagnostics.Debug.WriteLineIf(dbg, "cover (I) " + v_low.KeyString + " with " + newNode.KeyString);
HasseEdge NewEdge = MakeEdge(v_low, newNode);
AddedEdges.Add(NewEdge);
}
//make relations between new and LUBs
foreach (HasseNode v_high in collectionLUB.Values)
{
System.Diagnostics.Debug.WriteLineIf(dbg, "cover (II) " + newNode.KeyString + " with " + v_high.KeyString);
MakeEdge(newNode, v_high);
}
return AddedEdges;
}
public void FindLUBAndGLB(HasseNode newNode, ref HasseNodeCollection lub, ref HasseNodeCollection glb)
{
bool dbgTimings = Convert.ToBoolean(DEBUGLEVEL & LOG_ALL_TIMINGS);
bool dbgComparisons = Convert.ToBoolean(DEBUGLEVEL & LOG_ALL_COMPARISON_COUNTS);
//glb = BruteForceFindGlb(newNode, HasseDiagramNodes);
//lub = BruteForceFindLub(newNode, HasseDiagramNodes);
glb = FindGlb(newNode, HasseDiagramNodes);
lub = FindLub(newNode, HasseDiagramNodes);
}
public void ContractChains2()
{
// identify vertices with one edge out, put them on remove list
HasseNodeCollection VisitedNodes = new HasseNodeCollection();
List<HasseNode> ToBeRemoved = new List<HasseNode>();
foreach (HasseNode Node in HasseDiagramNodes.Values)
{
if (!VisitedNodes.ContainsKey(Node.KeyString))
{
if (Node.EdgesToCovering.Count == 1)
{
foreach (HasseEdge TheCoveringEdge in Node.EdgesToCovering)
{
if (TheCoveringEdge.UpperNode.EdgesToCovered.Count == 1)
ToBeRemoved.Add(Node);
}
}
VisitedNodes.Add(Node.KeyString, Node);
}
}
//now contract nodes A-B to form B
// B must inherit innodes as into A, then throw away A
foreach (HasseNode Node in ToBeRemoved)
{
HasseEdge EdgeUpToCovering = Node.EdgesToCovering[0];
HasseNode NodeCovering = EdgeUpToCovering.UpperNode;
//HasseNode Node2 = null;
System.Diagnostics.Debug.WriteLine("contract [" + Node.KeyString + "]-[" + NodeCovering.KeyString + "]");
RemoveEdge(EdgeUpToCovering);
// make list of edges to covered
HasseEdge[] EdgesToCovered = Node.EdgesToCovered.ToArray();
foreach (HasseEdge E2 in EdgesToCovered)
{
HasseNode Node2 = E2.LowerNode;
// inherit edges from those that Node covers
this.MakeEdge(Node2, NodeCovering);
this.RemoveEdge(E2);
}
HasseDiagramNodes.Remove(Node.KeyString);
}
}
public void ContractChains()
{
HasseNodeCollection VisitedNodes = new HasseNodeCollection();
// identify vertices with one edge in and one edge out, put them on remove list
List<HasseNode> ToBeRemoved = new List<HasseNode>();
foreach (HasseNode Node in HasseDiagramNodes.Values)
{
if (!VisitedNodes.ContainsKey(Node.KeyString))
{
if (Node.EdgesToCovered.Count == 1 && Node.EdgesToCovering.Count == 1)
{
ToBeRemoved.Add(Node);
}
VisitedNodes.Add(Node.KeyString, Node);
}
}
//now contract nodes A-B-C to form A-C, then throw away B
foreach (HasseNode Node in ToBeRemoved)
{
HasseNode Node1 = Node.EdgesToCovered[0].LowerNode;
HasseNode Node2 = Node.EdgesToCovering[0].UpperNode;
this.MakeEdge(Node1, Node2);
this.RemoveEdge(Node.EdgesToCovered[0]);
this.RemoveEdge(Node.EdgesToCovering[0]);
HasseDiagramNodes.Remove(Node.KeyString);
}
}
public static HasseNodeCollection FindLub(HasseNode ReferenceNode, HasseNodeCollection AllNodes)
{
bool dbg = Convert.ToBoolean(DEBUGLEVEL & LOG_DEBUG_MAKE_LUB);
HasseNodeCollection lub = new HasseNodeCollection();
//List<string> ToBeRemoved = new List<string>();
HashSet<string> ToBeRemoved = new HashSet<string>();
foreach (HasseNode Node in AllNodes.Values)
{
if (!ToBeRemoved.Contains(Node.KeyString))
{
System.Diagnostics.Debug.WriteLineIf(dbg, "test if " + Node.KeyString + " is larger than " + ReferenceNode.KeyString);
// debug:
//HasseNode[] subobj = ReferenceNode.getElementarySubobjects().Values.ToArray();
//if (!Node.HasElements(subobj) &&
// (Node.IsLargerThan(ReferenceNode)))
//{
// System.Diagnostics.Debugger.Break();
//}
if ( Node.IsLargerThan(ReferenceNode))
{
System.Diagnostics.Debug.WriteLineIf(dbg, " yes - is lub candidate, delete above...");
lub.Add(Node.KeyString, Node);
FindNodesAbove(Node, ToBeRemoved, 0);
}
/*
else if (ReferenceNode.IsLargerThan(Node))
{
DeleteNodesBelow(Node, ToBeRemoved, 0);
}
*/
else ToBeRemoved.Add(Node.KeyString);
}
}
foreach (string key in ToBeRemoved)
{
lub.Remove(key);
}
return (lub);
}
public static HasseNodeCollection FindGlb(HasseNode ReferenceNode, HasseNodeCollection AllNodes)
{
bool dbg = Convert.ToBoolean(DEBUGLEVEL & LOG_DEBUG_MAKE_GLB);
HasseNodeCollection glb = new HasseNodeCollection();
//List<string> ToBeRemoved = new List<string>();
HashSet<string> ToBeRemoved = new HashSet<string>();
foreach (HasseNode Node in AllNodes.Values)
{
if (!ToBeRemoved.Contains(Node.KeyString))
{
System.Diagnostics.Debug.WriteLineIf(dbg, "test if " + ReferenceNode.KeyString + " is larger than " + Node.KeyString);
if ( ReferenceNode.IsLargerThan(Node))
{
System.Diagnostics.Debug.WriteLineIf(dbg, " yes - is glb candidate, delete below...");
glb.Add(Node.KeyString, Node);
FindNodesBelow(Node, ToBeRemoved, 0);
}
/* else if (Node.IsLargerThan(ReferenceNode))
{
DeleteNodesAbove(Node, ToBeRemoved, 0);
}
*/
else ToBeRemoved.Add(Node.KeyString);
}
}
foreach (string key in ToBeRemoved)
{
glb.Remove(key);
}
return (glb);
}
public static HasseNodeCollection BruteForceFindLub(HasseNode @ref, HasseNodeCollection AllNodes)
{
#if DEBUG
// if (@ref.UniqueString.Equals("*B*")) {
// System.Diagnostics.Debugger.Break();
// }
#endif
HasseNodeCollection lub = new HasseNodeCollection();
List<string> ToBeRemoved = new List<string>();
foreach (HasseNode Node in AllNodes.Values)
{
if (Node.IsLargerThan(@ref))
{
lub.Add(Node.KeyString, Node);
}
}
foreach (HasseNode Node in lub.Values)
{
foreach (HasseNode Node2 in lub.Values)
{
if (Node2.IsLargerThan(Node))
{
ToBeRemoved.Add(Node2.KeyString);
//break;
}
}
}
foreach (string key in ToBeRemoved)
{
lub.Remove(key);
}
return (lub);
}
public static HasseNodeCollection BruteForceFindGlb(HasseNode @ref, HasseNodeCollection AllNodes)
{
if (@ref.KeyString.Equals("x")) { System.Diagnostics.Debugger.Break(); }
HasseNodeCollection glb = new HasseNodeCollection();
List<string> ToBeRemoved = new List<string>();
foreach (HasseNode Node in AllNodes.Values)
{
if (@ref.IsLargerThan(Node))
{
glb.Add(Node.KeyString, Node);
}
}
foreach (HasseNode Node in glb.Values)
{
foreach (HasseNode Node2 in glb.Values)
{
if (Node != Node2)
{
if (Node.IsLargerThan(Node2))
{ ToBeRemoved.Add(Node2.KeyString); }
// break;
}
}
}
foreach (string key in ToBeRemoved)
{
glb.Remove(key);
}
return (glb);
}
public DotFileWriter(HasseNodeCollection col, List<HasseNode> _subset, string path)
{
NodeCollection = col;
FilenameAndPath = path;
subset= _subset;
}
public DotFileWriter(HasseNodeCollection col, string path)
{
NodeCollection = col;
FilenameAndPath = path;
}
