lucene-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Yonik Seeley <ysee...@gmail.com>
Subject Re: score based on field value
Date Mon, 26 Sep 2005 21:09:14 GMT
Here is another prototype.
Field value retrieval has been decoupled from function calculation, so one
will be able to use a field of any type with the same function class.

Comments?
If not, I think this may be the version I clean up, implement sources for
Integer and Ordinal fields, and submit to JIRA.

-Yonik
Now hiring -- http://tinyurl.com/7m67g


/**
* @author yonik
*/

public class LinearFloatFunction implements FunctionFactory {
protected final String field;
protected final FieldValueSourceFactory sourceFac;
protected final float slope;
protected final float intercept;

public LinearFloatFunction(String field, float slope, float intercept,
FieldValueSourceFactory sourceFac) {
this.field = field;
this.sourceFac=sourceFac==null ? FloatFieldSource.DEFAULT : sourceFac;
this.slope=slope;
this.intercept = intercept;
}

public FunctionInst createFunction(IndexReader reader) throws IOException {
final FieldValueSource source = sourceFac.getSource(field,reader);
return new FunctionInst() {
public float score(int doc) {
return source.floatVal(doc) * slope + intercept;
}
public String toString(int doc) {
return "f(" + source.floatVal(doc) + ")=" + score(doc);
}
};
}

public String toString() {
return slope + "*float(" + field + ")+" + intercept;
}

public int hashCode() {
return field.hashCode()
^ Float.floatToIntBits(slope)
^ (Float.floatToIntBits(intercept)*29)
^ sourceFac.hashCode();
}

public boolean equals(Object o) {
if (!(o instanceof LinearFloatFunction)) return false;
LinearFloatFunction other = (LinearFloatFunction)o;
return this.field.equals(other.field)
&& this.slope == other.slope
&& this.intercept == other.intercept
&& this.sourceFac.equals(other.sourceFac);
}
}




// there needs to be an object created at query evaluation time that
// is not referenced by the query itself. (you don't want a query
// object used as a key, carrying around big objects
abstract class FieldValueSource {
public float floatVal(int doc) { throw new UnsupportedOperationException();
}
public int intVal(int doc) { throw new UnsupportedOperationException(); }
public long longVal(int doc) { throw new UnsupportedOperationException(); }
public double doubleVal(int doc) { throw new
UnsupportedOperationException(); }
public String strVal(int doc) { throw new UnsupportedOperationException(); }
}

interface FieldValueSourceFactory {
public FieldValueSource getSource(String field, IndexReader reader) throws
IOException;
public boolean equals(Object o);
public int hashCode();
}

class FloatFieldSource implements FieldValueSourceFactory {
public static FloatFieldSource DEFAULT = new FloatFieldSource();

FieldCache.FloatParser parser;

public FloatFieldSource() {
}

public FloatFieldSource(FieldCache.FloatParser parser) {
this.parser = parser;
}

public FieldValueSource getSource(String field, IndexReader reader) throws
IOException {
final float[] arr = (parser==null) ?
FieldCache.DEFAULT.getFloats(reader, field) :
FieldCache.DEFAULT.getFloats(reader, field, parser);
return new FieldValueSource() {
public float floatVal(int doc) {
return arr[doc];
}

public int intVal(int doc) {
return (int)arr[doc];
}

public long longVal(int doc) {
return (long)arr[doc];
}

public double doubleVal(int doc) {
return (double)arr[doc];
}

public String strVal(int doc) {
return Float.toString(doc);
}
};
}

public boolean equals(Object o) {
if (!this.getClass().equals(o.getClass())) return false;
FloatFieldSource other = (FloatFieldSource)o;
return this.parser==null ? other.parser==null :
this.parser.getClass().equals(other.parser.getClass());
}

public int hashCode() {
return parser==null ? Float.class.hashCode() : parser.getClass().hashCode();
};

}


interface FunctionFactory {
public FunctionInst createFunction(IndexReader reader) throws IOException;
}

abstract class FunctionInst {
public abstract float score(int doc);
}



public class FunctionQuery extends Query {

FunctionFactory func;

public FunctionQuery(FunctionFactory func) {
this.func=func;
}

public Query rewrite(IndexReader reader) throws IOException {
return this;
}

protected class FunctionWeight implements Weight {
private Searcher searcher;
private float queryNorm;
private float queryWeight;

public FunctionWeight(Searcher searcher) {
this.searcher = searcher;
}

public Query getQuery() {
return FunctionQuery.this;
}

public float getValue() {
return queryWeight;
}

public float sumOfSquaredWeights() throws IOException {
queryWeight = getBoost();
return queryWeight * queryWeight;
}

public void normalize(float norm) {
this.queryNorm = norm;
queryWeight *= this.queryNorm;
}

public Scorer scorer(IndexReader reader) throws IOException {
return new AllScorer(getSimilarity(searcher), reader, this);
}

public Explanation explain(IndexReader reader, int doc) throws IOException {
return scorer(reader).explain(doc);
}
}

protected class AllScorer extends Scorer {
final IndexReader reader;
final int maxDoc;
final float qWeight;
int doc=-1;
final FunctionInst ff;

public AllScorer(Similarity similarity, IndexReader reader, Weight w) throws
IOException {
super(similarity);
this.qWeight = w.getValue();
this.reader = reader;
this.maxDoc = reader.maxDoc();
ff = func.createFunction(reader);
}

// instead of matching all docs, we could also embed a query.
// the score could either ignore the subscore, or boost it.
// Containment: floatline(foo:myTerm, "myFloatField", 1.0, 0.0f)
// Boost: foo:myTerm^floatline("myFloatField",1.0,0.0f)
public boolean next() throws IOException {
for(;;) {
++doc;
if (doc>=maxDoc) {
return false;
}
if (reader.isDeleted(doc)) continue;
// todo: allow score() to throw a specific exception
// and continue on to the next document if it is thrown...
// that may be useful...
return true;
}
}

public int doc() {
return doc;
}

public float score() throws IOException {
return qWeight * ff.score(doc);
}

public boolean skipTo(int target) throws IOException {
doc=target-1;
return next();
}

public Explanation explain(int doc) throws IOException {
float sc = qWeight * ff.score(doc);
return new Explanation(sc,"Function " + ff.score(doc) + " * queryWeight("
+qWeight + ")");
// TODO: add hierarchy
}
}


protected Weight createWeight(Searcher searcher) {
return new FunctionQuery.FunctionWeight(searcher);
}


/** Prints a user-readable version of this query. */
public String toString(String field)
{
return func.toString() + (getBoost()==0 ? "" : "^"+getBoost());
}


/** Returns true if <code>o</code> is equal to this. */
public boolean equals(Object o) {
if (!(o instanceof FunctionQuery)) return false;
FunctionQuery other = (FunctionQuery)o;
return this.getBoost() == other.getBoost()
&& this.func.equals(other.func);
}

/** Returns a hash code value for this object. */
public int hashCode() {
int h = Float.floatToIntBits(getBoost());
h ^= func.hashCode();
return h;
}
}

Mime
  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message