mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
Let IntRange's And and Or handle negative values
This commit is contained in:
1 parent
607bd735b4
commit
6a9a3abd24
3 files changed
+418
-115
No files matched your search
+195
-27
@@ -42,13 +42,35 @@ var (
|
||||
one = big.NewInt(1)
|
||||
)
|
||||
|
||||
func bigIntClone(i *big.Int) *big.Int {
|
||||
// bitMask returns ((1<<n) - 1), where n is the largest of n0 and n1.
|
||||
func bitMask(n0 int, n1 int) *big.Int {
|
||||
n := n0
|
||||
if n < n1 {
|
||||
n = n1
|
||||
}
|
||||
if n > (1 << 30) {
|
||||
panic("interval: input is too large")
|
||||
}
|
||||
z := big.NewInt(1)
|
||||
z = z.Lsh(z, uint(n))
|
||||
z = z.Sub(z, one)
|
||||
return z
|
||||
}
|
||||
|
||||
func bigIntNewSet(i *big.Int) *big.Int {
|
||||
if i != nil {
|
||||
return big.NewInt(0).Set(i)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func bigIntNewNot(i *big.Int) *big.Int {
|
||||
if i != nil {
|
||||
return big.NewInt(0).Not(i)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func bigIntMul(i *big.Int, j *big.Int) *big.Int { return big.NewInt(0).Mul(i, j) }
|
||||
func bigIntQuo(i *big.Int, j *big.Int) *big.Int { return big.NewInt(0).Quo(i, j) }
|
||||
|
||||
@@ -263,6 +285,35 @@ func (x IntRange) justZero() bool {
|
||||
return x[0] != nil && x[1] != nil && x[0].Sign() == 0 && x[1].Sign() == 0
|
||||
}
|
||||
|
||||
// split2Ways splits x into negative and non-negative sub-intervals. The
|
||||
// IntRange values returned may be empty, which means that x does not contain
|
||||
// any negative or non-negative elements.
|
||||
func (x IntRange) split2Ways() (neg IntRange, nonNeg IntRange) {
|
||||
if x.Empty() {
|
||||
return empty(), empty()
|
||||
}
|
||||
if x[0] != nil && x[0].Sign() >= 0 {
|
||||
return empty(), x
|
||||
}
|
||||
if x[1] != nil && x[1].Sign() < 0 {
|
||||
return x, empty()
|
||||
}
|
||||
|
||||
neg[0] = x[0]
|
||||
neg[1] = big.NewInt(-1)
|
||||
if x[1] != nil && x[1].Cmp(neg[1]) < 0 {
|
||||
neg[1] = x[1]
|
||||
}
|
||||
|
||||
nonNeg[0] = big.NewInt(0)
|
||||
if x[0] != nil && x[0].Cmp(nonNeg[0]) > 0 {
|
||||
nonNeg[0] = x[0]
|
||||
}
|
||||
nonNeg[1] = x[1]
|
||||
|
||||
return neg, nonNeg
|
||||
}
|
||||
|
||||
// split splits x into negative, zero and positive sub-intervals. The IntRange
|
||||
// values returned may be empty, which means that x does not contain any
|
||||
// negative or positive elements.
|
||||
@@ -293,14 +344,14 @@ func (x IntRange) split() (neg IntRange, pos IntRange, negEmpty bool, hasZero bo
|
||||
func (x IntRange) Unite(y IntRange) (z IntRange) {
|
||||
if x.Empty() {
|
||||
return IntRange{
|
||||
bigIntClone(y[0]),
|
||||
bigIntClone(y[1]),
|
||||
bigIntNewSet(y[0]),
|
||||
bigIntNewSet(y[1]),
|
||||
}
|
||||
}
|
||||
if y.Empty() {
|
||||
return IntRange{
|
||||
bigIntClone(x[0]),
|
||||
bigIntClone(x[1]),
|
||||
bigIntNewSet(x[0]),
|
||||
bigIntNewSet(x[1]),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -330,9 +381,9 @@ func (x IntRange) Intersect(y IntRange) (z IntRange) {
|
||||
}
|
||||
|
||||
if x[0] == nil {
|
||||
z[0] = bigIntClone(y[0])
|
||||
z[0] = bigIntNewSet(y[0])
|
||||
} else if y[0] == nil {
|
||||
z[0] = bigIntClone(x[0])
|
||||
z[0] = bigIntNewSet(x[0])
|
||||
} else if x[0].Cmp(y[0]) < 0 {
|
||||
z[0] = big.NewInt(0).Set(y[0])
|
||||
} else {
|
||||
@@ -340,9 +391,9 @@ func (x IntRange) Intersect(y IntRange) (z IntRange) {
|
||||
}
|
||||
|
||||
if x[1] == nil {
|
||||
z[1] = bigIntClone(y[1])
|
||||
z[1] = bigIntNewSet(y[1])
|
||||
} else if y[1] == nil {
|
||||
z[1] = bigIntClone(x[1])
|
||||
z[1] = bigIntNewSet(x[1])
|
||||
} else if x[1].Cmp(y[1]) < 0 {
|
||||
z[1] = big.NewInt(0).Set(x[1])
|
||||
} else {
|
||||
@@ -627,15 +678,54 @@ func (x IntRange) Rsh(y IntRange) (z IntRange, ok bool) {
|
||||
//
|
||||
// ok is false (and z will be IntRange{nil, nil}) if x or y contains at least
|
||||
// one negative value. Otherwise, ok is true.
|
||||
//
|
||||
// TODO: implement bit-wise operations (with tight bounds) on negative
|
||||
// integers. In that case, we could drop the "ok" return value.
|
||||
func (x IntRange) And(y IntRange) (z IntRange, ok bool) {
|
||||
if x.Empty() || y.Empty() {
|
||||
return empty(), true
|
||||
}
|
||||
if x.ContainsNegative() || y.ContainsNegative() {
|
||||
return IntRange{}, false
|
||||
if !x.ContainsNegative() && !y.ContainsNegative() {
|
||||
return andBothNonNeg(x, y), true
|
||||
}
|
||||
|
||||
xNeg, xNon := x.split2Ways()
|
||||
yNeg, yNon := y.split2Ways()
|
||||
hasXNeg := !xNeg.Empty()
|
||||
hasXNon := !xNon.Empty()
|
||||
hasYNeg := !yNeg.Empty()
|
||||
hasYNon := !yNon.Empty()
|
||||
|
||||
z = empty()
|
||||
if hasXNeg {
|
||||
if hasYNeg {
|
||||
w := orBothNonNeg(IntRange{
|
||||
bigIntNewNot(xNeg[1]),
|
||||
bigIntNewNot(xNeg[0]),
|
||||
}, IntRange{
|
||||
bigIntNewNot(yNeg[1]),
|
||||
bigIntNewNot(yNeg[0]),
|
||||
})
|
||||
z = z.Unite(IntRange{
|
||||
bigIntNewNot(w[1]),
|
||||
bigIntNewNot(w[0]),
|
||||
})
|
||||
}
|
||||
if hasYNon {
|
||||
z = z.Unite(andOneNegOneNonNeg(xNeg, yNon))
|
||||
}
|
||||
}
|
||||
if hasXNon {
|
||||
if hasYNeg {
|
||||
z = z.Unite(andOneNegOneNonNeg(yNeg, xNon))
|
||||
}
|
||||
if hasYNon {
|
||||
z = z.Unite(andBothNonNeg(xNon, yNon))
|
||||
}
|
||||
}
|
||||
return z, true
|
||||
}
|
||||
|
||||
func andBothNonNeg(x IntRange, y IntRange) (z IntRange) {
|
||||
if x.Empty() || x.ContainsNegative() || y.Empty() || y.ContainsNegative() {
|
||||
panic("pre-condition failure")
|
||||
}
|
||||
|
||||
zMax := (*big.Int)(nil)
|
||||
@@ -643,13 +733,13 @@ func (x IntRange) And(y IntRange) (z IntRange, ok bool) {
|
||||
if y[1] != nil {
|
||||
zMax = x.andMax(y)
|
||||
} else {
|
||||
return IntRange{big.NewInt(0), big.NewInt(0).Set(x[1])}, true
|
||||
return IntRange{big.NewInt(0), big.NewInt(0).Set(x[1])}
|
||||
}
|
||||
} else {
|
||||
if y[1] != nil {
|
||||
return IntRange{big.NewInt(0), big.NewInt(0).Set(y[1])}, true
|
||||
return IntRange{big.NewInt(0), big.NewInt(0).Set(y[1])}
|
||||
} else {
|
||||
return IntRange{big.NewInt(0), nil}, true
|
||||
return IntRange{big.NewInt(0), nil}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -665,22 +755,86 @@ func (x IntRange) And(y IntRange) (z IntRange, ok bool) {
|
||||
zMin := notX.orMax(notY)
|
||||
zMin.Not(zMin)
|
||||
|
||||
return IntRange{zMin, zMax}, true
|
||||
return IntRange{zMin, zMax}
|
||||
}
|
||||
|
||||
func andOneNegOneNonNeg(neg IntRange, non IntRange) (z IntRange) {
|
||||
if neg.Empty() || neg.ContainsZero() || neg.ContainsPositive() || non.Empty() || non.ContainsNegative() {
|
||||
panic("pre-condition failure")
|
||||
}
|
||||
|
||||
if neg[0] == nil {
|
||||
return IntRange{big.NewInt(0), bigIntNewSet(non[1])}
|
||||
} else if non[1] == nil {
|
||||
mask := bitMask(neg[0].BitLen(), non[0].BitLen())
|
||||
biasedNeg := IntRange{
|
||||
big.NewInt(0).And(mask, neg[0]),
|
||||
big.NewInt(0).And(mask, neg[1]),
|
||||
}
|
||||
w := andBothNonNeg(biasedNeg, IntRange{non[0], mask})
|
||||
return IntRange{w[0], nil}
|
||||
} else {
|
||||
mask := bitMask(neg[0].BitLen(), non[1].BitLen())
|
||||
biasedNeg := IntRange{
|
||||
big.NewInt(0).And(mask, neg[0]),
|
||||
big.NewInt(0).And(mask, neg[1]),
|
||||
}
|
||||
return andBothNonNeg(biasedNeg, non)
|
||||
}
|
||||
}
|
||||
|
||||
// Or returns z = x | y.
|
||||
//
|
||||
// ok is false (and z will be IntRange{nil, nil}) if x or y contains at least
|
||||
// one negative value. Otherwise, ok is true.
|
||||
//
|
||||
// TODO: implement bit-wise operations (with tight bounds) on negative
|
||||
// integers. In that case, we could drop the "ok" return value.
|
||||
func (x IntRange) Or(y IntRange) (z IntRange, ok bool) {
|
||||
if x.Empty() || y.Empty() {
|
||||
return empty(), true
|
||||
}
|
||||
if x.ContainsNegative() || y.ContainsNegative() {
|
||||
return IntRange{}, false
|
||||
if !x.ContainsNegative() && !y.ContainsNegative() {
|
||||
return orBothNonNeg(x, y), true
|
||||
}
|
||||
|
||||
xNeg, xNon := x.split2Ways()
|
||||
yNeg, yNon := y.split2Ways()
|
||||
hasXNeg := !xNeg.Empty()
|
||||
hasXNon := !xNon.Empty()
|
||||
hasYNeg := !yNeg.Empty()
|
||||
hasYNon := !yNon.Empty()
|
||||
|
||||
z = empty()
|
||||
if hasXNeg {
|
||||
if hasYNeg {
|
||||
w := andBothNonNeg(IntRange{
|
||||
bigIntNewNot(xNeg[1]),
|
||||
bigIntNewNot(xNeg[0]),
|
||||
}, IntRange{
|
||||
bigIntNewNot(yNeg[1]),
|
||||
bigIntNewNot(yNeg[0]),
|
||||
})
|
||||
z = z.Unite(IntRange{
|
||||
bigIntNewNot(w[1]),
|
||||
bigIntNewNot(w[0]),
|
||||
})
|
||||
}
|
||||
if hasYNon {
|
||||
z = z.Unite(orOneNegOneNonNeg(xNeg, yNon))
|
||||
}
|
||||
}
|
||||
if hasXNon {
|
||||
if hasYNeg {
|
||||
z = z.Unite(orOneNegOneNonNeg(yNeg, xNon))
|
||||
}
|
||||
if hasYNon {
|
||||
z = z.Unite(orBothNonNeg(xNon, yNon))
|
||||
}
|
||||
}
|
||||
return z, true
|
||||
}
|
||||
|
||||
func orBothNonNeg(x IntRange, y IntRange) (z IntRange) {
|
||||
if x.Empty() || x.ContainsNegative() || y.Empty() || y.ContainsNegative() {
|
||||
panic("pre-condition failure")
|
||||
}
|
||||
|
||||
zMax := (*big.Int)(nil)
|
||||
@@ -698,10 +852,10 @@ func (x IntRange) Or(y IntRange) (z IntRange, ok bool) {
|
||||
// value is contained in the other interval. For example, if both xx
|
||||
// and yy can be x[0], then (x[0] | x[0]) is simply x[0].
|
||||
if x.ContainsInt(y[0]) {
|
||||
return IntRange{big.NewInt(0).Set(y[0]), nil}, true
|
||||
return IntRange{big.NewInt(0).Set(y[0]), nil}
|
||||
}
|
||||
if y.ContainsInt(x[0]) {
|
||||
return IntRange{big.NewInt(0).Set(x[0]), nil}, true
|
||||
return IntRange{big.NewInt(0).Set(x[0]), nil}
|
||||
}
|
||||
if x[1] == nil && y[1] == nil {
|
||||
panic("unreachable")
|
||||
@@ -738,7 +892,21 @@ func (x IntRange) Or(y IntRange) (z IntRange, ok bool) {
|
||||
zMin := notX.andMax(notY)
|
||||
zMin.Not(zMin)
|
||||
|
||||
return IntRange{zMin, zMax}, true
|
||||
return IntRange{zMin, zMax}
|
||||
}
|
||||
|
||||
func orOneNegOneNonNeg(neg IntRange, non IntRange) (z IntRange) {
|
||||
w := andOneNegOneNonNeg(IntRange{
|
||||
bigIntNewNot(non[1]),
|
||||
bigIntNewNot(non[0]),
|
||||
}, IntRange{
|
||||
bigIntNewNot(neg[1]),
|
||||
bigIntNewNot(neg[0]),
|
||||
})
|
||||
return IntRange{
|
||||
bigIntNewNot(w[1]),
|
||||
bigIntNewNot(w[0]),
|
||||
}
|
||||
}
|
||||
|
||||
// The andMax and orMax algorithms are tricky.
|
||||
@@ -999,7 +1167,7 @@ func (x IntRange) orMax(y IntRange) *big.Int {
|
||||
// - Etc.
|
||||
func bitFillRight(i *big.Int) {
|
||||
if s := i.Sign(); s < 0 {
|
||||
panic("TODO: implement bit-wise operations on negative integers")
|
||||
panic("pre-condition failure")
|
||||
} else if s == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
+155
-65
@@ -24,6 +24,36 @@ import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
var fromNeg7ToPos7 = []*big.Int{
|
||||
big.NewInt(-7),
|
||||
big.NewInt(-6),
|
||||
big.NewInt(-5),
|
||||
big.NewInt(-4),
|
||||
big.NewInt(-3),
|
||||
big.NewInt(-2),
|
||||
big.NewInt(-1),
|
||||
big.NewInt(+0),
|
||||
big.NewInt(+1),
|
||||
big.NewInt(+2),
|
||||
big.NewInt(+3),
|
||||
big.NewInt(+4),
|
||||
big.NewInt(+5),
|
||||
big.NewInt(+6),
|
||||
big.NewInt(+7),
|
||||
nil,
|
||||
}
|
||||
|
||||
var fromNeg3ToPos3 = []*big.Int{
|
||||
big.NewInt(-3),
|
||||
big.NewInt(-2),
|
||||
big.NewInt(-1),
|
||||
big.NewInt(+0),
|
||||
big.NewInt(+1),
|
||||
big.NewInt(+2),
|
||||
big.NewInt(+3),
|
||||
nil,
|
||||
}
|
||||
|
||||
// TestMotivatingExample tests the "motivating example" given in the package
|
||||
// doc comment.
|
||||
func TestMotivatingExample(tt *testing.T) {
|
||||
@@ -311,33 +341,13 @@ func testBruteForceAgrees(x IntRange, y IntRange, opKey string) error {
|
||||
}
|
||||
|
||||
func TestBruteForceAgreesSystematically(tt *testing.T) {
|
||||
ints := []*big.Int{
|
||||
big.NewInt(-7),
|
||||
big.NewInt(-6),
|
||||
big.NewInt(-5),
|
||||
big.NewInt(-4),
|
||||
big.NewInt(-3),
|
||||
big.NewInt(-2),
|
||||
big.NewInt(-1),
|
||||
big.NewInt(+0),
|
||||
big.NewInt(+1),
|
||||
big.NewInt(+2),
|
||||
big.NewInt(+3),
|
||||
big.NewInt(+4),
|
||||
big.NewInt(+5),
|
||||
big.NewInt(+6),
|
||||
big.NewInt(+7),
|
||||
nil,
|
||||
}
|
||||
|
||||
for _, opKey := range intOperatorsKeys {
|
||||
|
||||
for _, x0 := range ints {
|
||||
for _, x1 := range ints {
|
||||
for _, x0 := range fromNeg7ToPos7 {
|
||||
for _, x1 := range fromNeg7ToPos7 {
|
||||
x := IntRange{x0, x1}
|
||||
|
||||
for _, y0 := range ints {
|
||||
for _, y1 := range ints {
|
||||
for _, y0 := range fromNeg7ToPos7 {
|
||||
for _, y1 := range fromNeg7ToPos7 {
|
||||
y := IntRange{y0, y1}
|
||||
|
||||
if err := testBruteForceAgrees(x, y, opKey); err != nil {
|
||||
@@ -422,7 +432,7 @@ func testOp1(s string) error {
|
||||
|
||||
got, gotOK := intOperators[opKey](x, y)
|
||||
if !got.Eq(want) || gotOK != wantOK {
|
||||
return fmt.Errorf("package code: got %v, %t, want %v, %t", got, gotOK, want, wantOK)
|
||||
return fmt.Errorf("got %v, %t, want %v, %t", got, gotOK, want, wantOK)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -755,46 +765,46 @@ func TestOpRsh(tt *testing.T) {
|
||||
|
||||
func TestOpAnd(tt *testing.T) {
|
||||
testOp(tt,
|
||||
"[ 3, 3] & [ -5, -5] == invalid",
|
||||
"[ 3, 3] & [ -5, -5] == [ 3, 3]",
|
||||
"[ 3, 3] & [ 0, 0] == [ 0, 0]",
|
||||
"[ 0, 0] & [ -7, 7] == invalid",
|
||||
"[ 0, 0] & [ -7, 7] == [ 0, 0]",
|
||||
"[ 0, 2] & [ 0, 5] == [ 0, 2]",
|
||||
"[ 3, 6] & [ 10, 15] == [ 0, 6]",
|
||||
"[ 3, +∞) & [ -4, -2] == invalid",
|
||||
"[ 3, +∞) & [ -4, -2] == [ 0, +∞)",
|
||||
"[ 3, +∞) & [ 10, 15] == [ 0, 15]",
|
||||
"[ 3, +∞) & ( -∞, 15] == invalid",
|
||||
"[ 3, 6] & ( -∞, 15] == invalid",
|
||||
"[ 3, 6] & ( -∞, +∞) == invalid",
|
||||
"( -∞, +∞) & ( -∞, +∞) == invalid",
|
||||
"( -∞, +∞) & [ 1, 2] == invalid",
|
||||
"( -∞, +∞) & [ 0, 0] == invalid",
|
||||
"[ 3, +∞) & ( -∞, 15] == [ 0, +∞)",
|
||||
"[ 3, 6] & ( -∞, 15] == [ 0, 6]",
|
||||
"[ 3, 6] & ( -∞, +∞) == [ 0, 6]",
|
||||
"( -∞, +∞) & ( -∞, +∞) == ( -∞, +∞)",
|
||||
"( -∞, +∞) & [ 1, 2] == [ 0, 2]",
|
||||
"( -∞, +∞) & [ 0, 0] == [ 0, 0]",
|
||||
"[ 3, 6] & [...empty..] == [...empty..]",
|
||||
"[...empty..] & [ 10, 15] == [...empty..]",
|
||||
"[...empty..] & [...empty..] == [...empty..]",
|
||||
"( -∞, +∞) & [...empty..] == [...empty..]",
|
||||
|
||||
"[ 1, 4] & [ -11, -10] == invalid",
|
||||
"[ 1, 4] & [ -11, -10] == [ 0, 4]",
|
||||
|
||||
"[ 1, 4] & [ -6, 2] == invalid",
|
||||
"[ 1, 4] & [ -6, 2] == [ 0, 4]",
|
||||
|
||||
"[ -3, -1] & [ 0, 3] == invalid",
|
||||
"[ -1, 4] & [ 0, 3] == invalid",
|
||||
"[ -3, -1] & [ 0, 3] == [ 0, 3]",
|
||||
"[ -1, 4] & [ 0, 3] == [ 0, 3]",
|
||||
"[ 0, 4] & [ 0, 3] == [ 0, 3]",
|
||||
"[ 1, 4] & [ 0, 3] == [ 0, 3]",
|
||||
|
||||
"[ -3, -1] & [ 2, 3] == invalid",
|
||||
"[ -1, 4] & [ 2, 3] == invalid",
|
||||
"[ -3, -1] & [ 2, 3] == [ 0, 3]",
|
||||
"[ -1, 4] & [ 2, 3] == [ 0, 3]",
|
||||
"[ 0, 4] & [ 2, 3] == [ 0, 3]",
|
||||
"[ 1, 4] & [ 2, 3] == [ 0, 3]",
|
||||
|
||||
"[ -9, +∞) & [ 2, +∞) == invalid",
|
||||
"[ -1, +∞) & [ 2, +∞) == invalid",
|
||||
"[ -9, +∞) & [ 2, +∞) == [ 0, +∞)",
|
||||
"[ -1, +∞) & [ 2, +∞) == [ 0, +∞)",
|
||||
"[ 0, +∞) & [ 2, +∞) == [ 0, +∞)",
|
||||
"[ 1, +∞) & [ 2, +∞) == [ 0, +∞)",
|
||||
"[ 7, +∞) & [ 2, +∞) == [ 0, +∞)",
|
||||
"[ -1, 1] & ( -∞, +∞) == invalid",
|
||||
"[ 0, 0] & ( -∞, +∞) == invalid",
|
||||
"[ 1, 1] & ( -∞, +∞) == invalid",
|
||||
"[ -1, 1] & ( -∞, +∞) == ( -∞, +∞)",
|
||||
"[ 0, 0] & ( -∞, +∞) == [ 0, 0]",
|
||||
"[ 1, 1] & ( -∞, +∞) == [ 0, 1]",
|
||||
|
||||
"[ 1, 3] & [ 4, 9] == [ 0, 3]",
|
||||
"[ 3, 4] & [ 5, 6] == [ 1, 4]",
|
||||
@@ -816,51 +826,54 @@ func TestOpAnd(tt *testing.T) {
|
||||
"[ 5, 9] & [ 9, +∞) == [ 0, 9]",
|
||||
"[ 5, 6] & [ 12, +∞) == [ 0, 6]",
|
||||
"[ 5, 9] & [ 12, +∞) == [ 0, 9]",
|
||||
|
||||
"( -∞, -3] & [ -3, -2] == ( -∞, -3]",
|
||||
"[ 2, +∞) & [ 1, 2] == [ 0, 2]",
|
||||
)
|
||||
}
|
||||
|
||||
func TestOpOr(tt *testing.T) {
|
||||
testOp(tt,
|
||||
"[ 3, 3] | [ -5, -5] == invalid",
|
||||
"[ 3, 3] | [ -5, -5] == [ -5, -5]",
|
||||
"[ 3, 3] | [ 0, 0] == [ 3, 3]",
|
||||
"[ 0, 0] | [ -7, 7] == invalid",
|
||||
"[ 0, 0] | [ -7, 7] == [ -7, 7]",
|
||||
"[ 0, 2] | [ 0, 5] == [ 0, 7]",
|
||||
"[ 3, 6] | [ 10, 15] == [ 11, 15]",
|
||||
"[ 3, +∞) | [ -4, -2] == invalid",
|
||||
"[ 3, +∞) | [ -4, -2] == [ -4, -1]",
|
||||
"[ 3, +∞) | [ 10, 15] == [ 10, +∞)",
|
||||
"[ 3, +∞) | ( -∞, 15] == invalid",
|
||||
"[ 3, 6] | ( -∞, 15] == invalid",
|
||||
"[ 3, 6] | ( -∞, +∞) == invalid",
|
||||
"( -∞, +∞) | ( -∞, +∞) == invalid",
|
||||
"( -∞, +∞) | [ 1, 2] == invalid",
|
||||
"( -∞, +∞) | [ 0, 0] == invalid",
|
||||
"[ 3, +∞) | ( -∞, 15] == ( -∞, +∞)",
|
||||
"[ 3, 6] | ( -∞, 15] == ( -∞, 15]",
|
||||
"[ 3, 6] | ( -∞, +∞) == ( -∞, +∞)",
|
||||
"( -∞, +∞) | ( -∞, +∞) == ( -∞, +∞)",
|
||||
"( -∞, +∞) | [ 1, 2] == ( -∞, +∞)",
|
||||
"( -∞, +∞) | [ 0, 0] == ( -∞, +∞)",
|
||||
"[ 3, 6] | [...empty..] == [...empty..]",
|
||||
"[...empty..] | [ 10, 15] == [...empty..]",
|
||||
"[...empty..] | [...empty..] == [...empty..]",
|
||||
"( -∞, +∞) | [...empty..] == [...empty..]",
|
||||
|
||||
"[ 1, 4] | [ -11, -10] == invalid",
|
||||
"[ 1, 4] | [ -11, -10] == [ -11, -9]",
|
||||
|
||||
"[ 1, 4] | [ -6, 2] == invalid",
|
||||
"[ 1, 4] | [ -6, 2] == [ -6, 6]",
|
||||
|
||||
"[ -3, -1] | [ 0, 3] == invalid",
|
||||
"[ -1, 4] | [ 0, 3] == invalid",
|
||||
"[ -3, -1] | [ 0, 3] == [ -3, -1]",
|
||||
"[ -1, 4] | [ 0, 3] == [ -1, 7]",
|
||||
"[ 0, 4] | [ 0, 3] == [ 0, 7]",
|
||||
"[ 1, 4] | [ 0, 3] == [ 1, 7]",
|
||||
|
||||
"[ -3, -1] | [ 2, 3] == invalid",
|
||||
"[ -1, 4] | [ 2, 3] == invalid",
|
||||
"[ -3, -1] | [ 2, 3] == [ -2, -1]",
|
||||
"[ -1, 4] | [ 2, 3] == [ -1, 7]",
|
||||
"[ 0, 4] | [ 2, 3] == [ 2, 7]",
|
||||
"[ 1, 4] | [ 2, 3] == [ 2, 7]",
|
||||
|
||||
"[ -9, +∞) | [ 2, +∞) == invalid",
|
||||
"[ -1, +∞) | [ 2, +∞) == invalid",
|
||||
"[ -9, +∞) | [ 2, +∞) == [ -9, +∞)",
|
||||
"[ -1, +∞) | [ 2, +∞) == [ -1, +∞)",
|
||||
"[ 0, +∞) | [ 2, +∞) == [ 2, +∞)",
|
||||
"[ 1, +∞) | [ 2, +∞) == [ 2, +∞)",
|
||||
"[ 7, +∞) | [ 2, +∞) == [ 7, +∞)",
|
||||
"[ -1, 1] | ( -∞, +∞) == invalid",
|
||||
"[ 0, 0] | ( -∞, +∞) == invalid",
|
||||
"[ 1, 1] | ( -∞, +∞) == invalid",
|
||||
"[ -1, 1] | ( -∞, +∞) == ( -∞, +∞)",
|
||||
"[ 0, 0] | ( -∞, +∞) == ( -∞, +∞)",
|
||||
"[ 1, 1] | ( -∞, +∞) == ( -∞, +∞)",
|
||||
|
||||
"[ 1, 3] | [ 4, 9] == [ 5, 11]",
|
||||
"[ 3, 4] | [ 5, 6] == [ 5, 7]",
|
||||
@@ -882,5 +895,82 @@ func TestOpOr(tt *testing.T) {
|
||||
"[ 5, 9] | [ 9, +∞) == [ 9, +∞)",
|
||||
"[ 5, 6] | [ 12, +∞) == [ 13, +∞)",
|
||||
"[ 5, 9] | [ 12, +∞) == [ 12, +∞)",
|
||||
|
||||
"( -∞, -3] | [ -3, -2] == [ -3, -1]",
|
||||
"[ 2, +∞) | [ 1, 2] == [ 2, +∞)",
|
||||
)
|
||||
}
|
||||
|
||||
func TestOpAndWithMinusOne(tt *testing.T) {
|
||||
minusOne := IntRange{big.NewInt(-1), big.NewInt(-1)}
|
||||
for _, x0 := range fromNeg3ToPos3 {
|
||||
for _, x1 := range fromNeg3ToPos3 {
|
||||
x := IntRange{x0, x1}
|
||||
want := x
|
||||
|
||||
if got, _ := x.And(minusOne); !got.Eq(want) {
|
||||
tt.Fatalf("%v & -1: got %v, want %v", x, got, want)
|
||||
}
|
||||
if got, _ := minusOne.And(x); !got.Eq(want) {
|
||||
tt.Fatalf("-1 & %v: got %v, want %v", x, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpAndWithZero(tt *testing.T) {
|
||||
zero := IntRange{big.NewInt(+0), big.NewInt(+0)}
|
||||
for _, x0 := range fromNeg3ToPos3 {
|
||||
for _, x1 := range fromNeg3ToPos3 {
|
||||
x := IntRange{x0, x1}
|
||||
want := zero
|
||||
if x.Empty() {
|
||||
want = empty()
|
||||
}
|
||||
|
||||
if got, _ := x.And(zero); !got.Eq(want) {
|
||||
tt.Fatalf("%v & +0: got %v, want %v", x, got, want)
|
||||
}
|
||||
if got, _ := zero.And(x); !got.Eq(want) {
|
||||
tt.Fatalf("+0 & %v: got %v, want %v", x, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpOrWithMinusOne(tt *testing.T) {
|
||||
minusOne := IntRange{big.NewInt(-1), big.NewInt(-1)}
|
||||
for _, x0 := range fromNeg3ToPos3 {
|
||||
for _, x1 := range fromNeg3ToPos3 {
|
||||
x := IntRange{x0, x1}
|
||||
want := minusOne
|
||||
if x.Empty() {
|
||||
want = empty()
|
||||
}
|
||||
|
||||
if got, _ := x.Or(minusOne); !got.Eq(want) {
|
||||
tt.Fatalf("%v | -1: got %v, want %v", x, got, want)
|
||||
}
|
||||
if got, _ := minusOne.Or(x); !got.Eq(want) {
|
||||
tt.Fatalf("-1 | %v: got %v, want %v", x, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestOpOrWithZero(tt *testing.T) {
|
||||
zero := IntRange{big.NewInt(+0), big.NewInt(+0)}
|
||||
for _, x0 := range fromNeg3ToPos3 {
|
||||
for _, x1 := range fromNeg3ToPos3 {
|
||||
x := IntRange{x0, x1}
|
||||
want := x
|
||||
|
||||
if got, _ := x.Or(zero); !got.Eq(want) {
|
||||
tt.Fatalf("%v | +0: got %v, want %v", x, got, want)
|
||||
}
|
||||
if got, _ := zero.Or(x); !got.Eq(want) {
|
||||
tt.Fatalf("+0 | %v: got %v, want %v", x, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+68
-23
@@ -83,7 +83,8 @@ import (
|
||||
const (
|
||||
radialNaN = -1 << 31
|
||||
|
||||
// Note that radialInput.Or requires that (riRadius + 1) is a power of 2.
|
||||
// Note that radialInput.And and radialInput.Or require that (riRadius + 1)
|
||||
// is a power of 2.
|
||||
riRadius = 15
|
||||
roRadius = 16 << 16
|
||||
|
||||
@@ -343,36 +344,56 @@ func (x radialInput) And(y radialInput) radialOutPair {
|
||||
if x == radialNaN || y == radialNaN {
|
||||
return radialOutPair{radialNaN, radialNaN}
|
||||
}
|
||||
if x < 0 || y < 0 {
|
||||
// TODO: handle negative numbers.
|
||||
return radialOutPair{radialNaN, radialNaN}
|
||||
}
|
||||
ox := x.canonicalize()
|
||||
oy := y.canonicalize()
|
||||
|
||||
if ox > +riRadius {
|
||||
if oy > +riRadius {
|
||||
// r is a power of 2, so that its binary representation contains one "1"
|
||||
// digit, and that digit is not shared with any "small" value <= riRadius.
|
||||
const r = riRadius + 1
|
||||
|
||||
if ox < -riRadius {
|
||||
if oy < -riRadius {
|
||||
return radialOutPair{roLargeNeg, -r}
|
||||
} else if oy > +riRadius {
|
||||
return radialOutPair{0, roLargePos}
|
||||
} else if oy < 0 {
|
||||
return radialOutPair{roLargeNeg, -r}
|
||||
} else {
|
||||
return radialOutPair{0, oy}
|
||||
}
|
||||
} else {
|
||||
if oy > +riRadius {
|
||||
return radialOutPair{0, ox}
|
||||
} else if ox > +riRadius {
|
||||
if oy < -riRadius {
|
||||
return radialOutPair{0, roLargePos}
|
||||
} else if oy > +riRadius {
|
||||
return radialOutPair{0, roLargePos}
|
||||
} else if oy < 0 {
|
||||
return radialOutPair{+r, roLargePos}
|
||||
} else {
|
||||
return radialOutPair{ox & oy, ox & oy}
|
||||
return radialOutPair{0, oy}
|
||||
}
|
||||
}
|
||||
|
||||
if oy < -riRadius {
|
||||
if ox < 0 {
|
||||
return radialOutPair{roLargeNeg, -r}
|
||||
} else {
|
||||
return radialOutPair{0, ox}
|
||||
}
|
||||
} else if oy > +riRadius {
|
||||
if ox < 0 {
|
||||
return radialOutPair{+r, roLargePos}
|
||||
} else {
|
||||
return radialOutPair{0, ox}
|
||||
}
|
||||
}
|
||||
|
||||
return radialOutPair{ox & oy, ox & oy}
|
||||
}
|
||||
|
||||
func (x radialInput) Or(y radialInput) radialOutPair {
|
||||
if x == radialNaN || y == radialNaN {
|
||||
return radialOutPair{radialNaN, radialNaN}
|
||||
}
|
||||
if x < 0 || y < 0 {
|
||||
// TODO: handle negative numbers.
|
||||
return radialOutPair{radialNaN, radialNaN}
|
||||
}
|
||||
ox := x.canonicalize()
|
||||
oy := y.canonicalize()
|
||||
|
||||
@@ -380,19 +401,43 @@ func (x radialInput) Or(y radialInput) radialOutPair {
|
||||
// digit, and that digit is not shared with any "small" value <= riRadius.
|
||||
const r = riRadius + 1
|
||||
|
||||
if ox > +riRadius {
|
||||
if oy > +riRadius {
|
||||
return radialOutPair{r, roLargePos}
|
||||
if ox < -riRadius {
|
||||
if oy < -riRadius {
|
||||
return radialOutPair{roLargeNeg, -1}
|
||||
} else if oy > +riRadius {
|
||||
return radialOutPair{roLargeNeg, -1}
|
||||
} else if oy < 0 {
|
||||
return radialOutPair{oy, -1}
|
||||
} else {
|
||||
return radialOutPair{oy | r, roLargePos}
|
||||
return radialOutPair{roLargeNeg, oy | -r}
|
||||
}
|
||||
} else {
|
||||
if oy > +riRadius {
|
||||
return radialOutPair{ox | r, roLargePos}
|
||||
} else if ox > +riRadius {
|
||||
if oy < -riRadius {
|
||||
return radialOutPair{roLargeNeg, -1}
|
||||
} else if oy > +riRadius {
|
||||
return radialOutPair{+r, roLargePos}
|
||||
} else if oy < 0 {
|
||||
return radialOutPair{oy, -1}
|
||||
} else {
|
||||
return radialOutPair{ox | oy, ox | oy}
|
||||
return radialOutPair{oy | +r, roLargePos}
|
||||
}
|
||||
}
|
||||
|
||||
if oy < -riRadius {
|
||||
if ox < 0 {
|
||||
return radialOutPair{ox, -1}
|
||||
} else {
|
||||
return radialOutPair{roLargeNeg, ox | -r}
|
||||
}
|
||||
} else if oy > +riRadius {
|
||||
if ox < 0 {
|
||||
return radialOutPair{ox, -1}
|
||||
} else {
|
||||
return radialOutPair{ox | +r, roLargePos}
|
||||
}
|
||||
}
|
||||
|
||||
return radialOutPair{ox | oy, ox | oy}
|
||||
}
|
||||
|
||||
var riOperators = map[string]func(radialInput, radialInput) radialOutPair{
|
||||
|
||||
Reference in new issue
Block a user