public override NumericDocValues GetNormValues(string field)
{
FieldInfo fieldInfo;
if (!outerInstance.fieldInfos.TryGetValue(field, out fieldInfo) || fieldInfo.OmitsNorms())
{
return(null);
}
NumericDocValues norms = cachedNormValues;
Similarity sim = Similarity;
if (!field.Equals(cachedFieldName) || sim != cachedSimilarity) // not cached?
{
Info info = GetInfo(field);
int numTokens = info != null ? info.numTokens : 0;
int numOverlapTokens = info != null ? info.numOverlapTokens : 0;
float boost = info != null ? info.Boost : 1.0f;
FieldInvertState invertState = new FieldInvertState(field, 0, numTokens, numOverlapTokens, 0, boost);
long value = sim.ComputeNorm(invertState);
norms = new MemoryIndexNormDocValues(value);
// cache it for future reuse
cachedNormValues = norms;
cachedFieldName = field;
cachedSimilarity = sim;
#if DEBUG
Debug.WriteLine("MemoryIndexReader.norms: " + field + ":" + value + ":" + numTokens);
#endif
}
return(norms);
}
public override byte[] Norms(String fieldName)
{
byte[] norms = cachedNorms;
Similarity sim = GetSimilarity();
if (fieldName != cachedFieldName || sim != cachedSimilarity)
{
// not cached?
Info info = GetInfo(fieldName);
int numTokens = info != null ? info.NumTokens : 0;
int numOverlapTokens = info != null ? info.NumOverlapTokens : 0;
float boost = info != null ? info.Boost : 1.0f;
FieldInvertState invertState = new FieldInvertState(0, numTokens, numOverlapTokens, 0, boost);
float n = sim.ComputeNorm(fieldName, invertState);
byte norm = Similarity.EncodeNorm(n);
norms = new byte[] { norm };
// cache it for future reuse
cachedNorms = norms;
cachedFieldName = fieldName;
cachedSimilarity = sim;
if (DEBUG)
{
System.Diagnostics.Debug.WriteLine("MemoryIndexReader.norms: " + fieldName + ":" + n + ":" +
norm + ":" + numTokens);
}
}
return(norms);
}
//
// Summary:
// Implemented as state.getBoost()*lengthNorm(numTerms), where numTerms is Lucene.Net.Index.FieldInvertState.Length
// if Lucene.Net.Search.DefaultSimilarity.DiscountOverlaps is false, else it's Lucene.Net.Index.FieldInvertState.Length
// - Lucene.Net.Index.FieldInvertState.NumOverlap . WARNING: This API is new and
// experimental, and may suddenly change.
public override float ComputeNorm(string field, FieldInvertState state)
{
float v = base.ComputeNorm(field, state);
DebugMsg($"=====> ComputeNorm : field({field}), state({state}), out({v})");
return(v);
}
public override long ComputeNorm(FieldInvertState state)
{
if (state.Name.Equals(NORMS_FIELD))
{
return(Number.FloatToIntBits(state.Boost));
}
else
{
return(@in.ComputeNorm(state));
}
}
public override long ComputeNorm(FieldInvertState state)
{
if (state.Name.Equals(NORMS_FIELD, StringComparison.Ordinal))
{
return(Number.SingleToInt32Bits(state.Boost));
}
else
{
return(@in.ComputeNorm(state));
}
}
/// <summary>
/// Implemented as
/// <c>state.Boost * LengthNorm(numTerms)</c>, where
/// <c>numTerms</c> is <see cref="FieldInvertState.Length"/> if
/// <see cref="DiscountOverlaps"/> is <c>false</c>, else it's
/// <see cref="FieldInvertState.Length"/> -
/// <see cref="FieldInvertState.NumOverlap"/>.
///
/// <para/>
/// @lucene.experimental
/// </summary>
public override float LengthNorm(FieldInvertState state)
{
int numTerms;
if (m_discountOverlaps)
{
numTerms = state.Length - state.NumOverlap;
}
else
{
numTerms = state.Length;
}
return state.Boost * ((float)(1.0 / Math.Sqrt(numTerms)));
}
/// <summary>Implemented as
/// <c>state.getBoost()*lengthNorm(numTerms)</c>, where
/// <c>numTerms</c> is <see cref="FieldInvertState.Length" /> if <see cref="DiscountOverlaps" />
/// is false, else it's <see cref="FieldInvertState.Length" />
/// - <see cref="FieldInvertState.NumOverlap" />
///.
///
/// <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
/// change.<p/>
/// </summary>
public override float ComputeNorm(System.String field, FieldInvertState state)
{
int numTerms;
if (internalDiscountOverlaps)
{
numTerms = state.Length - state.NumOverlap;
}
else
{
numTerms = state.Length;
}
return(state.Boost * LengthNorm(field, numTerms));
}
/// <summary>
/// Implemented as
/// <c>
/// state.Boost * ComputeLengthNorm(numTokens)
/// </c>
/// where numTokens does not count overlap tokens if
/// discountOverlaps is true by default or true for this
/// specific field.
/// </summary>
public override float LengthNorm(FieldInvertState state)
{
int numTokens;
if (DiscountOverlaps)
{
numTokens = state.Length - state.NumOverlap;
}
else
{
numTokens = state.Length;
}
return(state.Boost * ComputeLengthNorm(numTokens));
}
/// <summary>
/// Implemented as <code> state.getBoost() *
/// computeLengthNorm(numTokens) </code> where
/// numTokens does not count overlap tokens if
/// discountOverlaps is true by default or true for this
/// specific field.
/// </summary>
public override float lengthNorm(FieldInvertState state)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int numTokens;
int numTokens;
if (discountOverlaps)
{
numTokens = state.Length - state.NumOverlap;
}
else
{
numTokens = state.Length;
}
return(state.Boost * computeLengthNorm(numTokens));
}
public virtual void TestDiscountOverlapsBoost()
{
DefaultSimilarity expected = new DefaultSimilarity();
SimilarityBase actual = new DFRSimilarity(new BasicModelIne(), new AfterEffectB(), new NormalizationH2());
expected.DiscountOverlaps = false;
actual.DiscountOverlaps = false;
FieldInvertState state = new FieldInvertState("foo");
state.Length = 5;
state.NumOverlap = 2;
state.Boost = 3;
Assert.AreEqual(expected.ComputeNorm(state), actual.ComputeNorm(state));
expected.DiscountOverlaps = true;
actual.DiscountOverlaps = true;
Assert.AreEqual(expected.ComputeNorm(state), actual.ComputeNorm(state));
}
public override long ComputeNorm(FieldInvertState state)
{
if (state.Name.Equals(NORMS_FIELD))
{
return Number.FloatToIntBits(state.Boost);
}
else
{
return @in.ComputeNorm(state);
}
}
public void TestSweetSpotComputeNorm()
{
SweetSpotSimilarity ss = new SweetSpotSimilarity();
ss.SetLengthNormFactors(1, 1, 0.5f, true);
Similarity d = new DefaultSimilarity();
Similarity s = ss;
// base case, should degrade
FieldInvertState invertState = new FieldInvertState("bogus");
invertState.Boost = 1.0f;
for (int i = 1; i < 1000; i++)
{
invertState.Length = i;
assertEquals("base case: i=" + i,
ComputeAndGetNorm(d, invertState),
ComputeAndGetNorm(s, invertState),
0.0f);
}
// make a sweet spot
ss.SetLengthNormFactors(3, 10, 0.5f, true);
for (int i = 3; i <= 10; i++)
{
invertState.Length = i;
assertEquals("3,10: spot i=" + i,
1.0f,
ComputeAndDecodeNorm(ss, ss, invertState),
0.0f);
}
for (int i = 10; i < 1000; i++)
{
invertState.Length = (i - 9);
byte normD = ComputeAndGetNorm(d, invertState);
invertState.Length = i;
byte normS = ComputeAndGetNorm(s, invertState);
assertEquals("3,10: 10<x : i=" + i,
normD,
normS,
0.0f);
}
// separate sweet spot for certain fields
SweetSpotSimilarity ssBar = new SweetSpotSimilarity();
ssBar.SetLengthNormFactors(8, 13, 0.5f, false);
SweetSpotSimilarity ssYak = new SweetSpotSimilarity();
ssYak.SetLengthNormFactors(6, 9, 0.5f, false);
SweetSpotSimilarity ssA = new SweetSpotSimilarity();
ssA.SetLengthNormFactors(5, 8, 0.5f, false);
SweetSpotSimilarity ssB = new SweetSpotSimilarity();
ssB.SetLengthNormFactors(5, 8, 0.1f, false);
Similarity sp = new PerFieldSimilarityWrapperHelper(ssBar, ssYak, ssA, ssB, ss);
invertState = new FieldInvertState("foo");
invertState.Boost = 1.0f;
for (int i = 3; i <= 10; i++)
{
invertState.Length = i;
assertEquals("f: 3,10: spot i=" + i,
1.0f,
ComputeAndDecodeNorm(ss, sp, invertState),
0.0f);
}
for (int i = 10; i < 1000; i++)
{
invertState.Length = (i - 9);
byte normD = ComputeAndGetNorm(d, invertState);
invertState.Length = (i);
byte normS = ComputeAndGetNorm(sp, invertState);
assertEquals("f: 3,10: 10<x : i=" + i,
normD,
normS,
0.0f);
}
invertState = new FieldInvertState("bar");
invertState.Boost = (1.0f);
for (int i = 8; i <= 13; i++)
{
invertState.Length = (i);
assertEquals("f: 8,13: spot i=" + i,
1.0f,
ComputeAndDecodeNorm(ss, sp, invertState),
0.0f);
}
invertState = new FieldInvertState("yak");
invertState.Boost = (1.0f);
for (int i = 6; i <= 9; i++)
{
invertState.Length = (i);
assertEquals("f: 6,9: spot i=" + i,
1.0f,
ComputeAndDecodeNorm(ss, sp, invertState),
0.0f);
}
invertState = new FieldInvertState("bar");
invertState.Boost = (1.0f);
for (int i = 13; i < 1000; i++)
{
invertState.Length = (i - 12);
byte normD = ComputeAndGetNorm(d, invertState);
invertState.Length = (i);
byte normS = ComputeAndGetNorm(sp, invertState);
assertEquals("f: 8,13: 13<x : i=" + i,
normD,
normS,
0.0f);
}
invertState = new FieldInvertState("yak");
invertState.Boost = (1.0f);
for (int i = 9; i < 1000; i++)
{
invertState.Length = (i - 8);
byte normD = ComputeAndGetNorm(d, invertState);
invertState.Length = (i);
byte normS = ComputeAndGetNorm(sp, invertState);
assertEquals("f: 6,9: 9<x : i=" + i,
normD,
normS,
0.0f);
}
// steepness
for (int i = 9; i < 1000; i++)
{
invertState = new FieldInvertState("a");
invertState.Boost = (1.0f);
invertState.Length = (i);
byte normSS = ComputeAndGetNorm(sp, invertState);
invertState = new FieldInvertState("b");
invertState.Boost = (1.0f);
invertState.Length = (i);
byte normS = ComputeAndGetNorm(sp, invertState);
assertTrue("s: i=" + i + " : a=" + normSS +
" < b=" + normS,
normSS < normS);
}
}
public override float LengthNorm(FieldInvertState state)
{
// Disable length norm
return(state.Boost);
}
public override sealed long ComputeNorm(FieldInvertState state)
{
float normValue = LengthNorm(state);
return(EncodeNormValue(normValue));
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//Make everything else 1 so we see the effect of the payload
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
public override float LengthNorm(FieldInvertState state)
{
return(state.Boost);
}
/// <summary> /// Computes the normalization value for a field, given the accumulated /// state of term processing for this field (see <see cref="FieldInvertState"/>). /// /// <para/>Matches in longer fields are less precise, so implementations of this /// method usually set smaller values when <c>state.Length</c> is large, /// and larger values when <code>state.Length</code> is small. /// <para/> /// @lucene.experimental /// </summary> /// <param name="state"> current processing state for this field </param> /// <returns> computed norm value </returns> public abstract long ComputeNorm(FieldInvertState state);
public override float ComputeNorm(System.String field, FieldInvertState state)
{
return(state.Boost);
}
override public float LengthNorm(FieldInvertState state)
{
return(base.LengthNorm(state));
}
public override float ComputeNorm(string field, FieldInvertState state)
{
// using the original formula for calculating the norm
return(base.ComputeNorm(field, state));
}
public override sealed long ComputeNorm(FieldInvertState state)
{
return(Get(state.Name).ComputeNorm(state));
}
/// <summary>
/// Implemented as
/// <code>state.getBoost()*lengthNorm(numTerms)</code>, where
/// <code>numTerms</code> is <seealso cref="FieldInvertState#getLength()"/> if {@link
/// #setDiscountOverlaps} is false, else it's {@link
/// FieldInvertState#getLength()} - {@link
/// FieldInvertState#getNumOverlap()}.
///
/// @lucene.experimental
/// </summary>
public override float LengthNorm(FieldInvertState state)
{
int numTerms;
if (DiscountOverlaps_Renamed)
{
numTerms = state.Length - state.NumOverlap;
}
else
{
numTerms = state.Length;
}
return state.Boost * ((float)(1.0 / Math.Sqrt(numTerms)));
}
public override sealed long ComputeNorm(FieldInvertState state)
{
int numTerms = discountOverlaps ? state.Length - state.NumOverlap : state.Length;
return(EncodeNormValue(state.Boost, numTerms));
}
public override long ComputeNorm(FieldInvertState state)
{
return(Sim.ComputeNorm(state));
}
/// <summary> Compute the normalization value for a field, given the accumulated
/// state of term processing for this field (see <see cref="FieldInvertState" />).
///
/// <p/>Implementations should calculate a float value based on the field
/// state and then return that value.
///
/// <p/>For backward compatibility this method by default calls
/// <see cref="LengthNorm(String, int)" /> passing
/// <see cref="FieldInvertState.Length" /> as the second argument, and
/// then multiplies this value by <see cref="FieldInvertState.Boost" />.<p/>
///
/// <p/><b>WARNING</b>: This API is new and experimental and may
/// suddenly change.<p/>
///
/// </summary>
/// <param name="field">field name
/// </param>
/// <param name="state">current processing state for this field
/// </param>
/// <returns> the calculated float norm
/// </returns>
public virtual float ComputeNorm(System.String field, FieldInvertState state)
{
return((float)(state.Boost * LengthNorm(field, state.Length)));
}
public override long ComputeNorm(FieldInvertState state)
{
throw new NotSupportedException(UNSUPPORTED_MSG);
}
public override long ComputeNorm(FieldInvertState state)
{
return(1); // we dont care
}
public override float ComputeNorm(System.String field, FieldInvertState state)
{
return((float)(1.0));
}
public override long ComputeNorm(FieldInvertState state)
{
return(m_sims[0].ComputeNorm(state));
}
public override float LengthNorm(FieldInvertState state)
{
return(10f);
}
public static float ComputeAndDecodeNorm(SweetSpotSimilarity decode, Similarity encode, FieldInvertState state)
{
return(decode.DecodeNormValue(ComputeAndGetNorm(encode, state)));
}
/// <summary> /// Compute an index-time normalization value for this field instance. /// <para/> /// This value will be stored in a single byte lossy representation by /// <see cref="EncodeNormValue(float)"/>. /// </summary> /// <param name="state"> Statistics of the current field (such as length, boost, etc) </param> /// <returns> An index-time normalization value </returns> public abstract float LengthNorm(FieldInvertState state);
public static byte ComputeAndGetNorm(Similarity s, FieldInvertState state)
{
return((byte)s.ComputeNorm(state));
}
public virtual void TestDiscountOverlapsBoost()
{
DefaultSimilarity expected = new DefaultSimilarity();
SimilarityBase actual = new DFRSimilarity(new BasicModelIne(), new AfterEffectB(), new NormalizationH2());
expected.DiscountOverlaps = false;
actual.DiscountOverlaps = false;
FieldInvertState state = new FieldInvertState("foo");
state.Length = 5;
state.NumOverlap = 2;
state.Boost = 3;
Assert.AreEqual(expected.ComputeNorm(state), actual.ComputeNorm(state));
expected.DiscountOverlaps = true;
actual.DiscountOverlaps = true;
Assert.AreEqual(expected.ComputeNorm(state), actual.ComputeNorm(state));
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//Make everything else 1 so we see the effect of the payload
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
public override float LengthNorm(FieldInvertState state)
{
return state.Boost;
}
