/*********************************************************************/
/// <summary>
/// Konstruktor
/// </summary>
public CTree()
{
mGraph = new CTreeGraph();
mEdgeList = new List <CTreeEdge>();
mVertexList = new List <CTreeVertex>();
mRoot = addVertex(null);
mVertexList.Add(mRoot);
}
internal CTreeEdge addEdge(CTreeVertex parent, CTreeVertex child, CAttributeValue attributeValue)
{
CTreeEdge edge = new CTreeEdge(parent, child, attributeValue);
mGraph.AddEdge(edge);
mEdgeList.Add(edge);
return(edge);
}
/*********************************************************************/
/// <summary>
/// Erstellt einen Vertex und fügt ihn in den Baum ein.
/// </summary>
/// <param name="parent">Übergeordneter Knoten im Baum</param>
/// <param name="attributeType">Attributtyp nach dem aufgeteilt werden soll</param>
/// <returns>Hinzugefügter Vertex</returns>
public CTreeVertex addVertex(CTreeVertex parent, CAttributeType attributeType = null)
{
CTreeVertex vertex = new CTreeVertex(parent, mGraph, attributeType);
mVertexList.Add(vertex);
mGraph.AddVertex(vertex);
if (parent != null)
{
parent.ChildList.Add(vertex);
}
return(vertex);
}
public double getEntropy(CTreeVertex vertex)
{
if (vertex.CountObjectsPerClass[CTreeVertex.YES_INDEX] == 0 || vertex.CountObjectsPerClass[CTreeVertex.NO_INDEX] == 0)
{
return(0);
}
else
{
double yesFactor = (double)vertex.CountObjectsPerClass[CTreeVertex.YES_INDEX] / (double)vertex.CountObjects;
double noFactor = (double)vertex.CountObjectsPerClass[CTreeVertex.NO_INDEX] / (double)vertex.CountObjects;
return(-(yesFactor * Math.Log(yesFactor, 2) + noFactor * Math.Log(noFactor, 2)));
}
}
private void updateVertexValue(CTreeVertex vertex, Logic.CTableLogic tableLogic)
{
CEntropyCalculator entropyCalc = new CEntropyCalculator();
vertex.CountObjects = tableLogic.getFilteredTableData(vertex).Count;
updateVertexClassCount(vertex, tableLogic);
foreach (CTreeVertex child in vertex.ChildList)
{
updateVertexValue(child, tableLogic);
}
vertex.Entropy = entropyCalc.getEntropy(vertex);
vertex.WeightedEntropy = entropyCalc.getWeightedEntropy(vertex);
}
/*********************************************************************/
/// <summary>
/// Löscht die Kindelement des übergebenen Vertex und die dazugehörigen
/// Verbindungen.
/// </summary>
/// <param name="vertex">Vertex dessen Kindknoten entfernt werden sollen</param>
/// <returns>Erfolg der Operation</returns>
public bool removeChildVertices(CTreeVertex vertex)
{
if (vertex.ChildList.Count > 0)
{
foreach (CTreeVertex child in vertex.ChildList)
{
// von dem Kind die Kindelmente löschen
removeChildVertices(child);
// Die Verbindungzum Parent löschen
removeEdge(child.ParentEdge);
// und den Kindknoten selbst
removeVertex(child);
}
vertex.ChildList.Clear();
return(true);
}
// es wurden kein Elemente gelöscht
return(false);
}
private void updateVertexClassCount(CTreeVertex vertex, Logic.CTableLogic tableLogic)
{
CTableEntryList entryList = tableLogic.getFilteredTableData(vertex);
CAttributeType targetAttribute = getTargetAttribute(tableLogic);
int[] counts = new int[2];
counts[CTreeVertex.YES_INDEX] = 0;
counts[CTreeVertex.NO_INDEX] = 0;
if (targetAttribute != null)
{
bool bFirst = true;
int targetAttributeIndex = 0;
foreach (CTableEntry entry in entryList)
{
if (bFirst == true)
{
for (int i = 0; i < entry.Size; i++)
{
if (entry[i].AttributeType.InternalName == targetAttribute.InternalName)
{
targetAttributeIndex = i;
}
}
bFirst = false;
}
// TODO Bei Zielattr nicht nur Binär Verzweigen
if (entry[targetAttributeIndex].TableValue == "j")
{
counts[CTreeVertex.YES_INDEX]++;
}
else if (entry[targetAttributeIndex].TableValue == "n")
{
counts[CTreeVertex.NO_INDEX]++;
}
}
}
vertex.CountObjectsPerClass = counts;
}
/*********************************************************************/
/// <summary>
/// Setzt den Baum auf den Initalzustand mit einem leeren Root-Knoten
/// zurück
/// </summary>
public void resetTree()
{
// alle bestehenden Knoten und Verbindungen des Baumes löschen
/*foreach (CTreeEdge edge in mEdgeList)
* {
* mGraph.RemoveEdge(edge);
* }*/
mEdgeList.Clear();
/*foreach (CTreeVertex vertex in mVertexList)
* {
* mGraph.RemoveVertex(vertex);
* }*/
mGraph = new CTreeGraph();
mVertexList.Clear();
mRoot = null;
mRoot = addVertex(null);
}
public double getWeightedEntropy(CTreeVertex vertex)
{
double sumEntropy = 0.0;
// für jedes Kind die Teilentropie berechnen lassen
foreach (CTreeVertex child in vertex.ChildList)
{
double childEntityFactor = (double)child.CountObjects / (double)vertex.CountObjects;
double childYesFactor = (double)child.CountObjectsPerClass[CTreeVertex.YES_INDEX] / child.CountObjects;
double childNoFactor = (double)child.CountObjectsPerClass[CTreeVertex.NO_INDEX] / child.CountObjects;
// sichergehen das wir kein NaN oder sonstiges auf sumEntropy aufaddieren
if ((childEntityFactor != 0) && (double.IsNaN(childEntityFactor) == false) &&
(childYesFactor != 0) && (double.IsNaN(childYesFactor) == false) &&
(childNoFactor != 0) && (double.IsNaN(childNoFactor) == false))
{
sumEntropy += childEntityFactor * (-childYesFactor * Math.Log(childYesFactor, 2) - childNoFactor * Math.Log(childNoFactor, 2));
}
}
return(sumEntropy);
}
/*protected int mNumObjects;
* protected int mNumObjectsYes;
* protected int mNumObjectsNo;
* protected double mEntropy;
*
* public void setDemoData(string vertexName, int countObjects, int countObjectsYes, int countObjectsNo, double entropy)
* {
* if (vertexName != "")
* {
* mAttributeType = new CAttributeType(0);
* mAttributeType.Name = vertexName;
* }
*
* mNumObjects = countObjects;
* mNumObjectsYes = countObjectsYes;
* mNumObjectsNo = countObjectsNo;
* mEntropy = entropy;
* }*/
#endregion
/*********************************************************************/
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="parent">Übergeordneter Knoten im Baum</param>
/// <param name="attributeType">Attributtyp nach dem aufgeteilt werden soll</param>
public CTreeVertex(CTreeVertex parent, CTreeGraph graph, CAttributeType attributeType = null)
{
mParentVertex = parent;
mGraph = graph;
AttributeType = attributeType;
}
internal bool removeVertex(CTreeVertex vertex)
{
mVertexList.Remove(vertex);
return(mGraph.RemoveVertex(vertex));
}
/*********************************************************************/
/// <summary>
/// Löscht einen Vertex aus dem Graphen.
/// !!Dabei werden KEINE Edges gelöscht!!
/// </summary>
/// <param name="vertex">zu Entfernender Vertex</param>
/// <returns>Erfolg der Operation</returns>
public bool removeVertex(CTreeVertex vertex)
{
return(mActiveTree.removeVertex(vertex));
}
/*********************************************************************/
/// <summary>
/// Fügt einen Knoten zum Graphen hinzu
/// </summary>
/// <param name="parent">Parent-Knoten des Knotens</param>
/// <param name="type">Typ des Attributes welches der Knoten
/// repräsentiert</param>
/// <returns>erstellter Vertex</returns>
public CTreeVertex addVertex(CTreeVertex parent, CAttributeType type)
{
return(mActiveTree.addVertex(parent, type));
}
public CTreeEdge addEdge(CTreeVertex parent, CTreeVertex child, CAttributeValue attributeValue)
{
return(mActiveTree.addEdge(parent, child, attributeValue));
}
