public NormsConsumerPerField(DocInverterPerField docInverterPerField, FieldInfo fieldInfo /*, NormsConsumer parent // LUCENENET: Not referenced */)
{
this.fieldInfo = fieldInfo;
docState = docInverterPerField.docState;
fieldState = docInverterPerField.fieldState;
similarity = docState.similarity;
}
public NormsWriterPerField(DocInverterPerField docInverterPerField, NormsWriterPerThread perThread, FieldInfo fieldInfo)
{
this.perThread = perThread;
this.fieldInfo = fieldInfo;
docState = perThread.docState;
fieldState = docInverterPerField.fieldState;
}
public NormsConsumerPerField(DocInverterPerField docInverterPerField, FieldInfo fieldInfo, NormsConsumer parent)
{
this.FieldInfo = fieldInfo;
DocState = docInverterPerField.DocState;
FieldState = docInverterPerField.FieldState;
Similarity = DocState.Similarity;
}
public NormsConsumerPerField(DocInverterPerField docInverterPerField, FieldInfo fieldInfo, NormsConsumer parent)
{
this.fieldInfo = fieldInfo;
docState = docInverterPerField.docState;
fieldState = docInverterPerField.fieldState;
similarity = docState.similarity;
}
public TermsHashPerField(DocInverterPerField docInverterPerField, TermsHash termsHash, TermsHash nextTermsHash, FieldInfo fieldInfo)
{
IntPool = termsHash.IntPool;
BytePool = termsHash.BytePool;
TermBytePool = termsHash.TermBytePool;
DocState = termsHash.DocState;
this.TermsHash = termsHash;
BytesUsed = termsHash.BytesUsed;
FieldState = docInverterPerField.FieldState;
this.Consumer = termsHash.Consumer.AddField(this, fieldInfo);
PostingsBytesStartArray byteStarts = new PostingsBytesStartArray(this, BytesUsed);
BytesHash = new BytesRefHash(TermBytePool, HASH_INIT_SIZE, byteStarts);
StreamCount = Consumer.StreamCount;
NumPostingInt = 2 * StreamCount;
this.FieldInfo = fieldInfo;
if (nextTermsHash != null)
{
NextPerField = (TermsHashPerField)nextTermsHash.AddField(docInverterPerField, fieldInfo);
}
else
{
NextPerField = null;
}
}
public NormsWriterPerField(DocInverterPerField docInverterPerField, NormsWriterPerThread perThread, FieldInfo fieldInfo)
{
this.perThread = perThread;
this.fieldInfo = fieldInfo;
docState = perThread.docState;
fieldState = docInverterPerField.fieldState;
}
public TermsHashPerField(DocInverterPerField docInverterPerField, TermsHash termsHash, TermsHash nextTermsHash, FieldInfo fieldInfo)
{
intPool = termsHash.intPool;
bytePool = termsHash.bytePool;
termBytePool = termsHash.termBytePool;
docState = termsHash.docState;
this.termsHash = termsHash;
bytesUsed = termsHash.bytesUsed;
fieldState = docInverterPerField.fieldState;
this.consumer = termsHash.consumer.AddField(this, fieldInfo);
PostingsBytesStartArray byteStarts = new PostingsBytesStartArray(this, bytesUsed);
bytesHash = new BytesRefHash(termBytePool, HASH_INIT_SIZE, byteStarts);
streamCount = consumer.StreamCount;
numPostingInt = 2 * streamCount;
this.fieldInfo = fieldInfo;
if (nextTermsHash != null)
{
nextPerField = (TermsHashPerField)nextTermsHash.AddField(docInverterPerField, fieldInfo);
}
else
{
nextPerField = null;
}
}
public TermsHashPerField(DocInverterPerField docInverterPerField, TermsHashPerThread perThread, TermsHashPerThread nextPerThread, FieldInfo fieldInfo)
{
InitBlock();
this.perThread = perThread;
intPool = perThread.intPool;
charPool = perThread.charPool;
bytePool = perThread.bytePool;
docState = perThread.docState;
fieldState = docInverterPerField.fieldState;
// Sorter requires the char pool.
_sorter = new Sorter <RawPostingList, PostingComparer>(new PostingComparer(this));
this.consumer = perThread.consumer.AddField(this, fieldInfo);
streamCount = consumer.GetStreamCount();
numPostingInt = 2 * streamCount;
this.fieldInfo = fieldInfo;
if (nextPerThread != null)
{
nextPerField = (TermsHashPerField)nextPerThread.AddField(docInverterPerField, fieldInfo);
}
else
{
nextPerField = null;
}
}
public DocInverterPerField(DocInverter parent, FieldInfo fieldInfo)
{
this.fieldInfo = fieldInfo;
docState = parent.docState;
fieldState = new FieldInvertState(fieldInfo.Name);
this.consumer = parent.consumer.AddField(this, fieldInfo);
this.endConsumer = parent.endConsumer.AddField(this, fieldInfo);
}
internal bool HasPayloads; // if enabled, and we actually saw any for this field
public TermVectorsConsumerPerField(TermsHashPerField termsHashPerField, TermVectorsConsumer termsWriter, FieldInfo fieldInfo)
{
this.TermsHashPerField = termsHashPerField;
this.TermsWriter = termsWriter;
this.FieldInfo = fieldInfo;
DocState = termsHashPerField.DocState;
FieldState = termsHashPerField.FieldState;
}
public DocInverterPerField(DocInverter parent, FieldInfo fieldInfo)
{
this.fieldInfo = fieldInfo;
DocState = parent.DocState;
FieldState = new FieldInvertState(fieldInfo.Name);
this.Consumer = parent.Consumer.AddField(this, fieldInfo);
this.EndConsumer = parent.EndConsumer.AddField(this, fieldInfo);
}
internal bool hasPayloads; // if enabled, and we actually saw any for this field
public TermVectorsConsumerPerField(TermsHashPerField termsHashPerField, TermVectorsConsumer termsWriter, FieldInfo fieldInfo)
{
this.termsHashPerField = termsHashPerField;
this.termsWriter = termsWriter;
this.fieldInfo = fieldInfo;
docState = termsHashPerField.docState;
fieldState = termsHashPerField.fieldState;
}
public DocInverterPerField(DocInverter parent, FieldInfo fieldInfo)
{
this.fieldInfo = fieldInfo;
DocState = parent.DocState;
FieldState = new FieldInvertState(fieldInfo.Name);
this.Consumer = parent.Consumer.AddField(this, fieldInfo);
this.EndConsumer = parent.EndConsumer.AddField(this, fieldInfo);
}
public FreqProxTermsWriterPerField(TermsHashPerField termsHashPerField, FreqProxTermsWriter parent, FieldInfo fieldInfo)
{
this.TermsHashPerField = termsHashPerField;
this.Parent = parent;
this.fieldInfo = fieldInfo;
DocState = termsHashPerField.DocState;
FieldState = termsHashPerField.FieldState;
IndexOptions = fieldInfo.FieldIndexOptions;
}
public FreqProxTermsWriterPerField(TermsHashPerField termsHashPerField, FreqProxTermsWriterPerThread perThread, FieldInfo fieldInfo)
{
this.termsHashPerField = termsHashPerField;
this.perThread = perThread;
this.fieldInfo = fieldInfo;
docState = termsHashPerField.docState;
fieldState = termsHashPerField.fieldState;
omitTermFreqAndPositions = fieldInfo.omitTermFreqAndPositions;
}
public TermVectorsTermsWriterPerField(TermsHashPerField termsHashPerField, TermVectorsTermsWriterPerThread perThread, FieldInfo fieldInfo)
{
this.termsHashPerField = termsHashPerField;
this.perThread = perThread;
this.termsWriter = perThread.termsWriter;
this.fieldInfo = fieldInfo;
docState = termsHashPerField.docState;
fieldState = termsHashPerField.fieldState;
}
public FreqProxTermsWriterPerField(TermsHashPerField termsHashPerField, FreqProxTermsWriterPerThread perThread, FieldInfo fieldInfo)
{
this.termsHashPerField = termsHashPerField;
this.perThread = perThread;
this.fieldInfo = fieldInfo;
docState = termsHashPerField.docState;
fieldState = termsHashPerField.fieldState;
omitTermFreqAndPositions = fieldInfo.omitTermFreqAndPositions;
}
public DocInverterPerField(DocInverterPerThread perThread, FieldInfo fieldInfo)
{
this.perThread = perThread;
this.fieldInfo = fieldInfo;
docState = perThread.docState;
fieldState = perThread.fieldState;
this.consumer = perThread.consumer.AddField(this, fieldInfo);
this.endConsumer = perThread.endConsumer.AddField(this, fieldInfo);
}
public FreqProxTermsWriterPerField(TermsHashPerField termsHashPerField, FreqProxTermsWriter parent, FieldInfo fieldInfo)
{
this.termsHashPerField = termsHashPerField;
this.parent = parent;
this.fieldInfo = fieldInfo;
docState = termsHashPerField.docState;
fieldState = termsHashPerField.fieldState;
SetIndexOptions(fieldInfo.IndexOptions);
}
public TermVectorsTermsWriterPerField(TermsHashPerField termsHashPerField, TermVectorsTermsWriterPerThread perThread, FieldInfo fieldInfo)
{
this.termsHashPerField = termsHashPerField;
this.perThread = perThread;
this.termsWriter = perThread.termsWriter;
this.fieldInfo = fieldInfo;
docState = termsHashPerField.docState;
fieldState = termsHashPerField.fieldState;
}
public DocInverterPerField(DocInverterPerThread perThread, FieldInfo fieldInfo)
{
this.perThread = perThread;
this.fieldInfo = fieldInfo;
docState = perThread.docState;
fieldState = perThread.fieldState;
this.consumer = perThread.consumer.AddField(this, fieldInfo);
this.endConsumer = perThread.endConsumer.AddField(this, fieldInfo);
}
/// <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));
}
public TermsHashPerField(DocInverterPerField docInverterPerField, TermsHashPerThread perThread, TermsHashPerThread nextPerThread, FieldInfo fieldInfo)
{
InitBlock();
this.perThread = perThread;
intPool = perThread.intPool;
charPool = perThread.charPool;
bytePool = perThread.bytePool;
docState = perThread.docState;
fieldState = docInverterPerField.fieldState;
this.consumer = perThread.consumer.AddField(this, fieldInfo);
streamCount = consumer.GetStreamCount();
numPostingInt = 2 * streamCount;
this.fieldInfo = fieldInfo;
if (nextPerThread != null)
nextPerField = (TermsHashPerField) nextPerThread.AddField(docInverterPerField, fieldInfo);
else
nextPerField = null;
}
public TermsHashPerField(DocInverterPerField docInverterPerField, TermsHashPerThread perThread, TermsHashPerThread nextPerThread, FieldInfo fieldInfo)
{
InitBlock();
this.perThread = perThread;
intPool = perThread.intPool;
charPool = perThread.charPool;
bytePool = perThread.bytePool;
docState = perThread.docState;
fieldState = docInverterPerField.fieldState;
this.consumer = perThread.consumer.AddField(this, fieldInfo);
streamCount = consumer.GetStreamCount();
numPostingInt = 2 * streamCount;
this.fieldInfo = fieldInfo;
if (nextPerThread != null)
{
nextPerField = (TermsHashPerField)nextPerThread.AddField(docInverterPerField, fieldInfo);
}
else
{
nextPerField = null;
}
}
public TermsHashPerField(DocInverterPerField docInverterPerField, TermsHash termsHash, TermsHash nextTermsHash, FieldInfo fieldInfo)
{
IntPool = termsHash.IntPool;
BytePool = termsHash.BytePool;
TermBytePool = termsHash.TermBytePool;
DocState = termsHash.DocState;
this.TermsHash = termsHash;
BytesUsed = termsHash.BytesUsed;
FieldState = docInverterPerField.FieldState;
this.Consumer = termsHash.Consumer.AddField(this, fieldInfo);
PostingsBytesStartArray byteStarts = new PostingsBytesStartArray(this, BytesUsed);
BytesHash = new BytesRefHash(TermBytePool, HASH_INIT_SIZE, byteStarts);
StreamCount = Consumer.StreamCount;
NumPostingInt = 2 * StreamCount;
this.FieldInfo = fieldInfo;
if (nextTermsHash != null)
{
NextPerField = (TermsHashPerField)nextTermsHash.AddField(docInverterPerField, fieldInfo);
}
else
{
NextPerField = null;
}
}
public override long ComputeNorm(FieldInvertState state)
{
return Number.FloatToIntBits(state.Boost);
}
/// <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
/// org.apache.lucene.index.FieldInvertState#getLength()} - {@link
/// org.apache.lucene.index.FieldInvertState#getNumOverlap()}.
///
/// @lucene.experimental
/// </summary>
public override float LengthNorm(FieldInvertState state)
{
int numTerms;
if (discountOverlaps)
{
numTerms = state.Length - state.NumOverlap;
}
else
{
numTerms = state.Length;
}
return state.Boost * ((float)(1.0 / Math.Sqrt(numTerms)));
}
public override float LengthNorm(FieldInvertState state)
{
return(state.Boost);
}
public override float LengthNorm(FieldInvertState state)
{
return(state.MaxTermFrequency);
}
public override float LengthNorm(FieldInvertState state)
{
return state.MaxTermFrequency;
}
public override long ComputeNorm(FieldInvertState state)
{
return(J2N.BitConversion.SingleToInt32Bits(state.Boost));
}
public static float ComputeAndDecodeNorm(SweetSpotSimilarity decode, Similarity encode, FieldInvertState state)
{
return decode.DecodeNormValue(ComputeAndGetNorm(encode, state));
}
public override long ComputeNorm(FieldInvertState state)
{
int boost = (int)state.Boost;
return (sbyte)boost;
}
public override float LengthNorm(FieldInvertState state)
{
return state.Length;
}
public override long ComputeNorm(FieldInvertState state)
{
return(Number.FloatToIntBits(state.Boost));
}
public override long ComputeNorm(FieldInvertState state)
{
int boost = (int)state.Boost;
return((sbyte)boost);
}
public override sealed long ComputeNorm(FieldInvertState state)
{
int numTerms = DiscountOverlaps_Renamed ? state.Length - state.NumOverlap : state.Length;
return EncodeNormValue(state.Boost, numTerms);
}
public override long ComputeNorm(FieldInvertState state)
{
return state.UniqueTermCount;
}
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 static byte ComputeAndGetNorm(Similarity s, FieldInvertState state)
{
return (byte)s.ComputeNorm(state);
}
public override float LengthNorm(FieldInvertState state)
{
// Disable length norm
return state.Boost;
}
public override long ComputeNorm(FieldInvertState state)
{
return(Number.SingleToInt32Bits(state.Boost));
}
public override long ComputeNorm(FieldInvertState state)
{
return(state.UniqueTermCount);
}
/// <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);
}
public override long ComputeNorm(FieldInvertState state)
{
return Sim.ComputeNorm(state);
}
