database.cs

一个经典的apriori算法（c#实现）

			/// <summary>
			/// Adds an itemset to the itemset table.
			/// </summary>
			/// <param name="itemSet">
			/// The set of items to be added as a comma seperated string.
			/// </param>
			/// <param name="itemsetLevel">
			/// The hierarchy of the itemset in the market based analysis.
			/// </param>
			/// <param name="supportCount">
			/// The number of transactions in the APriori ADO.NET database that contain the itemset.
			/// </param>
			/// <returns>
			/// Returns an ADO.NET DataRow.
			/// </returns>
			public DataRow AddItemset(string itemSet, int itemsetLevel, int supportCount)
			{
				DataRow myDataRow;
 

				myDataRow = this.myTransactions.Tables["ItemsetTable"].NewRow();


				myDataRow["Itemset"] = itemSet;

				myDataRow["Level"] = itemsetLevel;

				myDataRow["SupportCount"] = supportCount;


				this.myTransactions.Tables["ItemsetTable"].Rows.Add(myDataRow);

				return myDataRow;

			}

		
			/// <summary>
			/// Retrieves a datarow containing a set of items from the APriori database. 
			/// </summary>
			/// <param name="itemSet">
			/// The exact set of comma seperated items to search for in the Market Based Analysis Database.
			/// </param>
			/// <returns>
			/// Returns an array of DataRow elements containing rows that match the itemSet parameter.
			/// </returns>
			public DataRow [] GetItemset(string itemSet)
			{
				int length = 0;


				DataView myDataView = new DataView(this.myTransactions.Tables["ItemsetTable"]);


				myDataView.Sort = "Itemset";


				DataRowView [] found = myDataView.FindRows(itemSet);


				length = found.Length;


				DataRow [] myDataRow = new DataRow[length];
				
			
				for(int count = 0; count < length; count++)
				{
					myDataRow[count] = found[count].Row;				
				}

				return myDataRow;
			
			}

		
			/// <summary>
			/// Retrieves a DataRow containing the itemset passed to it.
			/// </summary>
			/// <param name="itemSet">
			/// An ItemsetArrayList class to retrieve from the database.
			/// </param>
			/// <returns>
			/// A System.Data.DataRow object containing an itemset.
			/// </returns>
			public DataRow [] GetItemset(ItemsetArrayList itemSet)
			{
				int length = 0;

				string find = ItemsetArrayList.ConvertToString(itemSet, ",");


				DataView myDataView = new DataView(this.myTransactions.Tables[1]);


				myDataView.Sort = "Itemset";


				DataRowView [] found = myDataView.FindRows(find);


				length = found.Length;


				DataRow [] myDataRow = new DataRow[length];
				
			
				for(int count = 0; count < length; count++)
				{
					myDataRow[count] = found[count].Row;				
				}

				return myDataRow;
			
			}

		
		
			/// <summary>
			/// Retrieves an ItemsetArrayList array of frequent itemsets. 
			/// </summary>
			/// <param name="rowFilter">
			/// The minimum support count expression used in filtering itemsets.
			/// </param>
			/// <param name="sortColumn">
			/// The table column used to sort and index the itemsets.
			/// </param>
			/// <returns>
			/// An ItemsetArrayList collection containing the collection of itemsets with the minimum support count.
			/// </returns>
			public ItemsetArrayList [] GetItemset(string rowFilter, string sortColumn)
			{

				int length = 0;

				ItemsetArrayList [] items;

				DataView myDataView = new DataView(this.myTransactions.Tables["ItemsetTable"],rowFilter,sortColumn,												DataViewRowState.CurrentRows);


				DataRow [] found = this.myTransactions.Tables["ItemsetTable"].Select(rowFilter,sortColumn);

				length = found.Length;


				items = new ItemsetArrayList[length];
				
			
				for(int count = 0; count < length; count++)
				{
					items[count] = new ItemsetArrayList(1);
			
					items[count].Add(ItemsetArrayList.ConvertToItemsetArrayList((string) (found[count]["Itemset"]),new Char[] {','}));
				
					items[count].Level = (int) found[count]["Level"];

					items[count].SupportCount = (int) found[count]["SupportCount"];

					items[count].TrimToSize();
				}

				return items;
			
			}

		
			/// <summary>
			/// Retrieves the primary keys of the itemsets passed as a parameter to it.
			/// </summary>
			/// <param name="itemSet">
			/// The ArrayListItemset class to retrieve the PrimaryID for.
			/// </param>
			/// <param name="primaryKeyName">
			/// The name of the primary key column.
			/// </param>
			/// <returns>
			/// An integer value representing the primary key column.
			/// </returns>
			public int [] GetItemset(ItemsetArrayList itemSet, string primaryKeyName)
			{
				int length = 0;

				int [] primaryKey;

				string find = ItemsetArrayList.ConvertToString(itemSet, ",");


				DataView myDataView = new DataView(this.myTransactions.Tables["ItemsetTable"]);


				myDataView.Sort = "Itemset";			
			

				DataRowView [] found = myDataView.FindRows(find);


				length = found.Length;
			
			
				primaryKey = new int[length];
				
			
				for(int count = 0; count < length; count++)
				{
					primaryKey[count] = (int) found[count].Row[primaryKeyName];				
				}

				return primaryKey;
			
			}

		
			/// <summary>
			/// Adds a subset of an itemset to the Subset table.
			/// </summary>
			/// <param name="itemSet">
			/// An ItemsetArrayList to add to the Subset table.
			/// </param>
			/// <param name="subSet">
			/// The subset of items added to the database.
			/// </param>
			/// <returns>
			/// The Primary Key of the subset added to the Subset table.
			/// </returns>
			public int AddSubset(ItemsetArrayList itemSet, ItemsetArrayList subSet)
			{
				int keyID = 0;

				int [] itemID = this.GetItemset(itemSet,"ItemID");

			
				//Convert the ItemsetArrayList to a string
				string subset = ItemsetArrayList.ConvertToString(subSet, ItemsetArrayList.CommaOnly);
		
				DataRow [] mySubsetRows = this.GetItemset(subset);


				if(mySubsetRows.Length !=0)
				{

					int subsetID = (int) mySubsetRows[0][0];

			
					DataRow myDataRow = this.myTransactions.Tables["SubsetTable"].NewRow();

			
					//Only one row will actually be returned because each itemset is added only once to the itemset table
					myDataRow["ItemID"] = itemID[0];
			
					//Only one row will actually be returned because each itemset is added only once to the itemset table
					myDataRow["SubsetID"] = subsetID;

			
					this.myTransactions.Tables["SubsetTable"].Rows.Add(myDataRow);

					keyID = (int) myDataRow["FirstKeyID"];

				}

				else
				{
					keyID = 1;

				}

				return keyID;

			}

		
			/// <summary>
			/// Adds a market based analysis association rule to the rules table.
			/// </summary>
			/// <param name="parentRuleset">
			/// The set of frequent items for which rules are derived.
			/// </param>
			/// <param name="leftRuleset">
			/// The set of items on the left side of an association rule.
			/// </param>
			/// <param name="rightRuleset">
			/// The set of items on the right side of an association rule.
			/// </param>
			/// <returns>
			/// A System.Data.DataRow object containing the rule added to the database.
			/// </returns>
			public DataRow AddRuleset(ItemsetArrayList parentRuleset, ItemsetArrayList leftRuleset, ItemsetArrayList											rightRuleset)
			{
			
				int leftColumnID = 0;

				int rightColumnID = 0;

				double upperNumber = 0;

				double lowerNumber = 0;

				double confidence = 0.0;

				string rowFilter;

				string sortColumn;
			
				DataRow [] found;
            

				DataRow [] leftDataRow = this.GetItemset(leftRuleset);

				DataRow [] rightDataRow = this.GetItemset(rightRuleset);

				DataRow [] parentDataRow = this.GetItemset(parentRuleset);


				//Only one row of data will be returned as each item is unique in the database
				DataRow myDataRow = this.myTransactions.Tables["RulesTable"].NewRow();

			
				leftColumnID = (int) leftDataRow[0]["ItemID"];

				rightColumnID = (int) rightDataRow[0]["ItemID"];


				rowFilter = "LeftRule = " + leftColumnID + " AND rightRule = " + rightColumnID;

				sortColumn = "leftRule, rightRule";


				//DataView myDataView = new DataView(this.myTransactions.Tables["RulesTable"],rowFilter,sortColumn,												DataViewRowState.CurrentRows);


				found = this.myTransactions.Tables["RulesTable"].Select(rowFilter,sortColumn);

			
				//only add unique data rows
				if (found.Length == 0)
				{
					myDataRow["LeftRule"] = leftColumnID;

					myDataRow["RightRule"] = rightColumnID;


					//Calculate the confidence for each number
					upperNumber = (int)parentDataRow[0]["SupportCount"];

					lowerNumber = (int)leftDataRow[0]["SupportCount"];


					confidence = Convert.ToDouble((upperNumber / lowerNumber));


					//Add the confidence value for the rule to the data row
					myDataRow["Confidence"] = confidence;
			

					this.myTransactions.Tables["RulesTable"].Rows.Add(myDataRow);
				}

				return myDataRow;
			

			}

		}
	}

}