ranking: parametrize contribution of document ranks (#479)

We tune the contribution of document ranks to the final ranking with a damping factor. The zero value of the damping factor leads to an equal contribution of scores and ranks, while a damping factor of 1 effectively eliminates the influence of document ranks.

The default is 0 IE equal contribution.

Author: stefanhengl

api.go

@@ -803,6 +803,11 @@ type SearchOptions struct {
 	// sorting matches.
 	UseDocumentRanks bool
 
+	// RanksDampingFactor determines the contribution of documents ranks to the
+	// final ranking based on RRF. A value in (0,1] reduces the contribution,
+	// while a value in (-inf,0) increases it.
+	RanksDampingFactor float64
+
 	// Trace turns on opentracing for this request if true and if the Jaeger address was provided as
 	// a command-line flag
 	Trace bool

contentprovider.go

@@ -900,7 +900,7 @@ func SortFiles(ms []FileMatch, opts *SearchOptions) {
 		sort.Stable(fileMatchesByRank{fileMatches: ms, rrfScore: rrfScore})
 
 		for i := range rrfScore {
-			rrfScore[i] += 1 / (k + float64(i))
+			rrfScore[i] += (1 - opts.RanksDampingFactor) / (k + float64(i))
 			if opts.DebugScore {
 				ms[i].Debug += fmt.Sprintf("%d), ", i)
 			}

contentprovider_test.go

@@ -3,6 +3,7 @@ package zoekt
 import (
 	"bytes"
 	"fmt"
+	"math"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
@@ -335,22 +336,46 @@ func TestSortFiles(t *testing.T) {
 		{FileName: "d4", Score: 1, Ranks: []float64{0.5}},
 	}
 
-	// Document  RRF(Score) RRF(Ranks) SUM                  Rank
-	// d3        1/(60+1)   1/(60+0)   0,0330601092896175   0
-	// d2        1/(60+0)   1/(60+3)   0,0325396825396826   1
-	// d1        1/(60+2)   1/(60+1)   0,0325224748810153   2
-	// d4        1/(60+3)   1/(60+2)   0,0320020481310804   3
+	cases := []struct {
+		name          string
+		dampingFactor float64
+		wantOrder     []string
+	}{
+		// Document  RRF(Score) RRF(Ranks) SUM                  Rank
+		// d3        1/(60+1)   1/(60+0)   0,0330601092896175   0
+		// d2        1/(60+0)   1/(60+3)   0,0325396825396826   1
+		// d1        1/(60+2)   1/(60+1)   0,0325224748810153   2
+		// d4        1/(60+3)   1/(60+2)   0,0320020481310804   3
+		{
+			"equal",
+			0,
+			[]string{"d3", "d2", "d1", "d4"},
+		},
+		{
+			"scores only",
+			1,
+			[]string{"d2", "d3", "d1", "d4"},
+		},
+		{
+			"ranks only",
+			math.Inf(-1),
+			[]string{"d3", "d1", "d4", "d2"},
+		},
+	}
 
-	SortFiles(in, &SearchOptions{UseDocumentRanks: true, DebugScore: true})
+	for _, tt := range cases {
+		t.Run("", func(t *testing.T) {
 
-	wantOrder := []string{"d3", "d2", "d1", "d4"}
+			SortFiles(in, &SearchOptions{UseDocumentRanks: true, DebugScore: true, RanksDampingFactor: tt.dampingFactor})
 
-	var haveOrder = []string{}
-	for _, f := range in {
-		haveOrder = append(haveOrder, f.FileName)
-	}
+			var haveOrder = []string{}
+			for _, f := range in {
+				haveOrder = append(haveOrder, f.FileName)
+			}
 
-	if d := cmp.Diff(wantOrder, haveOrder); d != "" {
-		t.Fatalf("-want, +got\n%s\n", d)
+			if d := cmp.Diff(tt.wantOrder, haveOrder); d != "" {
+				t.Fatalf("-want, +got\n%s\n", d)
+			}
+		})
 	}
 }