evaluation.cs

用C#编写的一个款搜索engine的源代码！摘自<Visual c#2005 程序设计>

					ArrayList RefList = new ArrayList();
					for(int rank=1;rank<=this.m_CheckPoint_Ref[this.m_CheckPoint_Ref.Length-1];rank++)
					{
						if(QueryRecord.Exists(query.Words,this.m_RefEngine,rank))
							RefList.Add(QueryRecord.Load(query.Words,this.m_RefEngine,rank));
						else
							break;
					}

					//If Reference List is null, skip
					if(RefList.Count==0)
					{
						continue;
					}

					//Construct Peer List
					ArrayList PeerList = new ArrayList();
					for(int rank=1;rank<=this.m_CheckPoint_Peer[this.m_CheckPoint_Peer.Length-1];rank++)
					{
						if(QueryRecord.Exists(query.Words,this.m_PeerEngine,rank))
							PeerList.Add(QueryRecord.Load(query.Words,this.m_PeerEngine,rank));
						else
							break;
					}

					//Check Peer List to find overlaps
					//"arrRank[]" is used to record corresponding rank of RefList[i](i=1~Nr) in PeerList.
					int[] arrRank = new int[RefList.Count+1];
					foreach(QueryRecord rRecord in RefList)
					{
						bool flag = false;
						foreach(QueryRecord pRecord in PeerList)
						{
							//if URL is found, record it.
							if(  pRecord.Equals(rRecord)  )
							{
								arrRank[rRecord.Rank] = pRecord.Rank;
								flag = true;
								break;
							}
						}

						//If the record is not found, output to missing URL/Domain list.
						if(flag==false)
						{
							String Domain = MissingDomain.GetDomain(rRecord.URL);
							//Traverse ArrayList to check the Domain
							bool IsFind = false;
							foreach(MissingDomain md in MissingDomains)
							{
								if(md.Domain.Equals(Domain))
								{
									md.AddCount();
									IsFind = true;
									break;
								}
							}

							if(IsFind == false)
							{
								//If not found
								MissingDomains.Add(new MissingDomain(Domain));
							}
						}
					}
		
					//evaluate, using each CheckPoint pair
					for(int p=0;p<this.m_CheckPoint_Peer.Length;p++)
					{
						int PeerLength = this.m_CheckPoint_Peer[p];
						for(int r=0;r<this.m_CheckPoint_Ref.Length;r++)
						{
							//************Progress Status Report*****************
							this.mProcessingEntry = "Evaluating " + query.Words;
							this.mEntryPercentage = (float)q/queries.Count;
							//***************************************************
							
							int RefLength = this.m_CheckPoint_Ref[r];
							//Nr must less than Np, else skip
							if(RefLength<=PeerLength)
							{
								float score = this.Evaluate(arrRank,RefLength,PeerLength);
								if(EntryResults[p,r]==null)
									EntryResults[p,r] = new ArrayList();
								EntryResults[p,r].Add(new EntryResult(query.Words,score));
							}
						}
					}//for each check point pair
				}//for each query

				//Category Level stat
				//for each CheckPoint pair
				for(int p=0;p<this.m_CheckPoint_Peer.Length;p++)
				{
					for(int r=0;r<this.m_CheckPoint_Ref.Length;r++)
					{
						TotalScore[p,r]=0;
						TotalCount[p,r]=0;
						TotalZero [p,r]=0;
						//************Progress Status Report*****************
						this.mProcessingEntry = "Computing " + category;
						this.mEntryPercentage = (float)(p*this.m_CheckPoint_Ref.Length+r+1)/(this.m_CheckPoint_Peer.Length*this.m_CheckPoint_Ref.Length);  
						//***************************************************
						if(EntryResults[p,r]==null) 
							continue;
						foreach (EntryResult result in EntryResults[p,r])
						{
							if(result.Score.Equals(float.NaN))
							{
								TotalZero[p,r]++;   //Count of NaN
								TotalCount[p,r]++;
								TotalScore[p,r] += this.m_CheckPoint_Peer[this.m_CheckPoint_Peer.Length-1];
								continue;
							}
							if(result.Score == 0)
							{
								TotalCount[p,r]++;
								TotalZero[p,r]++;
								continue;
							}
							
							TotalScore[p,r] += result.Score;
							TotalCount[p,r]++;
						}

						OverallTotalScore[p,r] += TotalScore[p,r]/TotalCount[p,r];
					}
				}

				//****************Write Overall Report***************
				bufOverall = new StringBuilder(4096);
				bufOverall.Append("<h2 align=center>Category "+(i+1)+": "+category+"</h2><br>"
					+"<table align=center border=1>"
					+"<tr bgcolor=silver align=center>"
					+"<td>P\\R</td>");
				for(int column=0;column<this.m_CheckPoint_Ref.Length;column++)
					bufOverall.Append("<td>"+this.m_CheckPoint_Ref[column]+"</td>");
				bufOverall.Append("</tr>");
				for(int p=0;p<this.m_CheckPoint_Peer.Length;p++)
				{
					int PeerLength = this.m_CheckPoint_Peer[p];
					bufOverall.Append("<tr align=center><td bgcolor=silver>"+PeerLength+"</td>");
					for(int r=0;r<this.m_CheckPoint_Ref.Length;r++)
					{
						int RefLength = this.m_CheckPoint_Ref[r];
						//************Progress Status Report*****************
						this.mProcessingEntry = "Saving Reports... ";
						this.mEntryPercentage = (float)(p*this.m_CheckPoint_Ref.Length+r+1)/(this.m_CheckPoint_Peer.Length*this.m_CheckPoint_Ref.Length);  
						//****************Write Overall Report************
						if(RefLength<=PeerLength)
						{
							bufOverall.Append("<td>"+(TotalScore[p,r]/TotalCount[p,r]));
							if(TotalZero[p,r]>0)
								bufOverall.Append("("+TotalZero[p,r]+"/"+TotalCount[p,r]+")");
							bufOverall.Append("</td>");
						}
						else
						{
							bufOverall.Append("<td>-</td>");
						}
						//****************Write Detail  Report************
						if(RefLength<=PeerLength)
						{
							StringBuilder bufDetail = new StringBuilder(4096);
							bufDetail.Append("<h2 align=center>Category "+(i+1)+": "+category+"</h2><br>");
							bufDetail.Append("<table align=center border=1>");
							bufDetail.Append("<tr bgcolor=silver align=center><td>Query Words</td><td>Score</td></tr>");
							if(EntryResults[p,r] != null)
							{
								foreach (EntryResult result in EntryResults[p,r])
								{
									bufDetail.Append("<tr><td>"+result.Query+"</td><td>"+result.Score+"</td></tr>");
								}
							}
							bufDetail.Append("<tr bgcolor=silver><td>Category ["+category+"] Average Score</td><td>"+(TotalScore[p,r]/TotalCount[p,r])+"</td></tr>");
							bufDetail.Append("</table><br>");
							this.WriteDetailFile(RefLength,PeerLength,bufDetail.ToString());
						}
						//***************************************************
					}
					bufOverall.Append("</tr>");
				}

				//****************Write Overall Report****************	
				bufOverall.Append("</table><br>");
				this.WriteOverallFile(bufOverall.ToString());
				//***************************************************

			}//for each category file


			//****************Write Overall Report****************	
			//Overall average of all categories
			bufOverall = new StringBuilder(4096);
			bufOverall.Append("<h2 align=center>Overall Average Score</h2><br>"
				+"<table align=center border=1>"
				+"<tr bgcolor=silver align=center>"
				+"<td>P\\R</td>");
			for(int column=0;column<this.m_CheckPoint_Ref.Length;column++)
				bufOverall.Append("<td>"+this.m_CheckPoint_Ref[column]+"</td>");
			bufOverall.Append("</tr>");
			for(int p=0;p<this.m_CheckPoint_Peer.Length;p++)
			{
				int PeerLength = this.m_CheckPoint_Peer[p];
				bufOverall.Append("<tr align=center><td bgcolor=silver>"+PeerLength+"</td>");
				for(int r=0;r<this.m_CheckPoint_Ref.Length;r++)
				{
					int RefLength = this.m_CheckPoint_Ref[r];
					if(RefLength<=PeerLength)
					{
						bufOverall.Append("<td>"+(OverallTotalScore[p,r]/files.Length)+"</td>");
					}
					else
					{
						bufOverall.Append("<td>-</td>");
					}
				}
				bufOverall.Append("</tr>");
			}
			bufOverall.Append("</table><br>");
			this.WriteOverallFile(bufOverall.ToString());

			//************Progress Status Report***********
			this.mIsFinished = true;
			//*********Write Missing Domains Reports**********
			this.WriteMissingDomainReport(MissingDomains);
			//*********************************************
			
		}//end of Run()

		/// <summary>
		/// Construct path of detail report file of give reference list length and peer list length.
		/// </summary>
		/// <param name="RefLength"></param>
		/// <param name="PeerLength"></param>
		/// <returns>Path of detail report file</returns>
		private String GetDetailFilePath(int RefLength,int PeerLength)
		{
			return this.m_FileRoot
				+"\\Detail_Ref"+this.m_RefEngine+RefLength
				+"_Peer"+this.m_PeerEngine+PeerLength+".html";
		}

		/// <summary>
		/// Construct path of overall report file.
		/// </summary>
		/// <returns></returns>
		private String GetOverallFilePath()
		{
			return this.m_FileRoot
				+"\\Overall_Ref"+this.m_RefEngine
				+"_Peer"+this.m_PeerEngine+".html";		
		}

		private String GetMissingDomainFilePath()
		{
			return this.m_FileRoot
				+"\\MissingDomains_Ref"+this.m_RefEngine
				+"_Peer"+this.m_PeerEngine+".html";
		}

		/// <summary>
		/// Create detail files and write title content.
		/// </summary>
		private void CreateDetailFiles()
		{
			for(int p=0;p<this.m_CheckPoint_Peer.Length;p++)
			{
				int PeerLength = this.m_CheckPoint_Peer[p];
				
				for(int r=0;r<this.m_CheckPoint_Ref.Length;r++)
				{
					int RefLength = this.m_CheckPoint_Ref[r];

					if(RefLength<=PeerLength)
					{	
						File.Create(this.GetDetailFilePath(RefLength,PeerLength)).Close();

						this.WriteDetailFile(RefLength,PeerLength,
							"<title>" + this.m_Method.ToString() + " Evaluation(Detail)</title>"
							+@"<style type=text/css>td {align:center;font-size: 12px;}</style>"
							+@"<h1 align=center>"+ this.m_Method.ToString() +" Evaluation</h1><br>"
							+@"<p align=center>Reference Engine: "+this.m_RefEngine+"( Top "+RefLength+" )<br>"
							+@"Peer Engine: "+this.m_PeerEngine+"( Top "+PeerLength+" )</p>");
					}
				}
			}
		}

		/// <summary>
		/// Create overall files and write title content.
		/// </summary>
		private void CreateOverallFiles()
		{
			File.Create(this.GetOverallFilePath()).Close();

			this.WriteOverallFile("<title>"+ this.m_Method.ToString() +" Evaluation(Overall)</title>"
				+@"<style type=text/css>td {font-size: 12px;}</style>"
				+@"<h1 align=center>"+ this.m_Method.ToString() +" Evaluation</h1><br>"
				+@"<p align=center>Reference Engine: "+this.m_RefEngine+"<br>"
				+@"Peer Engine: "+this.m_PeerEngine+"</p>"
				+@"<p align=center>Data format in table cells: <I>score excluding not found results{(not found/total amount of queries)}</I></p>");
		}

		/// <summary>
		/// Append string to detail file.
		/// </summary>
		/// <param name="RefLength"></param>
		/// <param name="PeerLength"></param>
		/// <param name="value"></param>
		private void WriteDetailFile(int RefLength,int PeerLength,String value)
		{
			StreamWriter writer = new StreamWriter( this.GetDetailFilePath(RefLength,PeerLength),true);
			writer.Write(value);
			writer.Close();
		}

		/// <summary>
		/// Append string to overall file.
		/// </summary>
		/// <param name="value"></param>
		private void WriteOverallFile(String value)
		{
			StreamWriter writer = new StreamWriter( this.GetOverallFilePath(),true);
			writer.Write(value);
			writer.Close();
		}

		private void WriteMissingDomainReport(ArrayList MissingDomains)
		{
			File.Create(this.GetMissingDomainFilePath()).Close();
			StreamWriter writer = new StreamWriter( this.GetMissingDomainFilePath(),true);
			
			writer.Write("<title>Missing Domains</title>"
				+@"<style type=text/css>td {font-size: 12px;}</style>"
				+@"<h1 align=center>Missing Domains List</h1><br>"
				+@"<p align=center>Reference Engine: "+this.m_RefEngine+"<br>"
				+@"Peer Engine: "+this.m_PeerEngine+"</p>"
				+@"<table align=center border=1>"
				+@"<tr bgcolor=silver align=center><td>Domain Name</td><td>Missing Count</td></tr>");
			foreach(MissingDomain md in MissingDomains)
			{
				writer.Write("<tr><td>"+md.Domain+"</td><td>"+md.Count+"</td></tr>");
			}
			writer.Write("</table>");
			writer.Close();
		}

	}
}