/*********************************************************************/ /// <summary> /// Sucht nach einem Attribut, welches für den Knoten optimal ist /// </summary> /// <param name="vertex">Vertex für den der Typ gefunden werden soll</param> /// <returns>gefundener AttributTyp</returns> private CAttributeType findBestAttribute(CTreeVertex vertex) { double bestEntropy = double.MaxValue; CAttributeType bestAttrType = null; List <CAttributeType> attrTypeList = mTableLogic.getAttributeTypes(); foreach (CAttributeType type in attrTypeList) { if ((type.Used == true) && (type.TargetAttribute == false) && (mTreeLogic.isAttributeUsedByParent(vertex, type) == false)) { mTreeLogic.setVertexAttribute(vertex, type); mTreeLogic.updateVertexValues(); // Verhindern das ein Kindknoten alle Einträge enthält wie der Parent, // dann können wir uns das auch sparen if (childDoesOwnAllParentObjects(vertex) == false) { double entropy = calculateWeightedEntropy(vertex); if (entropy < bestEntropy) { bestEntropy = entropy; bestAttrType = type; } } } } return(bestAttrType); }
/// <summary> /// Konstruktor /// </summary> /// <param name="attributyType">Typ der Spalte</param> public CTableColumn(CAttributeType attributyType) { mAttributeType = attributyType; Header = attributyType.Name; Binding = new Binding("[" + attributyType.Index + "].TableValue"); }
/*********************************************************************/ /// <summary> /// fügt eine zusätzliche Spalte in die Tabelle ein /// </summary> /// <param name="name"></param> /// <param name="targetAttribute"></param> /// <returns></returns> public CAttributeType addTableAttribute(string sName, bool bTargetAttribute = false) { if (isAttributExistent(sName) == false) { CAttributeType attrType = getNextAvailableAttibuteType(); if (attrType != null) { attrType.setUsed(sName, E_DATATYPE.E_STRING, bTargetAttribute); return(attrType); } } return(null); #region altcode .. kann eventuell noch gebraucht werden /* * string sSQLCommand = "UPDATE " + CTableConstants.TABLE_ATTRIBUTE_TYPES + " SET " + * CTableConstants.ATTR_TYPES_NAME + "='" + sName + "', " + * CTableConstants.ATTR_TYPES_USED + "=1, " + * CTableConstants.ATTR_TYPES_TARGET_ATTR + "=" + Convert.ToInt16(bTargetAttribute) + * " WHERE " + CTableConstants.ATTR_TYPES_INTERNAL_NAME + "='" + sInternalName + "'"; * mConnection.sqlExecuteStatement(sSQLCommand); * * return true; */ #endregion }
/*********************************************************************/ /// <summary> /// Setzt für einen Vertex das Attribut welches dieser Repräsentiert /// </summary> /// <param name="vertex">Vertex dessen Attribut geändert werden soll</param> /// <param name="attributeType">neues Attribut des Vertex</param> public bool setVertexAttribute(CTreeVertex vertex, CAttributeType attributeType) { if (mTreeLogic.setVertexAttribute(vertex, attributeType) == true) { mTreeLogic.updateVertexValues(); return(true); } return(false); }
/*********************************************************************/ /// <summary> /// Fügt eine Spalte für das Datagrid ein, aus einem AttributTypen /// </summary> /// <param name="columnData">Attributtype für den eine Spalte eingefügt /// werden soll</param> void addDatagridColumn(CAttributeType columnData) { if (columnData != null) { DataGridTextColumn column = new CTableColumn(columnData); //column.Header = columnData.Name; //column.Binding = new Binding("[ " + columnData.Index + "].TableValue"); datagrid1.Columns.Add(column); } }
public void testTypes() { CAttributeType typeNumber = new CAttributeType(0); Assert.IsTrue(typeNumber.Used == false); typeNumber.setUsed("Number", E_DATATYPE.E_INT, true); Assert.IsTrue(typeNumber.DataType == E_DATATYPE.E_INT); Assert.IsTrue(typeNumber.Name == "Number"); Assert.IsTrue(typeNumber.TargetAttribute == true); }
public void testAttributeGeneration() { CAttributeType typeNumber = new CAttributeType(0); typeNumber.setUsed("Number", E_DATATYPE.E_INT, false); CAttributeType typeString = new CAttributeType(0); typeString.setUsed("String", E_DATATYPE.E_STRING, false); CAttributeType typeFloat = new CAttributeType(0); typeFloat.setUsed("Float", E_DATATYPE.E_FLOAT, false); // Attributwerte mit unterschiedlichen Typen erstellen CAttributeValue[] values = new CAttributeValue[10]; for (int i = 0; i < 10; i++) { switch (i % 2) { case 0: values[i] = new CAttributeValue(typeString, i.ToString(), i.ToString(), null); break; case 1: values[i] = new CAttributeValue(typeNumber, i.ToString(), i.ToString(), null); break; case 2: values[i] = new CAttributeValue(typeFloat, i.ToString(), i.ToString(), null); break; } } // testen ob die Werte korrekt eingetragen wurden for (int i = 0; i < 10; i++) { switch (values[i].AttributeType.DataType) { case E_DATATYPE.E_STRING: Assert.IsTrue(values[i].StringValue == i.ToString()); break; case E_DATATYPE.E_INT: Assert.IsTrue(values[i].IntegerValue == i); break; case E_DATATYPE.E_FLOAT: Assert.IsTrue(values[i].FloatValue == i); break; } } }
/*********************************************************************/ /// <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); }
/*********************************************************************/ /// <summary> /// Setzt für einen Vertex das Attribut welches dieser Repräsentiert /// </summary> /// <param name="vertex">Vertex dessen Attribut geändert werden soll</param> /// <param name="attributeType">neues Attribut des Vertex</param> internal bool setVertexAttribute(CTreeVertex vertex, CAttributeType attributeType) { // sollte das Attribut bereits von einem Parent-Knoten verwendet werden // darf der Benutzer dieser Attribut nicht verwenden if (isAttributeUsedByParent(vertex, attributeType) == true) { return(false); } // wenn das Attribut bereits das ist welches der Vertex repräsentiert, // müssen wir nichts machen. if (vertex.AttributeType != attributeType) { mTreeHandler.removeChildVertices(vertex); // Attribut des Vertex setzen vertex.AttributeType = attributeType; if (vertex.AttributeType != null) { // TODO Kindknoten erzeugen und Verbindungen anlegen: //diskreter Wert (Splitwerte zurzeit nicht verfügbar -> ||true) if (attributeType.DataType.Equals(E_DATATYPE.E_STRING) || true) { //alte Children löschen mTreeHandler.removeChildVertices(vertex); //Werte für die Kindknoten erhalten CValueList childVertices = mTableLogic.getChildVertices(vertex); //Knoten und Verbindungen hinzufügen foreach (CAttributeValue value in childVertices) { CTreeVertex childVertex = addVertex(vertex, null); childVertex.ParentEdge = addEdge(vertex, childVertex, value); } } else //stetiger Wert { //Splitwert abfragen //Datenbankabfrage, GROUP BY? // } } return(true); } return(false); }
/*********************************************************************/ /// <summary> /// Setzt das Zielattribut auf den übergebenen Typen /// </summary> /// <param name="targetAttributeType">Attributtyp der zum Zielattribut /// werden soll</param> /// <returns>Erfolg des Setztens</returns> public bool setTargetAttribute(CAttributeType targetAttributeType) { if (isValidTargetAttribut(targetAttributeType) == false) { return(false); } foreach (CAttributeType attributeType in mAttributeTypeList) { attributeType.TargetAttribute = false; } targetAttributeType.TargetAttribute = true; return(true); }
private static CAttributeType getTargetAttribute(Logic.CTableLogic tableLogic) { List <CAttributeType> attributeTypeList = tableLogic.getAttributeTypes(); CAttributeType targetAttribute = null; foreach (CAttributeType type in attributeTypeList) { if (type.TargetAttribute == true) { targetAttribute = type; break; } } return(targetAttribute); }
/*********************************************************************/ /// <summary> /// Prüft ob ein AttributType bereits von ein ParentKnoten des /// übergebenen Kontens verwendet wird /// </summary> /// <param name="vertex">Vertex dessen Parentes geprüft werden</param> /// <param name="type">zu Prüfender Type</param> /// <returns>True - wird von Parent benutzt, False - sonst</returns> public bool isAttributeUsedByParent(CTreeVertex vertex, CAttributeType type) { // Durch alle Parentelemente des Knotenes gehen und prüfen ob dieses Attribut // nicht schon verwendet wurde CTreeVertex parent = vertex.ParentVertex; while (parent != null) { if (parent.AttributeType == type) { return(true); } parent = parent.ParentVertex; } return(false); }
public void TesthandleDataTypeofValue() { CAttributeType typeNumber = new CAttributeType(0); typeNumber.setUsed("Number", E_DATATYPE.E_INT, true); CAttributeValue myValue = new CAttributeValue(typeNumber, "1", "1", null); CDataTypeChecker checker = new CDataTypeChecker(); checker.handleDataTypeofValue(myValue, "1.3"); Assert.IsTrue(myValue.AttributeType.DataType == E_DATATYPE.E_FLOAT, "float hinzufügen"); checker.handleDataTypeofValue(myValue, "2"); Assert.IsTrue(myValue.AttributeType.DataType == E_DATATYPE.E_INT, "int hinzufügen"); checker.handleDataTypeofValue(myValue, "wer"); Assert.IsTrue(myValue.AttributeType.DataType == E_DATATYPE.E_STRING, "string hinzufügen"); }
public void testValuesList() { CValueList valueList = new CValueList(); CAttributeType typeNumber = new CAttributeType(0); typeNumber.setUsed("Number", E_DATATYPE.E_INT, false); CAttributeType typeString = new CAttributeType(0); typeString.setUsed("String", E_DATATYPE.E_STRING, false); CAttributeType typeFloat = new CAttributeType(0); typeFloat.setUsed("Float", E_DATATYPE.E_FLOAT, false); // Attributwerte mit unterschiedlichen Typen erstellen und in die Liste einfügen for (int i = 0; i < 10; i++) { switch (i % 2) { case 0: valueList.addValue(new CAttributeValue(typeString, i.ToString(), i.ToString(), null)); break; case 1: valueList.addValue(new CAttributeValue(typeNumber, i.ToString(), i.ToString(), null)); break; case 2: valueList.addValue(new CAttributeValue(typeFloat, i.ToString(), i.ToString(), null)); break; } } Assert.IsTrue(valueList.Size == 10); // Zugriff per foreach auf Elemente der Liste foreach (CAttributeValue value in valueList) { value.ToString(); } // Zugriff per Index auf ein Element valueList[0].ToString(); }
/*********************************************************************/ /// <summary> /// führt den TDIDT Algorithmus für einen Knoten durch und sucht nach /// dem Optimalen Attribut für diesen Knoten und seine Kindknoten /// </summary> /// <param name="vertex"></param> private void doTDIDT(CTreeVertex vertex) { mTreeLogic.updateVertexValues(); if (stopCriteriaMet(vertex) == false) { // wir suchen das Optimale Attribut für diesen Knoten CAttributeType bestType = findBestAttribute(vertex); // nur wenn noch Attribute vorhanden sind machen wir weiter // if (bestType != null) { mTreeLogic.setVertexAttribute(vertex, bestType); foreach (CTreeVertex child in vertex.ChildList) { doTDIDT(child); } } } }
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; }
public void ItemTestIndex() { CTableEntryList list = new CTableEntryList(); CAttributeType attrType = new CAttributeType(0); attrType.setUsed("asd", E_DATATYPE.E_STRING, false); for (int i = 0; i < 10; i++) { CTableEntry entry = new CTableEntry(i.ToString()); entry.addValue(new CAttributeValue(attrType, i.ToString(), i.ToString(), null)); list.addEntry(entry); } CTableEntry singleEntry; singleEntry = list[5]; Assert.IsTrue(singleEntry.Size == 1); Assert.IsTrue(singleEntry[0].EntryIndex == "5"); Assert.IsTrue(singleEntry[0].StringValue == "5"); }
private bool isValidTargetAttribut(CAttributeType type) { bool bRet = true; string sSqlCommand = "SELECT DISTINCT " + type.InternalName + " FROM " + CTableConstants.TABLE_ATTRIBUTES; SQLiteDataReader reader; CValueList entryList = new CValueList(); if (mConnection.sqlRequestStatement(sSqlCommand, out reader) == true) { while (reader.Read() == true) { string sValue = reader[0] as string; if ((sValue != "j") && (sValue != "n")) { bRet = false; } } closeReader(reader); } return(bRet); }
protected CTreeVertex addVertex(CTreeVertex parent, CAttributeType type = null) { return(mTreeHandler.addVertex(parent, type)); }
/*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; }
/*********************************************************************/ /// <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)); }
/*********************************************************************/ /// <summary> /// Setzt das Zielattribut auf den übergebenen Typen /// </summary> /// <param name="targetAttributeType">Attributtyp der zum Zielattribut /// werden soll</param> /// <returns>Erfolg des Setztens</returns> public bool setTargetAttribute(CAttributeType targetAttributeType) { return(mDBAccess.setTargetAttribute(targetAttributeType)); }
/*********************************************************************/ /// <summary> /// Wird aufgrufen wenn ein Button von der Tabellenansicht geklickt wurde /// </summary> private void RibbonButtonTableView_Click(object sender, RoutedEventArgs e) { // Spalte hinzufügen Button if (sender.Equals(btnAddColumn) == true) { string name = Microsoft.VisualBasic.Interaction.InputBox("Geben Sie den Namen des Attributs ein", "Attributname", ""); if (!name.Equals("")) { CAttributeType columnData = mBusinessLogic.addAttribute(name); addDatagridColumn(columnData); } } // selektierte Spalte löschen Button else if (sender.Equals(btnRemoveColumn) == true) { if (datagrid1.CurrentColumn != null) { DataGridColumn column = datagrid1.CurrentColumn; if (mBusinessLogic.removeAttribute((string)column.Header) == true) { datagrid1.Columns.Remove(column); } } } // Neue Zeile hinzufügen else if (sender.Equals(btnAddRow) == true) { mTableEntryList.addEntry(mBusinessLogic.addDataset()); } // Selektierte Zeile Löschen else if (sender.Equals(btnRemoveRow) == true) { if (datagrid1.SelectedItem != null) { CTableEntry selectedEntry = (CTableEntry)datagrid1.SelectedItem; if (mBusinessLogic.removeDataset(selectedEntry) == true) { mTableEntryList.Remove(selectedEntry); } } } // Selektierte Zeile als Zielattribut setzen else if (sender.Equals(btnSetTargetAttribute) == true) { CTableColumn selectedColumn = datagrid1.CurrentColumn as CTableColumn; if (selectedColumn != null) { if (mBusinessLogic.setTargetAttribute(selectedColumn.ColumnDataType) == true) { foreach (CTableColumn column in datagrid1.Columns) { //column.HeaderStyle = FindResource("DefaultColumnHeaderStyle") as Style; column.HeaderStyle = null; } selectedColumn.HeaderStyle = FindResource("TargetValueColumnHeaderStyle") as Style; CTableEntry entry = (CTableEntry)datagrid1.CurrentItem; setTreeViewsEnabled(true); } else { MessageBox.Show("Das Attribut \"" + selectedColumn.ColumnDataType.Name + "\" kann nicht als Zielattribut gesetzt werden, da nur Datensätze mit den Einträgen \"j\" und \"n\" zugelassen sind.", "Ungültiges Zielattribut", MessageBoxButton.OK, MessageBoxImage.Warning); } } } }
/*********************************************************************/ /// <summary> /// Setzt das Zielattribut auf den übergebenen Typen /// </summary> /// <param name="cAttributeType">Attributtyp der zum Zielattribut werden soll</param> /// <returns>Erfolg des Setztens</returns> public bool setTargetAttribute(CAttributeType targetAttributeType) { mTreeLogic.setTableSetupChanged(); return(mTableLogic.setTargetAttribute(targetAttributeType)); }