Add Prev function

Author: korthaj

bench_test.go

@@ -38,11 +38,21 @@ func BenchmarkNext(b *testing.B) {
 	s := BuildTestSet(b.N)
 	b.StartTimer()
 
-	for n := s.Next(-1); n != -1; {
+	for n := -2; n != -1; {
 		n = s.Next(n)
 	}
 }
 
+func BenchmarkPrev(b *testing.B) {
+	b.StopTimer()
+	s := BuildTestSet(b.N)
+	b.StartTimer()
+
+	for n := MaxInt; n != -1; {
+		n = s.Prev(n)
+	}
+}
+
 func BenchmarkVisit(b *testing.B) {
 	b.StopTimer()
 	s := BuildTestSet(b.N) // As Visit is pretty fast, s can be pretty big.

set.go

@@ -174,6 +174,31 @@ func (s *Set) Next(m int) int {
 	return i<<shift + TrailingZeros(w)
 }
 
+// Prev returns the previous element n, n < m, in the set,
+// or -1 if there is no such element.
+func (s *Set) Prev(m int) int {
+	d := s.data
+	len := len(d)
+	if len == 0 || m <= 0 {
+		return -1
+	}
+	i := len - 1
+	if max := i<<shift + 63 - LeadingZeros(d[i]); m > max {
+		return max
+	}
+	i = m >> shift
+	t := bpw - uint(m&mask)
+	w := d[i] << t >> t // Zero out bits for numbers ≥ m.
+	for i > 0 && w == 0 {
+		i--
+		w = d[i]
+	}
+	if w == 0 {
+		return -1
+	}
+	return i<<shift + 63 - LeadingZeros(w)
+}
+
 // Visit calls the do function for each element of s in numerical order.
 // If do returns true, Visit returns immediately, skipping any remaining
 // elements, and returns true. It is safe for do to add or delete

set_test.go

@@ -212,45 +212,56 @@ func TestEmpty(t *testing.T) {
 	}
 }
 
-func TestNext(t *testing.T) {
+func TestNextPrev(t *testing.T) {
 	for _, x := range []struct {
 		s     *Set
 		m     int
 		nextN int
+		prevN int
 	}{
-		{New(), 0, -1},
-		{New(), -1, -1},
-
-		{New(1), -1, 1},
-		{New(1), 0, 1},
-		{New(1), 1, -1},
-		{New(1), 2, -1},
-
-		{New(0, 2), -1, 0},
-		{New(0, 2), 0, 2},
-		{New(0, 2), 1, 2},
-		{New(0, 2), 2, -1},
-		{New(0, 2), 3, -1},
-
-		{New(63, 64), 62, 63},
-		{New(63, 64), 63, 64},
-		{New(63, 64), 64, -1},
-
-		{New(100, 300), MinInt, 100},
-		{New(100, 300), 0, 100},
-		{New(100, 300), 99, 100},
-		{New(100, 300), 100, 300},
-		{New(100, 300), 200, 300},
-		{New(100, 300), 299, 300},
-		{New(100, 300), 300, -1},
-		{New(100, 300), 400, -1},
-		{New(100, 300), MaxInt, -1},
+		{New(), 1, -1, -1},
+		{New(), 0, -1, -1},
+		{New(), -1, -1, -1},
+
+		{New(1), -1, 1, -1},
+		{New(1), 0, 1, -1},
+		{New(1), 1, -1, -1},
+		{New(1), 2, -1, 1},
+
+		{New(0, 2), -1, 0, -1},
+		{New(0, 2), 0, 2, -1},
+		{New(0, 2), 1, 2, 0},
+		{New(0, 2), 2, -1, 0},
+		{New(0, 2), 3, -1, 2},
+
+		{New(63, 64), 62, 63, -1},
+		{New(63, 64), 63, 64, -1},
+		{New(63, 64), 64, -1, 63},
+		{New(63, 64), 65, -1, 64},
+
+		{New(100, 300), MinInt, 100, -1},
+		{New(100, 300), -1, 100, -1},
+		{New(100, 300), 0, 100, -1},
+		{New(100, 300), 1, 100, -1},
+		{New(100, 300), 99, 100, -1},
+		{New(100, 300), 100, 300, -1},
+		{New(100, 300), 101, 300, 100},
+		{New(100, 300), 200, 300, 100},
+		{New(100, 300), 299, 300, 100},
+		{New(100, 300), 300, -1, 100},
+		{New(100, 300), 301, -1, 300},
+		{New(100, 300), 400, -1, 300},
+		{New(100, 300), MaxInt, -1, 300},
 	} {
 		s := x.s
 		m := x.m
-		n := s.Next(m)
-		if n != x.nextN {
-			t.Errorf("%v.Next(%d) = %d; want %d", s, m, n, x.nextN)
+		nextN := s.Next(m)
+		if nextN != x.nextN {
+			t.Errorf("%v.Next(%d) = %d; want %d", s, m, nextN, x.nextN)
+		}
+		prevN := s.Prev(m)
+		if prevN != x.prevN {
+			t.Errorf("%v.Prev(%d) = %d; want %d", s, m, prevN, x.prevN)
 		}
 	}
 }