Exemple #1
0
        public Node(string title, VirtualTable vt)
            : this(title)
        {
            Attribute att=new Attribute();

            VT = vt;
            //Fills the cases, maybe is not suitable for C&RT
            for(int x=0; x < Tree.VariableL.Count; ++x)
            {
                att = new Attribute(x);
                AttributeL.Add(att);
                for(int y=0; y < VT.RowCount; ++y)
                {
                    att.AddCase(VT[x, y]);
                }
            }
        }
Exemple #2
0
        public Cluster_(VirtualTable data, Node nodeParent)
        {
            //this.DS=data;

            NodeParent=nodeParent;

            //The root parameters and cases will be set during the Fill DataSet
            if(Tree.Root==null) //It is OK! (workaround)
                return;

            //Set the Attributes

            //outdated!!! blocks changing the type of the variable
            //			DataRow row = FrmMain.SFrmMain.DS.Tables[0].Rows[0];
            //			double val;
            //			foreach(DataColumn dc in FrmMain.SFrmMain.DS.Tables[0].Columns)
            //			{
            //				try
            //				{
            //					val=Double.Parse(row[dc, DataRowVersion.Original].ToString());
            //					att = new Attribute(dc.ColumnName.ToString(), Attribute.TypeEnum.Numerical);
            //					AttributeL.Add(att);
            //				}
            //				catch
            //				{
            //					att = new Attribute(dc.ColumnName.ToString(), Attribute.TypeEnum.Categorical);
            //					AttributeL.Add(att);
            //				}
            //			}
            //
            //
            //			//Set the Cases
            //			for(int x=0; x < AttributeQty; ++x)
            //			{
            //				att = (Attribute) AttributeL[x];
            //				for(int y=0; y < RowQty; ++y)
            //				{
            //					att.AddCase(DS[x,y]);
            //				}
            //			}
        }
        public static void QuickSortDouble(VirtualTable a, int lo0, int hi0, int col)
        {
            int lo = lo0;
            int hi = hi0;
            double mid;

            if ( hi0 > lo0)
            {
                /* Arbitrarily establishing partition element as the midpoint of
                * the array.
                */
                mid = a.GetNumber(col, (int) ( lo0 + hi0 ) / 2);

                // loop through the array until indices cross
                while( lo <= hi )
                {
                    /* find the first element that is greater than or equal to
                    * the partition element starting from the left Index.
                    */
                    while( ( lo < hi0 ) && ( a.GetNumber(col, lo) < mid ) )
                        ++lo;

                    /* find an element that is smaller than or equal to
                    * the partition element starting from the right Index.
                    */
                    while( ( hi > lo0 ) && ( a.GetNumber(col, hi) > mid ) )
                        --hi;

                    // if the indexes have not crossed, swap
                    if( lo <= hi )
                    {
                        swap(a, lo, hi);

                        ++lo;
                        --hi;
                    }
                }

                /* If the right index has not reached the left side of array
                * must now sort the left partition.
                */
                if( lo0 < hi )
                    QuickSortDouble( a, lo0, hi, col );

                /* If the left index has not reached the right side of array
                * must now sort the right partition.
                */
                if( lo < hi0 )
                    QuickSortDouble( a, lo, hi0, col );
            }
        }
 public VirtualTable SubSetUpTo(int col, double threshold)
 {
     DynArrInt rowsSelected = new DynArrInt();
     for(int y=0; y <  RowCount; ++y)
     {
         if(GetNumber(col, y) <= threshold)
         try
         {
                 rowsSelected.Add(row[y]);
         }
         catch(Exception e)
         {
                 MessageBox.Show(e.Message);
         }
     }
     VirtualTable subVT = new VirtualTable(rowsSelected);
     return subVT;
 }
 public VirtualTable SubSet(int col, string val)
 {
     DynArrInt rowsSelected = new DynArrInt();
     for(int y=0; y <  RowCount; ++y)
     {
         if(this[col, y].ToString().CompareTo(val) == 0)
             rowsSelected.Add(row[y]);
     }
     VirtualTable subVT = new VirtualTable(rowsSelected);
     return subVT;
 }
        public static void swap(VirtualTable a, int i, int j)
        {
            int T;

            if(i==-1)
                MessageBox.Show("Index = -1", "VirtualTable.cs");

            T = a[i];
            a[i] = a[j];
            a[j] = T;
        }
 // QuickSort  implementation for VirtualTable
 //QuickSort (szContents, 0, RowCount - 1);
 public static void sort(VirtualTable a, int col)
 {
     QuickSortDouble(a, 0, a.RowCount - 1, col);
 }
        private void FillPhysicalTable(OdbcDataReader reader, int colCount, int rowCount)
        {
            //Resets the objects
            foreach(Node nd in Tree.NodeL)
            {
                nd.AttributeL.Clear();
                nd.Dispose();
                nd.LabelTop.Dispose();
                nd.LabelBotton.Dispose();
            }
            Tree.NodeL.Clear();
            Tree.VariableL.Clear();
            Tree.LevelBrotherL.Clear();
            Tree.LevelLast=0;
            Tree.Width = 0;
            Tree.Height = 0;
            Node.CntId=-1;
            //End resets
            //Code of the static tree constructor that must be called
            ArrayList bL = new ArrayList();
            Tree.LevelBrotherL.Add(bL);
            //end Code of the static tree constructor that must be called
            GC.Collect();
            GC.WaitForPendingFinalizers();

            FrmMain.SFrmMain.PT = new PhysicalTable(colCount , rowCount);
            int x, y;
            bool firstTime = true;
            Variable var;
            string colName="";

            grid.Rows.Count = rowCount+1;
            grid.Cols.Count = colCount+1;
            y=0;

            while(reader.Read())
            {
                grid[y+1, 0]=y;
                for(x=0; x < reader.FieldCount; ++x)
                {
                    if(firstTime)
                    {
                        colName = reader.GetName(x).ToLower();
                        grid[y, x+1] = colName;
                        if(reader[x] is double || reader[x] is int)
                        {
                            FrmMain.SFrmMain.PT.AddCol(x, colName, rowCount, PhysicalColumn.DataTypeEnum.Number);
                            var = new Variable(colName, Variable.TypeEnum.Continuous, PhysicalColumn.DataTypeEnum.Number);
                        }
                        else
                        {
                            FrmMain.SFrmMain.PT.AddCol(x, colName, rowCount, PhysicalColumn.DataTypeEnum.Text);
                            var = new Variable(colName, Variable.TypeEnum.Categorical, PhysicalColumn.DataTypeEnum.Text);
                        }
                    }
                    FrmMain.SFrmMain.PT[x, y]=reader[x];
                    grid[y+1, x+1] = reader[x];
                }
                firstTime=false;
                ++y;
            }
            grid.Visible=true;
            //			grid.Cols //Set a code to autofit the columns width

            VirtualTable virtualTable = new VirtualTable(FrmMain.SFrmMain.PT);
            Node root = new Node("All data", virtualTable);
            Tree.Root = root;
        }