fix(faststats): correct Percentile() to use 0.0-1.0 range as documented

The Percentile() function documented that it accepts p in [0.0 - 1.0],
but the implementation incorrectly checked `p >= 100` and divided by 100.
This caused Var() method to return near-minimum values for all percentiles
since it called Percentile(.25), Percentile(.5), etc.

Fixed by changing bounds check to `p >= 1` and removing the /100 divisor.
Updated tests to use correct 0.0-1.0 range values.

Author: claude

faststats/rolling_percentile.go

@@ -88,10 +88,10 @@ func (s SortedDurations) Percentile(p float64) time.Duration {
 	if p <= 0 {
 		return s[0]
 	}
-	if p >= 100 {
+	if p >= 1 {
 		return s[len(s)-1]
 	}
-	absoluteIndex := p / 100 * float64(len(s)-1)
+	absoluteIndex := p * float64(len(s)-1)
 
 	// The real value is now an approximation between here
 	// For example, if absoluteIndex is 5.5, then we want to return a value

faststats/rolling_percentile_test.go

@@ -131,27 +131,27 @@ func TestRollingPercentile_AddDuration(t *testing.T) {
 	x.AddDuration(time.Second*2, now)
 	snap := x.SnapshotAt(now)
 	expectSnap(t, "at one item", snap, 1, time.Second*2, map[float64]time.Duration{
-		0:   time.Second * 2,
-		99:  time.Second * 2,
-		100: time.Second * 2,
+		0:    time.Second * 2,
+		0.99: time.Second * 2,
+		1.0:  time.Second * 2,
 	})
 
 	x.AddDuration(time.Second, now)
 	snap = x.SnapshotAt(now)
 	expectSnap(t, "at second item", snap, 2, time.Second*3/2, map[float64]time.Duration{
 		0:   time.Second,
-		50:  time.Second + time.Second/2,
-		100: time.Second * 2,
+		0.5: time.Second + time.Second/2,
+		1.0: time.Second * 2,
 	})
 
 	x.AddDuration(time.Second*3, now)
 	snap = x.SnapshotAt(now)
 	expectSnap(t, "at third item", snap, 3, time.Second*2, map[float64]time.Duration{
-		0:   time.Second,
-		25:  time.Second + time.Second/2,
-		50:  time.Second * 2,
-		75:  time.Second*2 + time.Second/2,
-		100: time.Second * 3,
+		0:    time.Second,
+		0.25: time.Second + time.Second/2,
+		0.5:  time.Second * 2,
+		0.75: time.Second*2 + time.Second/2,
+		1.0:  time.Second * 3,
 	})
 }
 
@@ -178,15 +178,15 @@ func TestRollingPercentile_Movement(t *testing.T) {
 	x.AddDuration(time.Millisecond*3, now)
 	x.AddDuration(time.Millisecond*2, now.Add(time.Millisecond*500))
 	x.AddDuration(time.Millisecond*4, now.Add(time.Millisecond*900))
-	// should have vlaues 1, 2, 3, 4
+	// should have values 1, 2, 3, 4
 
 	snap := x.SnapshotAt(now.Add(time.Millisecond * 900))
 	expectSnap(t, "at start", snap, 4, time.Millisecond*10/4, map[float64]time.Duration{
-		0:               time.Millisecond,
-		1.0 / 3.0 * 100: time.Millisecond * 2,
-		50:              time.Millisecond*2 + time.Millisecond/2,
-		2.0 / 3.0 * 100: time.Millisecond * 3,
-		100:             time.Millisecond * 4,
+		0:           time.Millisecond,
+		1.0 / 3.0:   time.Millisecond * 2,
+		0.5:         time.Millisecond*2 + time.Millisecond/2,
+		2.0 / 3.0:   time.Millisecond * 3,
+		1.0:         time.Millisecond * 4,
 	})
 
 	x.AddDuration(time.Millisecond*5, now.Add(time.Millisecond*1001))
@@ -195,15 +195,15 @@ func TestRollingPercentile_Movement(t *testing.T) {
 	// expect [2, 4, 5]
 	expectSnap(t, "after falling off", snap, 3, time.Millisecond*11/3, map[float64]time.Duration{
 		0:   time.Millisecond * 2,
-		50:  time.Millisecond * 4,
-		100: time.Millisecond * 5,
+		0.5: time.Millisecond * 4,
+		1.0: time.Millisecond * 5,
 	})
 
 	snap = x.SnapshotAt(now.Add(time.Hour))
 	// All values should fall off
 	expectSnap(t, "after all falling off", snap, 0, -1, map[float64]time.Duration{
 		0:   -1,
-		50:  -1,
-		100: -1,
+		0.5: -1,
+		1.0: -1,
 	})
 }