public override Explanation Explain(int doc)
			{
				Explanation explanation = new Explanation();
				explanation.SetValue(1.0f);
				explanation.SetDescription("MatchAllDocsQuery");
				return explanation;
			}

        public virtual Explanation Explain(IndexReader indexReader, int docid, Explanation innerExplaination)
        {
            if (!(indexReader is BoboIndexReader)) throw new ArgumentException("IndexReader is not BoboIndexReader");
            BoboIndexReader reader = (BoboIndexReader)indexReader;

            Explanation exp = new Explanation();
            exp.Description = "FacetBasedBoost";

            float boost = 1.0f;
            foreach (var boostEntry in _boostMaps)
            {
                string facetName = boostEntry.Key;
                IFacetHandler handler = reader.GetFacetHandler(facetName);
                if (!(handler is IFacetScoreable))
                    throw new ArgumentException(facetName + " does not implement IFacetScoreable");

                IFacetScoreable facetScoreable = (IFacetScoreable)handler;
                BoboDocScorer scorer = facetScoreable.GetDocScorer(reader, _scoringFunctionFactory, boostEntry.Value);
                float facetBoost = scorer.Score(docid);

                Explanation facetExp = new Explanation();
                facetExp.Description = facetName;
                facetExp.Value = facetBoost;
                facetExp.AddDetail(scorer.Explain(docid));
                boost *= facetBoost;
                exp.AddDetail(facetExp);
            }
            exp.Value = boost;
            exp.AddDetail(innerExplaination);
            return exp;
        }

 public virtual Explanation Explain(int df, float boost)
 {
     Explanation expl = new Explanation();
     expl.Value = Score(df, boost);
     expl.Description = "facet boost value of: " + boost;
     return expl;
 }

 public virtual Explanation Explain(IndexReader reader, int doc, Explanation innerExplanation)
 {
     if (reader is BoboIndexReader)
     {
         BoboIndexReader boboReader = (BoboIndexReader)reader;
         object dataObj = boboReader.GetFacetData(_timeFacetName);
         if (dataObj is FacetDataCache)
         {
             FacetDataCache facetDataCache = (FacetDataCache)(boboReader.GetFacetData(_timeFacetName));
             BigSegmentedArray orderArray = facetDataCache.OrderArray;
             TermLongList termList = (TermLongList)facetDataCache.ValArray;
             long now = System.Environment.TickCount;
             Explanation finalExpl = new Explanation();
             finalExpl.AddDetail(innerExplanation);
             float rawScore = innerExplanation.Value;
             long timeVal = termList.GetPrimitiveValue(orderArray.Get(doc));
             float timeScore = ComputeTimeFactor(timeVal);
             float finalScore = CombineScores(timeScore, rawScore);
             finalExpl.Value = finalScore;
             finalExpl.Description = "final score = (time score: " + timeScore + ") * (raw score: " + rawScore + "), timeVal: " + timeVal;
             return finalExpl;
         }
         else
         {
             throw new InvalidOperationException("underlying facet data must be of type FacetDataCache<long>");
         }
     }
     else
     {
         throw new ArgumentException("reader not instance of " + typeof(BoboIndexReader));
     }
 }

            public override Explanation Explain(IndexReader reader, int doc)
            {
                Explanation result = new Explanation();
                result.Value = _weight;
                result.Description = _parent.ToString();

                return result;
            }

 /// <summary>Explain the score of a document.</summary>
 /// <todo>  Also show the total score. </todo>
 /// <summary> See BooleanScorer.explain() on how to do this.
 /// </summary>
 public override Explanation Explain(int doc)
 {
     Explanation res = new Explanation();
     res.SetDescription("required, optional");
     res.AddDetail(reqScorer.Explain(doc));
     res.AddDetail(optScorer.Explain(doc));
     return res;
 }

 public virtual Explanation Explain(params float[] scores)
 {
     float sum = 0.0f;
     foreach (float score in scores)
     {
         sum += score;
     }
     Explanation expl = new Explanation(sum, "sum of: " + Arrays.ToString(scores));
     return expl;
 }

		public override Explanation Explain(IndexReader reader, int doc)
		{
			
			ComplexExplanation result = new ComplexExplanation();
			result.SetDescription("weight(" + GetQuery() + " in " + doc + "), product of:");
			System.String field = ((SpanQuery) GetQuery()).GetField();
			
			Explanation idfExpl = new Explanation(idf, "idf(" + field + ": " + idfExp.Explain() + ")");
			
			// explain query weight
			Explanation queryExpl = new Explanation();
			queryExpl.SetDescription("queryWeight(" + GetQuery() + "), product of:");
			
			Explanation boostExpl = new Explanation(GetQuery().GetBoost(), "boost");
			if (GetQuery().GetBoost() != 1.0f)
				queryExpl.AddDetail(boostExpl);
			queryExpl.AddDetail(idfExpl);
			
			Explanation queryNormExpl = new Explanation(queryNorm, "queryNorm");
			queryExpl.AddDetail(queryNormExpl);
			
			queryExpl.SetValue(boostExpl.GetValue() * idfExpl.GetValue() * queryNormExpl.GetValue());
			
			result.AddDetail(queryExpl);
			
			// explain field weight
			ComplexExplanation fieldExpl = new ComplexExplanation();
			fieldExpl.SetDescription("fieldWeight(" + field + ":" + query.ToString(field) + " in " + doc + "), product of:");
			
			Explanation tfExpl = Scorer(reader, true, false).Explain(doc);
			fieldExpl.AddDetail(tfExpl);
			fieldExpl.AddDetail(idfExpl);
			
			Explanation fieldNormExpl = new Explanation();
			byte[] fieldNorms = reader.Norms(field);
			float fieldNorm = fieldNorms != null?Similarity.DecodeNorm(fieldNorms[doc]):1.0f;
			fieldNormExpl.SetValue(fieldNorm);
			fieldNormExpl.SetDescription("fieldNorm(field=" + field + ", doc=" + doc + ")");
			fieldExpl.AddDetail(fieldNormExpl);
			
			fieldExpl.SetMatch(tfExpl.IsMatch());
			fieldExpl.SetValue(tfExpl.GetValue() * idfExpl.GetValue() * fieldNormExpl.GetValue());
			
			result.AddDetail(fieldExpl);
			System.Boolean? tempAux = fieldExpl.GetMatch();
			result.SetMatch(tempAux);
			
			// combine them
			result.SetValue(queryExpl.GetValue() * fieldExpl.GetValue());
			
			if (queryExpl.GetValue() == 1.0f)
				return fieldExpl;
			
			return result;
		}

        public ExplanationDialog(Explanation e)
        {
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            treeExplain.BeginUpdate();
            AddNode(null, e);
            treeExplain.ExpandAll();
            treeExplain.EndUpdate();
        }

 public virtual Explanation Explain(params float[] scores)
 {
     Explanation expl = new Explanation();
     float boost = 1.0f;
     foreach (float score in scores)
     {
         boost *= score;
     }
     expl.Value = boost;
     expl.Description = "product of: " + Arrays.ToString(scores);
     return expl;
 }

 public override Explanation Explain(int doc)
 {
     Explanation res = new Explanation();
     if (exclScorer.SkipTo(doc) && (exclScorer.Doc() == doc))
     {
         res.SetDescription("excluded");
     }
     else
     {
         res.SetDescription("not excluded");
         res.AddDetail(reqScorer.Explain(doc));
     }
     return res;
 }

        public override Explanation Explain(int doc)
        {
            Explanation tfExplanation = new Explanation();

            while (Next() && Doc() < doc)
            {
            }

            float phraseFreq = (Doc() == doc)?freq:0.0f;
            tfExplanation.SetValue(GetSimilarity().Tf(phraseFreq));
            tfExplanation.SetDescription("tf(phraseFreq=" + phraseFreq + ")");

            return tfExplanation;
        }

			public override Explanation Explain(int doc)
			{
				// make sure it has minX and area
				if (validMinX.Get(doc) && validMaxX.Get(doc))
				{
					Rectangle rect = new RectangleImpl(
						minX[doc], maxX[doc],
						minY[doc], maxY[doc]);
					var exp = new Explanation();
					_enclosingInstance.similarity.Score(rect, exp);
					return exp;
				}
				return new Explanation(0, "No BBox");
			}

 public override Explanation Explain(IndexSearcher searcher, Explanation firstPassExplanation, int docID)
 {
     Explanation result = base.Explain(searcher, firstPassExplanation, docID);
     IList<AtomicReaderContext> leaves = searcher.IndexReader.Leaves;
     int subReader = ReaderUtil.SubIndex(docID, leaves);
     AtomicReaderContext readerContext = leaves[subReader];
     int docIDInSegment = docID - readerContext.DocBase;
     var context = new Dictionary<string, object>();
     var fakeScorer = new FakeScorer { score = firstPassExplanation.Value, doc = docIDInSegment };
     context["scorer"] = fakeScorer;
     foreach (string variable in expression.variables)
     {
         result.AddDetail(new Explanation((float)bindings.GetValueSource(variable).GetValues
             (context, readerContext).DoubleVal(docIDInSegment), "variable \"" + variable + "\""
             ));
     }
     return result;
 }

 public double Score(Rectangle indexRect, Explanation exp)
 {
     double score;
     if (indexRect == null)
     {
         score = nullValue;
     }
     else
     {
         score = distCalc.Distance(queryPoint, indexRect.GetCenter());
     }
     if (exp != null)
     {
         exp.Value = (float) score;
         exp.Description = GetType().Name;
         exp.AddDetail(new Explanation(-1f, "" + queryPoint));
         exp.AddDetail(new Explanation(-1f, "" + indexRect));
     }
     return score;
 }

        private void AddNode(TreeNode tn, Explanation e)
        {
            TreeNode node = new TreeNode(e.GetValue().ToString("G4") + "  " + e.GetDescription());

            if (null == tn)
            {
                treeExplain.Nodes.Add(node);
            }
            else
            {
                tn.Nodes.Add(node);
            }

            Explanation[] kids = e.GetDetails();
            if (kids != null && kids.Length > 0)
            {
                for (int i = 0; i < kids.Length; i++)
                {
                    AddNode(node, kids[i]);
                }
            }
        }

 public override Explanation CustomExplain(int doc, Explanation subQueryExpl, Explanation[] valSrcExpls)
 {
     if (valSrcExpls.Length == 0)
     {
         return subQueryExpl;
     }
     Explanation exp = new Explanation(valSrcExpls[0].Value + subQueryExpl.Value, "sum of:");
     exp.AddDetail(subQueryExpl);
     exp.AddDetail(valSrcExpls[0]);
     if (valSrcExpls.Length == 1)
     {
         exp.Description = "CustomMulAdd, sum of:";
         return exp;
     }
     Explanation exp2 = new Explanation(valSrcExpls[1].Value * exp.Value, "custom score: product of:");
     exp2.AddDetail(valSrcExpls[1]);
     exp2.AddDetail(exp);
     return exp2;
 }

	    /// <summary>Adds a sub-node to this explanation node. </summary>
		public virtual void  AddDetail(Explanation detail)
		{
			if (details == null)
				details = new List<Explanation>();
			details.Add(detail);
		}

 /// <summary>Adds a sub-node to this explanation node. </summary>
 public virtual void AddDetail(Explanation detail)
 {
     if (details == null)
         details = new System.Collections.ArrayList();
     details.Add(detail);
 }

			public virtual Explanation Explain(IndexReader reader, int doc)
			{
				
				Explanation result = new Explanation();
				result.SetDescription("weight(" + GetQuery() + " in " + doc + "), product of:");
				
				System.Text.StringBuilder docFreqs = new System.Text.StringBuilder();
				System.Text.StringBuilder query = new System.Text.StringBuilder();
				query.Append('\"');
				for (int i = 0; i < Enclosing_Instance.terms.Count; i++)
				{
					if (i != 0)
					{
						docFreqs.Append(" ");
						query.Append(" ");
					}
					
					Term term = (Term) Enclosing_Instance.terms[i];
					
					docFreqs.Append(term.Text());
					docFreqs.Append("=");
					docFreqs.Append(reader.DocFreq(term));
					
					query.Append(term.Text());
				}
				query.Append('\"');
				
				Explanation idfExpl = new Explanation(idf, "idf(" + Enclosing_Instance.field + ": " + docFreqs + ")");
				
				// explain query weight
				Explanation queryExpl = new Explanation();
				queryExpl.SetDescription("queryWeight(" + GetQuery() + "), product of:");
				
				Explanation boostExpl = new Explanation(Enclosing_Instance.GetBoost(), "boost");
				if (Enclosing_Instance.GetBoost() != 1.0f)
					queryExpl.AddDetail(boostExpl);
				queryExpl.AddDetail(idfExpl);
				
				Explanation queryNormExpl = new Explanation(queryNorm, "queryNorm");
				queryExpl.AddDetail(queryNormExpl);
				
				queryExpl.SetValue(boostExpl.GetValue() * idfExpl.GetValue() * queryNormExpl.GetValue());
				
				result.AddDetail(queryExpl);
				
				// explain field weight
				Explanation fieldExpl = new Explanation();
				fieldExpl.SetDescription("fieldWeight(" + Enclosing_Instance.field + ":" + query + " in " + doc + "), product of:");
				
				Explanation tfExpl = Scorer(reader).Explain(doc);
				fieldExpl.AddDetail(tfExpl);
				fieldExpl.AddDetail(idfExpl);
				
				Explanation fieldNormExpl = new Explanation();
				byte[] fieldNorms = reader.Norms(Enclosing_Instance.field);
				float fieldNorm = fieldNorms != null ? Similarity.DecodeNorm(fieldNorms[doc]) : 0.0f;
				fieldNormExpl.SetValue(fieldNorm);
				fieldNormExpl.SetDescription("fieldNorm(field=" + Enclosing_Instance.field + ", doc=" + doc + ")");
				fieldExpl.AddDetail(fieldNormExpl);
				
				fieldExpl.SetValue(tfExpl.GetValue() * idfExpl.GetValue() * fieldNormExpl.GetValue());
				
				result.AddDetail(fieldExpl);
				
				// combine them
				result.SetValue(queryExpl.GetValue() * fieldExpl.GetValue());
				
				if (queryExpl.GetValue() == 1.0f)
					return fieldExpl;
				
				return result;
			}