diff options
122 files changed, 3317 insertions, 3531 deletions
diff --git a/src/pkg/cmath/asin.go b/src/pkg/cmath/asin.go index eb87ba5e5..d6a3ca480 100644 --- a/src/pkg/cmath/asin.go +++ b/src/pkg/cmath/asin.go @@ -51,16 +51,16 @@ import "math" func Asin(x complex128) complex128 { if imag(x) == 0 { if math.Fabs(real(x)) > 1 { - return cmplx(math.Pi/2, 0) // DOMAIN error + return complex(math.Pi/2, 0) // DOMAIN error } - return cmplx(math.Asin(real(x)), 0) + return complex(math.Asin(real(x)), 0) } - ct := cmplx(-imag(x), real(x)) // i * x + ct := complex(-imag(x), real(x)) // i * x xx := x * x - x1 := cmplx(1-real(xx), -imag(xx)) // 1 - x*x - x2 := Sqrt(x1) // x2 = sqrt(1 - x*x) + x1 := complex(1-real(xx), -imag(xx)) // 1 - x*x + x2 := Sqrt(x1) // x2 = sqrt(1 - x*x) w := Log(ct + x2) - return cmplx(imag(w), -real(w)) // -i * w + return complex(imag(w), -real(w)) // -i * w } // Asinh returns the inverse hyperbolic sine of x. @@ -68,13 +68,13 @@ func Asinh(x complex128) complex128 { // TODO check range if imag(x) == 0 { if math.Fabs(real(x)) > 1 { - return cmplx(math.Pi/2, 0) // DOMAIN error + return complex(math.Pi/2, 0) // DOMAIN error } - return cmplx(math.Asinh(real(x)), 0) + return complex(math.Asinh(real(x)), 0) } xx := x * x - x1 := cmplx(1+real(xx), imag(xx)) // 1 + x*x - return Log(x + Sqrt(x1)) // log(x + sqrt(1 + x*x)) + x1 := complex(1+real(xx), imag(xx)) // 1 + x*x + return Log(x + Sqrt(x1)) // log(x + sqrt(1 + x*x)) } // Complex circular arc cosine @@ -93,16 +93,16 @@ func Asinh(x complex128) complex128 { // Acos returns the inverse cosine of x. func Acos(x complex128) complex128 { w := Asin(x) - return cmplx(math.Pi/2-real(w), -imag(w)) + return complex(math.Pi/2-real(w), -imag(w)) } // Acosh returns the inverse hyperbolic cosine of x. func Acosh(x complex128) complex128 { w := Acos(x) if imag(w) <= 0 { - return cmplx(-imag(w), real(w)) // i * w + return complex(-imag(w), real(w)) // i * w } - return cmplx(imag(w), -real(w)) // -i * w + return complex(imag(w), -real(w)) // -i * w } // Complex circular arc tangent @@ -159,12 +159,12 @@ func Atan(x complex128) complex128 { } t = imag(x) + 1 c := (x2 + t*t) / b - return cmplx(w, 0.25*math.Log(c)) + return complex(w, 0.25*math.Log(c)) } // Atanh returns the inverse hyperbolic tangent of x. func Atanh(x complex128) complex128 { - z := cmplx(-imag(x), real(x)) // z = i * x + z := complex(-imag(x), real(x)) // z = i * x z = Atan(z) - return cmplx(imag(z), -real(z)) // z = -i * z + return complex(imag(z), -real(z)) // z = -i * z } diff --git a/src/pkg/cmath/cmath_test.go b/src/pkg/cmath/cmath_test.go index bf1a9605d..6a595b0a6 100644 --- a/src/pkg/cmath/cmath_test.go +++ b/src/pkg/cmath/cmath_test.go @@ -355,15 +355,15 @@ var expSC = []complex128{ NaN(), } var vcIsNaNSC = []complex128{ - cmplx(math.Inf(-1), math.Inf(-1)), - cmplx(math.Inf(-1), math.NaN()), - cmplx(math.NaN(), math.Inf(-1)), - cmplx(0, math.NaN()), - cmplx(math.NaN(), 0), - cmplx(math.Inf(1), math.Inf(1)), - cmplx(math.Inf(1), math.NaN()), - cmplx(math.NaN(), math.Inf(1)), - cmplx(math.NaN(), math.NaN()), + complex(math.Inf(-1), math.Inf(-1)), + complex(math.Inf(-1), math.NaN()), + complex(math.NaN(), math.Inf(-1)), + complex(0, math.NaN()), + complex(math.NaN(), 0), + complex(math.Inf(1), math.Inf(1)), + complex(math.Inf(1), math.NaN()), + complex(math.NaN(), math.Inf(1)), + complex(math.NaN(), math.NaN()), } var isNaNSC = []bool{ false, @@ -656,7 +656,7 @@ func TestPolar(t *testing.T) { } } func TestPow(t *testing.T) { - var a = cmplx(float64(3), float64(3)) + var a = complex(3.0, 3.0) for i := 0; i < len(vc); i++ { if f := Pow(a, vc[i]); !cSoclose(pow[i], f, 4e-15) { t.Errorf("Pow(%g, %g) = %g, want %g", a, vc[i], f, pow[i]) @@ -743,82 +743,82 @@ func TestTanh(t *testing.T) { func BenchmarkAbs(b *testing.B) { for i := 0; i < b.N; i++ { - Abs(cmplx(2.5, 3.5)) + Abs(complex(2.5, 3.5)) } } func BenchmarkAcos(b *testing.B) { for i := 0; i < b.N; i++ { - Acos(cmplx(2.5, 3.5)) + Acos(complex(2.5, 3.5)) } } func BenchmarkAcosh(b *testing.B) { for i := 0; i < b.N; i++ { - Acosh(cmplx(2.5, 3.5)) + Acosh(complex(2.5, 3.5)) } } func BenchmarkAsin(b *testing.B) { for i := 0; i < b.N; i++ { - Asin(cmplx(2.5, 3.5)) + Asin(complex(2.5, 3.5)) } } func BenchmarkAsinh(b *testing.B) { for i := 0; i < b.N; i++ { - Asinh(cmplx(2.5, 3.5)) + Asinh(complex(2.5, 3.5)) } } func BenchmarkAtan(b *testing.B) { for i := 0; i < b.N; i++ { - Atan(cmplx(2.5, 3.5)) + Atan(complex(2.5, 3.5)) } } func BenchmarkAtanh(b *testing.B) { for i := 0; i < b.N; i++ { - Atanh(cmplx(2.5, 3.5)) + Atanh(complex(2.5, 3.5)) } } func BenchmarkConj(b *testing.B) { for i := 0; i < b.N; i++ { - Conj(cmplx(2.5, 3.5)) + Conj(complex(2.5, 3.5)) } } func BenchmarkCos(b *testing.B) { for i := 0; i < b.N; i++ { - Cos(cmplx(2.5, 3.5)) + Cos(complex(2.5, 3.5)) } } func BenchmarkCosh(b *testing.B) { for i := 0; i < b.N; i++ { - Cosh(cmplx(2.5, 3.5)) + Cosh(complex(2.5, 3.5)) } } func BenchmarkExp(b *testing.B) { for i := 0; i < b.N; i++ { - Exp(cmplx(2.5, 3.5)) + Exp(complex(2.5, 3.5)) } } func BenchmarkLog(b *testing.B) { for i := 0; i < b.N; i++ { - Log(cmplx(2.5, 3.5)) + Log(complex(2.5, 3.5)) } } func BenchmarkLog10(b *testing.B) { for i := 0; i < b.N; i++ { - Log10(cmplx(2.5, 3.5)) + Log10(complex(2.5, 3.5)) } } func BenchmarkPhase(b *testing.B) { for i := 0; i < b.N; i++ { - Phase(cmplx(2.5, 3.5)) + Phase(complex(2.5, 3.5)) } } func BenchmarkPolar(b *testing.B) { for i := 0; i < b.N; i++ { - Polar(cmplx(2.5, 3.5)) + Polar(complex(2.5, 3.5)) } } func BenchmarkPow(b *testing.B) { for i := 0; i < b.N; i++ { - Pow(cmplx(2.5, 3.5), cmplx(2.5, 3.5)) + Pow(complex(2.5, 3.5), complex(2.5, 3.5)) } } func BenchmarkRect(b *testing.B) { @@ -828,26 +828,26 @@ func BenchmarkRect(b *testing.B) { } func BenchmarkSin(b *testing.B) { for i := 0; i < b.N; i++ { - Sin(cmplx(2.5, 3.5)) + Sin(complex(2.5, 3.5)) } } func BenchmarkSinh(b *testing.B) { for i := 0; i < b.N; i++ { - Sinh(cmplx(2.5, 3.5)) + Sinh(complex(2.5, 3.5)) } } func BenchmarkSqrt(b *testing.B) { for i := 0; i < b.N; i++ { - Sqrt(cmplx(2.5, 3.5)) + Sqrt(complex(2.5, 3.5)) } } func BenchmarkTan(b *testing.B) { for i := 0; i < b.N; i++ { - Tan(cmplx(2.5, 3.5)) + Tan(complex(2.5, 3.5)) } } func BenchmarkTanh(b *testing.B) { for i := 0; i < b.N; i++ { - Tanh(cmplx(2.5, 3.5)) + Tanh(complex(2.5, 3.5)) } } diff --git a/src/pkg/cmath/conj.go b/src/pkg/cmath/conj.go index 7a19e8631..776b57da7 100644 --- a/src/pkg/cmath/conj.go +++ b/src/pkg/cmath/conj.go @@ -5,4 +5,4 @@ package cmath // Conj returns the complex conjugate of x. -func Conj(x complex128) complex128 { return cmplx(real(x), -imag(x)) } +func Conj(x complex128) complex128 { return complex(real(x), -imag(x)) } diff --git a/src/pkg/cmath/exp.go b/src/pkg/cmath/exp.go index 1a639c596..64c1ef409 100644 --- a/src/pkg/cmath/exp.go +++ b/src/pkg/cmath/exp.go @@ -51,5 +51,5 @@ import "math" func Exp(x complex128) complex128 { r := math.Exp(real(x)) s, c := math.Sincos(imag(x)) - return cmplx(r*c, r*s) + return complex(r*c, r*s) } diff --git a/src/pkg/cmath/isinf.go b/src/pkg/cmath/isinf.go index f17a752ec..f23d2dea7 100644 --- a/src/pkg/cmath/isinf.go +++ b/src/pkg/cmath/isinf.go @@ -14,8 +14,8 @@ func IsInf(x complex128) bool { return false } -// Inf returns a complex infinity, cmplx(+Inf, +Inf). +// Inf returns a complex infinity, complex(+Inf, +Inf). func Inf() complex128 { inf := math.Inf(1) - return cmplx(inf, inf) + return complex(inf, inf) } diff --git a/src/pkg/cmath/isnan.go b/src/pkg/cmath/isnan.go index 8e971dbd3..2063bb835 100644 --- a/src/pkg/cmath/isnan.go +++ b/src/pkg/cmath/isnan.go @@ -21,5 +21,5 @@ func IsNaN(x complex128) bool { // NaN returns a complex ``not-a-number'' value. func NaN() complex128 { nan := math.NaN() - return cmplx(nan, nan) + return complex(nan, nan) } diff --git a/src/pkg/cmath/log.go b/src/pkg/cmath/log.go index b42062b2a..8e6964fee 100644 --- a/src/pkg/cmath/log.go +++ b/src/pkg/cmath/log.go @@ -55,7 +55,7 @@ import "math" // Log returns the natural logarithm of x. func Log(x complex128) complex128 { - return cmplx(math.Log(Abs(x)), Phase(x)) + return complex(math.Log(Abs(x)), Phase(x)) } // Log10 returns the decimal logarithm of x. diff --git a/src/pkg/cmath/pow.go b/src/pkg/cmath/pow.go index de2c4db56..68e1207c6 100644 --- a/src/pkg/cmath/pow.go +++ b/src/pkg/cmath/pow.go @@ -46,7 +46,7 @@ import "math" func Pow(x, y complex128) complex128 { modulus := Abs(x) if modulus == 0 { - return cmplx(0, 0) + return complex(0, 0) } r := math.Pow(modulus, real(y)) arg := Phase(x) @@ -56,5 +56,5 @@ func Pow(x, y complex128) complex128 { theta += imag(y) * math.Log(modulus) } s, c := math.Sincos(theta) - return cmplx(r*c, r*s) + return complex(r*c, r*s) } diff --git a/src/pkg/cmath/rect.go b/src/pkg/cmath/rect.go index 1a88d8679..b955f0bf7 100644 --- a/src/pkg/cmath/rect.go +++ b/src/pkg/cmath/rect.go @@ -9,5 +9,5 @@ import "math" // Rect returns the complex number x with polar coordinates r, θ. func Rect(r, θ float64) complex128 { s, c := math.Sincos(θ) - return cmplx(r*c, r*s) + return complex(r*c, r*s) } diff --git a/src/pkg/cmath/sin.go b/src/pkg/cmath/sin.go index 1b79da493..8900ecdde 100644 --- a/src/pkg/cmath/sin.go +++ b/src/pkg/cmath/sin.go @@ -53,7 +53,7 @@ import "math" func Sin(x complex128) complex128 { s, c := math.Sincos(real(x)) sh, ch := sinhcosh(imag(x)) - return cmplx(s*ch, c*sh) + return complex(s*ch, c*sh) } // Complex hyperbolic sine @@ -73,7 +73,7 @@ func Sin(x complex128) complex128 { func Sinh(x complex128) complex128 { s, c := math.Sincos(imag(x)) sh, ch := sinhcosh(real(x)) - return cmplx(c*sh, s*ch) + return complex(c*sh, s*ch) } // Complex circular cosine @@ -98,7 +98,7 @@ func Sinh(x complex128) complex128 { func Cos(x complex128) complex128 { s, c := math.Sincos(real(x)) sh, ch := sinhcosh(imag(x)) - return cmplx(c*ch, -s*sh) + return complex(c*ch, -s*sh) } // Complex hyperbolic cosine @@ -117,7 +117,7 @@ func Cos(x complex128) complex128 { func Cosh(x complex128) complex128 { s, c := math.Sincos(imag(x)) sh, ch := sinhcosh(real(x)) - return cmplx(c*ch, s*sh) + return complex(c*ch, s*sh) } // calculate sinh and cosh diff --git a/src/pkg/cmath/sqrt.go b/src/pkg/cmath/sqrt.go index 58bc4b691..e77a9b9df 100644 --- a/src/pkg/cmath/sqrt.go +++ b/src/pkg/cmath/sqrt.go @@ -57,20 +57,20 @@ import "math" func Sqrt(x complex128) complex128 { if imag(x) == 0 { if real(x) == 0 { - return cmplx(0, 0) + return complex(0, 0) } if real(x) < 0 { - return cmplx(0, math.Sqrt(-real(x))) + return complex(0, math.Sqrt(-real(x))) } - return cmplx(math.Sqrt(real(x)), 0) + return complex(math.Sqrt(real(x)), 0) } if real(x) == 0 { if imag(x) < 0 { r := math.Sqrt(-0.5 * imag(x)) - return cmplx(r, -r) + return complex(r, -r) } r := math.Sqrt(0.5 * imag(x)) - return cmplx(r, r) + return complex(r, r) } a := real(x) b := imag(x) @@ -97,7 +97,7 @@ func Sqrt(x complex128) complex128 { r *= scale } if b < 0 { - return cmplx(t, -r) + return complex(t, -r) } - return cmplx(t, r) + return complex(t, r) } diff --git a/src/pkg/cmath/tan.go b/src/pkg/cmath/tan.go index d1945cd79..94b517521 100644 --- a/src/pkg/cmath/tan.go +++ b/src/pkg/cmath/tan.go @@ -64,7 +64,7 @@ func Tan(x complex128) complex128 { if d == 0 { return Inf() } - return cmplx(math.Sin(2*real(x))/d, math.Sinh(2*imag(x))/d) + return complex(math.Sin(2*real(x))/d, math.Sinh(2*imag(x))/d) } // Complex hyperbolic tangent @@ -85,7 +85,7 @@ func Tanh(x complex128) complex128 { if d == 0 { return Inf() } - return cmplx(math.Sinh(2*real(x))/d, math.Sin(2*imag(x))/d) + return complex(math.Sinh(2*real(x))/d, math.Sin(2*imag(x))/d) } // Program to subtract nearest integer multiple of PI @@ -114,11 +114,11 @@ func tanSeries(z complex128) float64 { x = reducePi(x) x = x * x y = y * y - x2 := float64(1) - y2 := float64(1) - f := float64(1) - rn := float64(0) - d := float64(0) + x2 := 1.0 + y2 := 1.0 + f := 1.0 + rn := 0.0 + d := 0.0 for { rn += 1 f *= rn @@ -180,5 +180,5 @@ func Cot(x complex128) complex128 { if d == 0 { return Inf() } - return cmplx(math.Sin(2*real(x))/d, -math.Sinh(2*imag(x))/d) + return complex(math.Sin(2*real(x))/d, -math.Sinh(2*imag(x))/d) } diff --git a/src/pkg/container/vector/numbers_test.go b/src/pkg/container/vector/numbers_test.go index 93335ca60..d540ace05 100644 --- a/src/pkg/container/vector/numbers_test.go +++ b/src/pkg/container/vector/numbers_test.go @@ -46,7 +46,7 @@ func TestVectorNums(t *testing.T) { v.Resize(0, 0) runtime.GC() n := m.Alloc - m0.Alloc - t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float(n)/memTestN) + t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float64(n)/memTestN) } @@ -64,7 +64,7 @@ func TestIntVectorNums(t *testing.T) { v.Resize(0, 0) runtime.GC() n := m.Alloc - m0.Alloc - t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float(n)/memTestN) + t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float64(n)/memTestN) } @@ -82,7 +82,7 @@ func TestStringVectorNums(t *testing.T) { v.Resize(0, 0) runtime.GC() n := m.Alloc - m0.Alloc - t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float(n)/memTestN) + t.Logf("%T.Push(%#v), n = %s: Alloc/n = %.2f\n", v, c, s(memTestN), float64(n)/memTestN) } diff --git a/src/pkg/encoding/binary/binary.go b/src/pkg/encoding/binary/binary.go index 6bbe7eb89..77ff3a9f3 100644 --- a/src/pkg/encoding/binary/binary.go +++ b/src/pkg/encoding/binary/binary.go @@ -199,7 +199,7 @@ func sizeof(v reflect.Type) int { case *reflect.UintType, *reflect.IntType, *reflect.FloatType, *reflect.ComplexType: switch t := t.Kind(); t { - case reflect.Int, reflect.Uint, reflect.Uintptr, reflect.Float, reflect.Complex: + case reflect.Int, reflect.Uint, reflect.Uintptr: return -1 } return int(v.Size()) @@ -331,12 +331,12 @@ func (d *decoder) value(v reflect.Value) { case *reflect.ComplexValue: switch v.Type().Kind() { case reflect.Complex64: - v.Set(cmplx( + v.Set(complex( float64(math.Float32frombits(d.uint32())), float64(math.Float32frombits(d.uint32())), )) case reflect.Complex128: - v.Set(cmplx( + v.Set(complex( math.Float64frombits(d.uint64()), math.Float64frombits(d.uint64()), )) diff --git a/src/pkg/encoding/binary/binary_test.go b/src/pkg/encoding/binary/binary_test.go index c378413f1..e09ec489f 100644 --- a/src/pkg/encoding/binary/binary_test.go +++ b/src/pkg/encoding/binary/binary_test.go @@ -31,8 +31,6 @@ type Struct struct { type T struct { Int int Uint uint - Float float - Complex complex Uintptr uintptr Array [4]int } @@ -49,11 +47,11 @@ var s = Struct{ math.Float32frombits(0x1f202122), math.Float64frombits(0x232425262728292a), - cmplx( + complex( math.Float32frombits(0x2b2c2d2e), math.Float32frombits(0x2f303132), ), - cmplx( + complex( math.Float64frombits(0x333435363738393a), math.Float64frombits(0x3b3c3d3e3f404142), ), diff --git a/src/pkg/exp/datafmt/datafmt_test.go b/src/pkg/exp/datafmt/datafmt_test.go index f6a09f820..d7c70b21d 100644 --- a/src/pkg/exp/datafmt/datafmt_test.go +++ b/src/pkg/exp/datafmt/datafmt_test.go @@ -80,10 +80,10 @@ func TestCustomFormatters(t *testing.T) { f = parse(t, ``, fmap1) verify(t, f, `even odd even odd `, 0, 1, 2, 3) - f = parse(t, `/ =@:blank; float="#"`, fmap1) + f = parse(t, `/ =@:blank; float64="#"`, fmap1) verify(t, f, `# # #`, 0.0, 1.0, 2.0) - f = parse(t, `float=@:nil`, fmap1) + f = parse(t, `float64=@:nil`, fmap1) verify(t, f, ``, 0.0, 1.0, 2.0) f = parse(t, `testing "testing"; ptr=*`, fmap2) @@ -139,7 +139,7 @@ func TestBasicTypes(t *testing.T) { const f = 3.141592 const fs = `3.141592` - check(t, `float ="%g"`, fs, f) + check(t, `float64="%g"`, fs, f) check(t, `float32="%g"`, fs, float32(f)) check(t, `float64="%g"`, fs, float64(f)) } diff --git a/src/pkg/exp/eval/Makefile b/src/pkg/exp/eval/Makefile index 2b716b14c..872316cad 100644 --- a/src/pkg/exp/eval/Makefile +++ b/src/pkg/exp/eval/Makefile @@ -30,7 +30,7 @@ eval: main.$O gen.$O: gen.go $(GC) $< -generate: gen.$O $(pkgdir)/$(TARG).a +generate: gen.$O $(LD) -o $@ $<;\ ./generate > expr1.go;\ gofmt -w expr1.go diff --git a/src/pkg/exp/eval/bridge.go b/src/pkg/exp/eval/bridge.go index 3fa498d68..12835c4c0 100644 --- a/src/pkg/exp/eval/bridge.go +++ b/src/pkg/exp/eval/bridge.go @@ -43,8 +43,6 @@ func TypeFromNative(t reflect.Type) Type { et = Float32Type case reflect.Float64: et = Float64Type - case reflect.Float: - et = FloatType } case *reflect.IntType: switch t.Kind() { diff --git a/src/pkg/exp/eval/eval_test.go b/src/pkg/exp/eval/eval_test.go index 6bfe9089d..ff28cf1a9 100644 --- a/src/pkg/exp/eval/eval_test.go +++ b/src/pkg/exp/eval/eval_test.go @@ -173,8 +173,8 @@ func toValue(val interface{}) Value { return &r case *big.Int: return &idealIntV{val} - case float: - r := floatV(val) + case float64: + r := float64V(val) return &r case *big.Rat: return &idealFloatV{val} @@ -244,7 +244,7 @@ func newTestWorld() *World { def("i", IntType, 1) def("i2", IntType, 2) def("u", UintType, uint(1)) - def("f", FloatType, 1.0) + def("f", Float64Type, 1.0) def("s", StringType, "abc") def("t", NewStructType([]StructField{{"a", IntType, false}}), vstruct{1}) def("ai", NewArrayType(2, IntType), varray{1, 2}) diff --git a/src/pkg/exp/eval/expr.go b/src/pkg/exp/eval/expr.go index 70f63cf2d..e65f47617 100644 --- a/src/pkg/exp/eval/expr.go +++ b/src/pkg/exp/eval/expr.go @@ -1981,7 +1981,7 @@ func (a *expr) extractEffect(b *block, errOp string) (func(*Thread), *expr) { case tempType.isInteger(): tempType = IntType case tempType.isFloat(): - tempType = FloatType + tempType = Float64Type default: log.Panicf("unexpected ideal type %v", tempType) } diff --git a/src/pkg/exp/eval/expr1.go b/src/pkg/exp/eval/expr1.go index ae0cfc723..5d0e50000 100755 --- a/src/pkg/exp/eval/expr1.go +++ b/src/pkg/exp/eval/expr1.go @@ -9,8 +9,8 @@ import ( ) /* -* "As" functions. These retrieve evaluator functions from an -* expr, panicking if the requested evaluator has the wrong type. + * "As" functions. These retrieve evaluator functions from an + * expr, panicking if the requested evaluator has the wrong type. */ func (a *expr) asBool() func(*Thread) bool { return a.eval.(func(*Thread) bool) @@ -90,7 +90,7 @@ func (a *expr) asInterface() func(*Thread) interface{} { } /* -* Operator generators. + * Operator generators. */ func (a *expr) genConstant(v Value) { @@ -392,13 +392,6 @@ func (a *expr) genBinOpAdd(l, r *expr) { ret = l + r return float64(float64(ret)) } - case 0: - a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t) - var ret float64 - ret = l + r - return float64(float(ret)) - } default: log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } @@ -528,13 +521,6 @@ func (a *expr) genBinOpSub(l, r *expr) { ret = l - r return float64(float64(ret)) } - case 0: - a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t) - var ret float64 - ret = l - r - return float64(float(ret)) - } default: log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } @@ -657,13 +643,6 @@ func (a *expr) genBinOpMul(l, r *expr) { ret = l * r return float64(float64(ret)) } - case 0: - a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t) - var ret float64 - ret = l * r - return float64(float(ret)) - } default: log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } @@ -822,16 +801,6 @@ func (a *expr) genBinOpQuo(l, r *expr) { ret = l / r return float64(float64(ret)) } - case 0: - a.eval = func(t *Thread) float64 { - l, r := lf(t), rf(t) - var ret float64 - if r == 0 { - t.Abort(DivByZeroError{}) - } - ret = l / r - return float64(float(ret)) - } default: log.Panicf("unexpected size %d in type %v at %v", t.Bits, t, a.pos) } diff --git a/src/pkg/exp/eval/gen.go b/src/pkg/exp/eval/gen.go index 81863dd6f..a2b119846 100644 --- a/src/pkg/exp/eval/gen.go +++ b/src/pkg/exp/eval/gen.go @@ -47,7 +47,7 @@ var ( } idealIntType = &Type{Repr: "*idealIntType", Value: "IdealIntValue", Native: "*big.Int", As: "asIdealInt", IsIdeal: true} floatType = &Type{Repr: "*floatType", Value: "FloatValue", Native: "float64", As: "asFloat", - Sizes: []Size{{32, "float32"}, {64, "float64"}, {0, "float"}}, + Sizes: []Size{{32, "float32"}, {64, "float64"}}, } idealFloatType = &Type{Repr: "*idealFloatType", Value: "IdealFloatValue", Native: "*big.Rat", As: "asIdealFloat", IsIdeal: true} stringType = &Type{Repr: "*stringType", Value: "StringValue", Native: "string", As: "asString"} diff --git a/src/pkg/exp/eval/stmt.go b/src/pkg/exp/eval/stmt.go index b9ffa94fa..77ff066d0 100644 --- a/src/pkg/exp/eval/stmt.go +++ b/src/pkg/exp/eval/stmt.go @@ -602,7 +602,7 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token, case ac.rmt.Elems[i].isInteger(): lt = IntType case ac.rmt.Elems[i].isFloat(): - lt = FloatType + lt = Float64Type default: log.Panicf("unexpected ideal type %v", rs[i].t) } diff --git a/src/pkg/exp/eval/type.go b/src/pkg/exp/eval/type.go index db77ab198..3f272ce4b 100644 --- a/src/pkg/exp/eval/type.go +++ b/src/pkg/exp/eval/type.go @@ -372,7 +372,6 @@ type floatType struct { var ( Float32Type = universe.DefineType("float32", universePos, &floatType{commonType{}, 32, "float32"}) Float64Type = universe.DefineType("float64", universePos, &floatType{commonType{}, 64, "float64"}) - FloatType = universe.DefineType("float", universePos, &floatType{commonType{}, 0, "float"}) ) func (t *floatType) compat(o Type, conv bool) bool { @@ -394,9 +393,6 @@ func (t *floatType) Zero() Value { case 64: res := float64V(0) return &res - case 0: - res := floatV(0) - return &res } panic("unexpected float bit count") } @@ -408,9 +404,6 @@ var minFloat64Val *big.Rat func (t *floatType) minVal() *big.Rat { bits := t.Bits - if bits == 0 { - bits = uint(8 * unsafe.Sizeof(float(0))) - } switch bits { case 32: return minFloat32Val @@ -423,9 +416,6 @@ func (t *floatType) minVal() *big.Rat { func (t *floatType) maxVal() *big.Rat { bits := t.Bits - if bits == 0 { - bits = uint(8 * unsafe.Sizeof(float(0))) - } switch bits { case 32: return maxFloat32Val diff --git a/src/pkg/exp/eval/value.go b/src/pkg/exp/eval/value.go index cace2fd37..daa691897 100644 --- a/src/pkg/exp/eval/value.go +++ b/src/pkg/exp/eval/value.go @@ -307,16 +307,6 @@ func (v *float64V) Get(*Thread) float64 { return float64(*v) } func (v *float64V) Set(t *Thread, x float64) { *v = float64V(x) } -type floatV float - -func (v *floatV) String() string { return fmt.Sprint(*v) } - -func (v *floatV) Assign(t *Thread, o Value) { *v = floatV(o.(FloatValue).Get(t)) } - -func (v *floatV) Get(*Thread) float64 { return float64(*v) } - -func (v *floatV) Set(t *Thread, x float64) { *v = floatV(x) } - /* * Ideal float */ diff --git a/src/pkg/exp/ogle/rtype.go b/src/pkg/exp/ogle/rtype.go index fd77f1bc2..b3c35575a 100644 --- a/src/pkg/exp/ogle/rtype.go +++ b/src/pkg/exp/ogle/rtype.go @@ -209,9 +209,6 @@ func parseRemoteType(a aborter, rs remoteStruct) *remoteType { case p.runtime.PFloat64Type: t = eval.Float64Type mk = mkFloat64 - case p.runtime.PFloatType: - t = eval.FloatType - mk = mkFloat case p.runtime.PStringType: t = eval.StringType mk = mkString diff --git a/src/pkg/expvar/expvar_test.go b/src/pkg/expvar/expvar_test.go index 265943443..a8b1a96a9 100644 --- a/src/pkg/expvar/expvar_test.go +++ b/src/pkg/expvar/expvar_test.go @@ -128,7 +128,7 @@ func TestIntFunc(t *testing.T) { } func TestFloatFunc(t *testing.T) { - x := float64(8.5) + x := 8.5 ix := FloatFunc(func() float64 { return x }) if s := ix.String(); s != "8.5" { t.Errorf("ix.String() = %v, want 3.14", s) diff --git a/src/pkg/flag/flag.go b/src/pkg/flag/flag.go index 04fe2fa05..143a10611 100644 --- a/src/pkg/flag/flag.go +++ b/src/pkg/flag/flag.go @@ -166,22 +166,6 @@ func (s *stringValue) Set(val string) bool { func (s *stringValue) String() string { return fmt.Sprintf("%s", *s) } -// -- Float Value -type floatValue float - -func newFloatValue(val float, p *float) *floatValue { - *p = val - return (*floatValue)(p) -} - -func (f *floatValue) Set(s string) bool { - v, err := strconv.Atof(s) - *f = floatValue(v) - return err == nil -} - -func (f *floatValue) String() string { return fmt.Sprintf("%v", *f) } - // -- Float64 Value type float64Value float64 @@ -385,20 +369,6 @@ func String(name, value string, usage string) *string { return p } -// FloatVar defines a float flag with specified name, default value, and usage string. -// The argument p points to a float variable in which to store the value of the flag. -func FloatVar(p *float, name string, value float, usage string) { - Var(newFloatValue(value, p), name, usage) -} - -// Float defines a float flag with specified name, default value, and usage string. -// The return value is the address of a float variable that stores the value of the flag. -func Float(name string, value float, usage string) *float { - p := new(float) - FloatVar(p, name, value, usage) - return p -} - // Float64Var defines a float64 flag with specified name, default value, and usage string. // The argument p points to a float64 variable in which to store the value of the flag. func Float64Var(p *float64, name string, value float64, usage string) { diff --git a/src/pkg/flag/flag_test.go b/src/pkg/flag/flag_test.go index 4ebb73805..b91a8b567 100644 --- a/src/pkg/flag/flag_test.go +++ b/src/pkg/flag/flag_test.go @@ -18,8 +18,7 @@ var ( test_uint = Uint("test_uint", 0, "uint value") test_uint64 = Uint64("test_uint64", 0, "uint64 value") test_string = String("test_string", "0", "string value") - test_float = Float("test_float", 0, "float value") - test_float64 = Float("test_float64", 0, "float64 value") + test_float64 = Float64("test_float64", 0, "float64 value") ) func boolString(s string) string { @@ -48,7 +47,7 @@ func TestEverything(t *testing.T) { } } VisitAll(visitor) - if len(m) != 8 { + if len(m) != 7 { t.Error("VisitAll misses some flags") for k, v := range m { t.Log(k, *v) @@ -69,11 +68,10 @@ func TestEverything(t *testing.T) { Set("test_uint", "1") Set("test_uint64", "1") Set("test_string", "1") - Set("test_float", "1") Set("test_float64", "1") desired = "1" Visit(visitor) - if len(m) != 8 { + if len(m) != 7 { t.Error("Visit fails after set") for k, v := range m { t.Log(k, *v) @@ -101,8 +99,7 @@ func TestParse(t *testing.T) { uintFlag := Uint("uint", 0, "uint value") uint64Flag := Uint64("uint64", 0, "uint64 value") stringFlag := String("string", "0", "string value") - floatFlag := Float("float", 0, "float value") - float64Flag := Float("float64", 0, "float64 value") + float64Flag := Float64("float64", 0, "float64 value") extra := "one-extra-argument" args := []string{ "a.out", @@ -113,7 +110,6 @@ func TestParse(t *testing.T) { "-uint", "24", "--uint64", "25", "-string", "hello", - "--float", "3141.5", "-float64", "2718e28", extra, } @@ -141,9 +137,6 @@ func TestParse(t *testing.T) { if *stringFlag != "hello" { t.Error("string flag should be `hello`, is ", *stringFlag) } - if *floatFlag != 3141.5 { - t.Error("float flag should be 3141.5, is ", *floatFlag) - } if *float64Flag != 2718e28 { t.Error("float64 flag should be 2718e28, is ", *float64Flag) } diff --git a/src/pkg/fmt/fmt_test.go b/src/pkg/fmt/fmt_test.go index 0aafe6d99..3f085b722 100644 --- a/src/pkg/fmt/fmt_test.go +++ b/src/pkg/fmt/fmt_test.go @@ -28,10 +28,8 @@ type ( renamedUintptr uintptr renamedString string renamedBytes []byte - renamedFloat float renamedFloat32 float32 renamedFloat64 float64 - renamedComplex complex renamedComplex64 complex64 renamedComplex128 complex128 ) @@ -224,31 +222,31 @@ var fmttests = []struct { {"%b", 7, "111"}, {"%b", b64, "1111111111111111111111111111111111111111111111111111111111111111"}, {"%b", -6, "-110"}, - {"%e", float64(1), "1.000000e+00"}, - {"%e", float64(1234.5678e3), "1.234568e+06"}, - {"%e", float64(1234.5678e-8), "1.234568e-05"}, - {"%e", float64(-7), "-7.000000e+00"}, - {"%e", float64(-1e-9), "-1.000000e-09"}, - {"%f", float64(1234.5678e3), "1234567.800000"}, - {"%f", float64(1234.5678e-8), "0.000012"}, - {"%f", float64(-7), "-7.000000"}, - {"%f", float64(-1e-9), "-0.000000"}, - {"%g", float64(1234.5678e3), "1.2345678e+06"}, + {"%e", 1.0, "1.000000e+00"}, + {"%e", 1234.5678e3, "1.234568e+06"}, + {"%e", 1234.5678e-8, "1.234568e-05"}, + {"%e", -7.0, "-7.000000e+00"}, + {"%e", -1e-9, "-1.000000e-09"}, + {"%f", 1234.5678e3, "1234567.800000"}, + {"%f", 1234.5678e-8, "0.000012"}, + {"%f", -7.0, "-7.000000"}, + {"%f", -1e-9, "-0.000000"}, + {"%g", 1234.5678e3, "1.2345678e+06"}, {"%g", float32(1234.5678e3), "1.2345678e+06"}, - {"%g", float64(1234.5678e-8), "1.2345678e-05"}, - {"%g", float64(-7), "-7"}, - {"%g", float64(-1e-9), "-1e-09"}, + {"%g", 1234.5678e-8, "1.2345678e-05"}, + {"%g", -7.0, "-7"}, + {"%g", -1e-9, "-1e-09"}, {"%g", float32(-1e-9), "-1e-09"}, - {"%E", float64(1), "1.000000E+00"}, - {"%E", float64(1234.5678e3), "1.234568E+06"}, - {"%E", float64(1234.5678e-8), "1.234568E-05"}, - {"%E", float64(-7), "-7.000000E+00"}, - {"%E", float64(-1e-9), "-1.000000E-09"}, - {"%G", float64(1234.5678e3), "1.2345678E+06"}, + {"%E", 1.0, "1.000000E+00"}, + {"%E", 1234.5678e3, "1.234568E+06"}, + {"%E", 1234.5678e-8, "1.234568E-05"}, + {"%E", -7.0, "-7.000000E+00"}, + {"%E", -1e-9, "-1.000000E-09"}, + {"%G", 1234.5678e3, "1.2345678E+06"}, {"%G", float32(1234.5678e3), "1.2345678E+06"}, - {"%G", float64(1234.5678e-8), "1.2345678E-05"}, - {"%G", float64(-7), "-7"}, - {"%G", float64(-1e-9), "-1E-09"}, + {"%G", 1234.5678e-8, "1.2345678E-05"}, + {"%G", -7.0, "-7"}, + {"%G", -1e-9, "-1E-09"}, {"%G", float32(-1e-9), "-1E-09"}, {"%c", 'x', "x"}, {"%c", 0xe4, "ä"}, @@ -273,15 +271,15 @@ var fmttests = []struct { {"%20e", 1.2345e3, " 1.234500e+03"}, {"%20e", 1.2345e-3, " 1.234500e-03"}, {"%20.8e", 1.2345e3, " 1.23450000e+03"}, - {"%20f", float64(1.23456789e3), " 1234.567890"}, - {"%20f", float64(1.23456789e-3), " 0.001235"}, - {"%20f", float64(12345678901.23456789), " 12345678901.234568"}, - {"%-20f", float64(1.23456789e3), "1234.567890 "}, - {"%20.8f", float64(1.23456789e3), " 1234.56789000"}, - {"%20.8f", float64(1.23456789e-3), " 0.00123457"}, - {"%g", float64(1.23456789e3), "1234.56789"}, - {"%g", float64(1.23456789e-3), "0.00123456789"}, - {"%g", float64(1.23456789e20), "1.23456789e+20"}, + {"%20f", 1.23456789e3, " 1234.567890"}, + {"%20f", 1.23456789e-3, " 0.001235"}, + {"%20f", 12345678901.23456789, " 12345678901.234568"}, + {"%-20f", 1.23456789e3, "1234.567890 "}, + {"%20.8f", 1.23456789e3, " 1234.56789000"}, + {"%20.8f", 1.23456789e-3, " 0.00123457"}, + {"%g", 1.23456789e3, "1234.56789"}, + {"%g", 1.23456789e-3, "0.00123456789"}, + {"%g", 1.23456789e20, "1.23456789e+20"}, {"%20e", math.Inf(1), " +Inf"}, {"%-20f", math.Inf(-1), "-Inf "}, {"%20g", math.NaN(), " NaN"}, @@ -346,10 +344,8 @@ var fmttests = []struct { {"%x", renamedString("thing"), "7468696e67"}, {"%d", renamedBytes([]byte{1, 2, 15}), `[1 2 15]`}, {"%q", renamedBytes([]byte("hello")), `"hello"`}, - {"%v", renamedFloat(11), "11"}, {"%v", renamedFloat32(22), "22"}, {"%v", renamedFloat64(33), "33"}, - {"%v", renamedComplex(7 + .2i), "(7+0.2i)"}, {"%v", renamedComplex64(3 + 4i), "(3+4i)"}, {"%v", renamedComplex128(4 - 3i), "(4-3i)"}, @@ -363,7 +359,7 @@ var fmttests = []struct { {"%#v", S{F(7), G(8)}, "fmt_test.S{f:<v=F(7)>, g:GoString(8)}"}, // %T - {"%T", (4 - 3i), "complex"}, + {"%T", (4 - 3i), "complex128"}, {"%T", renamedComplex128(4 - 3i), "fmt_test.renamedComplex128"}, {"%T", intVal, "int"}, {"%6T", &intVal, " *int"}, diff --git a/src/pkg/fmt/format.go b/src/pkg/fmt/format.go index 0121dda31..86057bf69 100644 --- a/src/pkg/fmt/format.go +++ b/src/pkg/fmt/format.go @@ -396,36 +396,3 @@ func (f *fmt) fmt_c128(v complex128, verb int) { } f.buf.Write(irparenBytes) } - -// float -func (x *fmt) f(a float) { - if strconv.FloatSize == 32 { - x.fmt_f32(float32(a)) - } else { - x.fmt_f64(float64(a)) - } -} - -func (x *fmt) e(a float) { - if strconv.FloatSize == 32 { - x.fmt_e32(float32(a)) - } else { - x.fmt_e64(float64(a)) - } -} - -func (x *fmt) g(a float) { - if strconv.FloatSize == 32 { - x.fmt_g32(float32(a)) - } else { - x.fmt_g64(float64(a)) - } -} - -func (x *fmt) fb(a float) { - if strconv.FloatSize == 32 { - x.fmt_fb32(float32(a)) - } else { - x.fmt_fb64(float64(a)) - } -} diff --git a/src/pkg/fmt/print.go b/src/pkg/fmt/print.go index 412260441..96029a878 100644 --- a/src/pkg/fmt/print.go +++ b/src/pkg/fmt/print.go @@ -573,26 +573,12 @@ func (p *pp) printField(field interface{}, verb int, plus, goSyntax bool, depth case bool: p.fmtBool(f, verb, field) return false - case float: - if floatBits == 32 { - p.fmtFloat32(float32(f), verb, field) - } else { - p.fmtFloat64(float64(f), verb, field) - } - return false case float32: p.fmtFloat32(f, verb, field) return false case float64: p.fmtFloat64(f, verb, field) return false - case complex: - if complexBits == 64 { - p.fmtComplex64(complex64(f), verb, field) - } else { - p.fmtComplex128(complex128(f), verb, field) - } - return false case complex64: p.fmtComplex64(complex64(f), verb, field) return false diff --git a/src/pkg/fmt/scan.go b/src/pkg/fmt/scan.go index dcc42bc92..ebbb17155 100644 --- a/src/pkg/fmt/scan.go +++ b/src/pkg/fmt/scan.go @@ -640,7 +640,7 @@ func (s *ss) scanComplex(verb int, n int) complex128 { sreal, simag := s.complexTokens() real := s.convertFloat(sreal, n/2) imag := s.convertFloat(simag, n/2) - return cmplx(real, imag) + return complex(real, imag) } // convertString returns the string represented by the next input characters. @@ -772,8 +772,6 @@ func (s *ss) scanOne(verb int, field interface{}) { switch v := field.(type) { case *bool: *v = s.scanBool(verb) - case *complex: - *v = complex(s.scanComplex(verb, int(complexBits))) case *complex64: *v = complex64(s.scanComplex(verb, 64)) case *complex128: @@ -802,11 +800,6 @@ func (s *ss) scanOne(verb int, field interface{}) { *v = uintptr(s.scanUint(verb, uintptrBits)) // Floats are tricky because you want to scan in the precision of the result, not // scan in high precision and convert, in order to preserve the correct error condition. - case *float: - if s.okVerb(verb, floatVerbs, "float") { - s.skipSpace(false) - *v = float(s.convertFloat(s.floatToken(), int(floatBits))) - } case *float32: if s.okVerb(verb, floatVerbs, "float32") { s.skipSpace(false) diff --git a/src/pkg/fmt/scan_test.go b/src/pkg/fmt/scan_test.go index fe5ee1d61..78b9fbb4a 100644 --- a/src/pkg/fmt/scan_test.go +++ b/src/pkg/fmt/scan_test.go @@ -50,13 +50,11 @@ var ( uint16Val uint16 uint32Val uint32 uint64Val uint64 - floatVal float float32Val float32 float64Val float64 stringVal string stringVal1 string bytesVal []byte - complexVal complex complex64Val complex64 complex128Val complex128 renamedBoolVal renamedBool @@ -73,10 +71,8 @@ var ( renamedUintptrVal renamedUintptr renamedStringVal renamedString renamedBytesVal renamedBytes - renamedFloatVal renamedFloat renamedFloat32Val renamedFloat32 renamedFloat64Val renamedFloat64 - renamedComplexVal renamedComplex renamedComplex64Val renamedComplex64 renamedComplex128Val renamedComplex128 ) @@ -161,12 +157,12 @@ var scanTests = []ScanTest{ {"30\n", &uint64Val, uint64(30)}, {"255\n", &uint8Val, uint8(255)}, {"32767\n", &int16Val, int16(32767)}, - {"2.3\n", &floatVal, 2.3}, + {"2.3\n", &float64Val, 2.3}, {"2.3e1\n", &float32Val, float32(2.3e1)}, - {"2.3e2\n", &float64Val, float64(2.3e2)}, + {"2.3e2\n", &float64Val, 2.3e2}, {"2.35\n", &stringVal, "2.35"}, {"2345678\n", &bytesVal, []byte("2345678")}, - {"(3.4e1-2i)\n", &complexVal, 3.4e1 - 2i}, + {"(3.4e1-2i)\n", &complex128Val, 3.4e1 - 2i}, {"-3.45e1-3i\n", &complex64Val, complex64(-3.45e1 - 3i)}, {"-.45e1-1e2i\n", &complex128Val, complex128(-.45e1 - 100i)}, {"hello\n", &stringVal, "hello"}, @@ -256,10 +252,8 @@ var scanfTests = []ScanfTest{ {"%d", "113\n", &renamedUintptrVal, renamedUintptr(113)}, {"%s", "114\n", &renamedStringVal, renamedString("114")}, {"%q", "\"1155\"\n", &renamedBytesVal, renamedBytes([]byte("1155"))}, - {"%g", "115.1\n", &renamedFloatVal, renamedFloat(115.1)}, {"%g", "116e1\n", &renamedFloat32Val, renamedFloat32(116e1)}, {"%g", "-11.7e+1", &renamedFloat64Val, renamedFloat64(-11.7e+1)}, - {"%g", "11+5.1i\n", &renamedComplexVal, renamedComplex(11 + 5.1i)}, {"%g", "11+6e1i\n", &renamedComplex64Val, renamedComplex64(11 + 6e1i)}, {"%g", "-11.+7e+1i", &renamedComplex128Val, renamedComplex128(-11. + 7e+1i)}, @@ -288,15 +282,15 @@ var overflowTests = []ScanTest{ {"65536", &uint16Val, 0}, {"1e100", &float32Val, 0}, {"1e500", &float64Val, 0}, - {"(1e100+0i)", &complexVal, 0}, + {"(1e100+0i)", &complex64Val, 0}, {"(1+1e100i)", &complex64Val, 0}, {"(1-1e500i)", &complex128Val, 0}, } var i, j, k int -var f float +var f float64 var s, t string -var c complex +var c complex128 var x, y Xs var multiTests = []ScanfMultiTest{ @@ -307,7 +301,7 @@ var multiTests = []ScanfMultiTest{ {"%2d.%3d", "66.777", args(&i, &j), args(66, 777), ""}, {"%d, %d", "23, 18", args(&i, &j), args(23, 18), ""}, {"%3d22%3d", "33322333", args(&i, &j), args(333, 333), ""}, - {"%6vX=%3fY", "3+2iX=2.5Y", args(&c, &f), args((3 + 2i), float(2.5)), ""}, + {"%6vX=%3fY", "3+2iX=2.5Y", args(&c, &f), args((3 + 2i), 2.5), ""}, {"%d%s", "123abc", args(&i, &s), args(123, "abc"), ""}, {"%c%c%c", "2\u50c2X", args(&i, &j, &k), args('2', '\u50c2', 'X'), ""}, @@ -409,7 +403,7 @@ func TestScanOverflow(t *testing.T) { } func verifyNaN(str string, t *testing.T) { - var f float + var f float64 var f32 float32 var f64 float64 text := str + " " + str + " " + str @@ -432,7 +426,7 @@ func TestNaN(t *testing.T) { } func verifyInf(str string, t *testing.T) { - var f float + var f float64 var f32 float32 var f64 float64 text := str + " " + str + " " + str diff --git a/src/pkg/fmt/stringer_test.go b/src/pkg/fmt/stringer_test.go index 815147e1a..0ca3f522d 100644 --- a/src/pkg/fmt/stringer_test.go +++ b/src/pkg/fmt/stringer_test.go @@ -20,7 +20,7 @@ type TU16 uint16 type TU32 uint32 type TU64 uint64 type TUI uintptr -type TF float +type TF float64 type TF32 float32 type TF64 float64 type TB bool @@ -37,7 +37,7 @@ func (v TU16) String() string { return Sprintf("U16: %d", uint16(v)) } func (v TU32) String() string { return Sprintf("U32: %d", uint32(v)) } func (v TU64) String() string { return Sprintf("U64: %d", uint64(v)) } func (v TUI) String() string { return Sprintf("UI: %d", uintptr(v)) } -func (v TF) String() string { return Sprintf("F: %f", float(v)) } +func (v TF) String() string { return Sprintf("F: %f", float64(v)) } func (v TF32) String() string { return Sprintf("F32: %f", float32(v)) } func (v TF64) String() string { return Sprintf("F64: %f", float64(v)) } func (v TB) String() string { return Sprintf("B: %t", bool(v)) } diff --git a/src/pkg/go/doc/doc.go b/src/pkg/go/doc/doc.go index fb1c4e03d..e46857cb8 100644 --- a/src/pkg/go/doc/doc.go +++ b/src/pkg/go/doc/doc.go @@ -154,7 +154,7 @@ func (doc *docReader) addValue(decl *ast.GenDecl) { // determine values list const threshold = 0.75 values := &doc.values - if domName != "" && domFreq >= int(float(len(decl.Specs))*threshold) { + if domName != "" && domFreq >= int(float64(len(decl.Specs))*threshold) { // typed entries are sufficiently frequent typ := doc.lookupTypeDoc(domName) if typ != nil { diff --git a/src/pkg/go/printer/nodes.go b/src/pkg/go/printer/nodes.go index 8aadc75a5..8207996dc 100644 --- a/src/pkg/go/printer/nodes.go +++ b/src/pkg/go/printer/nodes.go @@ -228,7 +228,7 @@ func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exp useFF = false } else { const r = 4 // threshold - ratio := float(size) / float(prevSize) + ratio := float64(size) / float64(prevSize) useFF = ratio <= 1/r || r <= ratio } } diff --git a/src/pkg/gob/codec_test.go b/src/pkg/gob/codec_test.go index d150dbe9a..af941c629 100644 --- a/src/pkg/gob/codec_test.go +++ b/src/pkg/gob/codec_test.go @@ -254,18 +254,6 @@ func TestScalarEncInstructions(t *testing.T) { } } - // float - { - b.Reset() - data := struct{ a float }{17} - instr := &encInstr{encFloat, 6, 0, 0} - state := newencoderState(b) - instr.op(instr, state, unsafe.Pointer(&data)) - if !bytes.Equal(floatResult, b.Bytes()) { - t.Errorf("float enc instructions: expected % x got % x", floatResult, b.Bytes()) - } - } - // float32 { b.Reset() @@ -492,19 +480,6 @@ func TestScalarDecInstructions(t *testing.T) { } } - // float - { - var data struct { - a float - } - instr := &decInstr{decOpMap[reflect.Float], 6, 0, 0, ovfl} - state := newDecodeStateFromData(floatResult) - execDec("float", instr, state, t, unsafe.Pointer(&data)) - if data.a != 17 { - t.Errorf("float a = %v not 17", data.a) - } - } - // float32 { var data struct { @@ -531,19 +506,6 @@ func TestScalarDecInstructions(t *testing.T) { } } - // complex - { - var data struct { - a complex - } - instr := &decInstr{decOpMap[reflect.Complex], 6, 0, 0, ovfl} - state := newDecodeStateFromData(complexResult) - execDec("complex", instr, state, t, unsafe.Pointer(&data)) - if data.a != 17+19i { - t.Errorf("complex a = %v not 17+19i", data.a) - } - } - // complex64 { var data struct { @@ -605,8 +567,8 @@ func TestEndToEnd(t *testing.T) { s2 := "string2" type T1 struct { A, B, C int - M map[string]*float - N *[3]float + M map[string]*float64 + N *[3]float64 Strs *[2]string Int64s *[]int64 RI complex64 @@ -620,8 +582,8 @@ func TestEndToEnd(t *testing.T) { A: 17, B: 18, C: -5, - M: map[string]*float{"pi": &pi, "e": &e}, - N: &[3]float{1.5, 2.5, 3.5}, + M: map[string]*float64{"pi": &pi, "e": &e}, + N: &[3]float64{1.5, 2.5, 3.5}, Strs: &[2]string{s1, s2}, Int64s: &[]int64{77, 89, 123412342134}, RI: 17 - 23i, @@ -799,7 +761,7 @@ func TestOverflow(t *testing.T) { // complex64 b.Reset() it = inputT{ - Maxc: cmplx(math.MaxFloat32*2, math.MaxFloat32*2), + Maxc: complex(math.MaxFloat32*2, math.MaxFloat32*2), } type outc64 struct { Maxc complex64 @@ -940,10 +902,10 @@ func TestAutoIndirection(t *testing.T) { type RT0 struct { A int B string - C float + C float64 } type RT1 struct { - C float + C float64 B string A int NotSet string @@ -973,13 +935,13 @@ type IT0 struct { A int64 B string Ignore_d []int - Ignore_e [3]float + Ignore_e [3]float64 Ignore_f bool Ignore_g string Ignore_h []byte Ignore_i *RT1 Ignore_m map[string]int - C float + C float64 } func TestIgnoredFields(t *testing.T) { @@ -1013,7 +975,7 @@ func TestIgnoredFields(t *testing.T) { type Bad0 struct { ch chan int - c float + c float64 } var nilEncoder *Encoder @@ -1109,7 +1071,7 @@ func (i Int) Square() int { return int(i * i) } -type Float float +type Float float64 func (f Float) Square() int { return int(f * f) @@ -1137,14 +1099,14 @@ func (p Point) Square() int { type InterfaceItem struct { I int Sq1, Sq2, Sq3 Squarer - F float + F float64 Sq []Squarer } // The same struct without interfaces type NoInterfaceItem struct { I int - F float + F float64 } func TestInterface(t *testing.T) { @@ -1207,8 +1169,8 @@ func TestInterface(t *testing.T) { type BasicInterfaceItem struct { Int, Int8, Int16, Int32, Int64 interface{} Uint, Uint8, Uint16, Uint32, Uint64 interface{} - Float, Float32, Float64 interface{} - Complex, Complex64, Complex128 interface{} + Float32, Float64 interface{} + Complex64, Complex128 interface{} Bool interface{} String interface{} Bytes interface{} @@ -1219,8 +1181,8 @@ func TestInterfaceBasic(t *testing.T) { item1 := &BasicInterfaceItem{ int(1), int8(1), int16(1), int32(1), int64(1), uint(1), uint8(1), uint16(1), uint32(1), uint64(1), - float(1), float32(1), float64(1), - complex(0i), complex64(0i), complex128(0i), + float32(1), 1.0, + complex64(0i), complex128(0i), true, "hello", []byte("sailor"), @@ -1318,7 +1280,7 @@ func TestIgnoreInterface(t *testing.T) { type U struct { A int B string - c float + c float64 D uint } @@ -1354,7 +1316,7 @@ type DT struct { // X OnTheFly A int B string - C float + C float64 I interface{} J interface{} I_nil interface{} diff --git a/src/pkg/gob/decode.go b/src/pkg/gob/decode.go index f88ca72da..2db75215c 100644 --- a/src/pkg/gob/decode.go +++ b/src/pkg/gob/decode.go @@ -333,7 +333,7 @@ func decComplex64(i *decInstr, state *decodeState, p unsafe.Pointer) { p = *(*unsafe.Pointer)(p) } storeFloat32(i, state, p) - storeFloat32(i, state, unsafe.Pointer(uintptr(p)+uintptr(unsafe.Sizeof(float(0))))) + storeFloat32(i, state, unsafe.Pointer(uintptr(p)+uintptr(unsafe.Sizeof(float32(0))))) } func decComplex128(i *decInstr, state *decodeState, p unsafe.Pointer) { @@ -345,7 +345,7 @@ func decComplex128(i *decInstr, state *decodeState, p unsafe.Pointer) { } real := floatFromBits(uint64(state.decodeUint())) imag := floatFromBits(uint64(state.decodeUint())) - *(*complex128)(p) = cmplx(real, imag) + *(*complex128)(p) = complex(real, imag) } // uint8 arrays are encoded as an unsigned count followed by the raw bytes. @@ -993,20 +993,6 @@ func (dec *Decoder) decode(wireId typeId, val reflect.Value) os.Error { } func init() { - var fop, cop decOp - switch reflect.Typeof(float(0)).Bits() { - case 32: - fop = decFloat32 - cop = decComplex64 - case 64: - fop = decFloat64 - cop = decComplex128 - default: - panic("gob: unknown size of float") - } - decOpMap[reflect.Float] = fop - decOpMap[reflect.Complex] = cop - var iop, uop decOp switch reflect.Typeof(int(0)).Bits() { case 32: diff --git a/src/pkg/gob/encode.go b/src/pkg/gob/encode.go index 3431eafa7..d286a7e00 100644 --- a/src/pkg/gob/encode.go +++ b/src/pkg/gob/encode.go @@ -223,15 +223,6 @@ func floatBits(f float64) uint64 { return v } -func encFloat(i *encInstr, state *encoderState, p unsafe.Pointer) { - f := *(*float)(p) - if f != 0 || state.sendZero { - v := floatBits(float64(f)) - state.update(i) - state.encodeUint(v) - } -} - func encFloat32(i *encInstr, state *encoderState, p unsafe.Pointer) { f := *(*float32)(p) if f != 0 || state.sendZero { @@ -251,17 +242,6 @@ func encFloat64(i *encInstr, state *encoderState, p unsafe.Pointer) { } // Complex numbers are just a pair of floating-point numbers, real part first. -func encComplex(i *encInstr, state *encoderState, p unsafe.Pointer) { - c := *(*complex)(p) - if c != 0+0i || state.sendZero { - rpart := floatBits(float64(real(c))) - ipart := floatBits(float64(imag(c))) - state.update(i) - state.encodeUint(rpart) - state.encodeUint(ipart) - } -} - func encComplex64(i *encInstr, state *encoderState, p unsafe.Pointer) { c := *(*complex64)(p) if c != 0+0i || state.sendZero { @@ -446,10 +426,8 @@ var encOpMap = []encOp{ reflect.Uint32: encUint32, reflect.Uint64: encUint64, reflect.Uintptr: encUintptr, - reflect.Float: encFloat, reflect.Float32: encFloat32, reflect.Float64: encFloat64, - reflect.Complex: encComplex, reflect.Complex64: encComplex64, reflect.Complex128: encComplex128, reflect.String: encString, diff --git a/src/pkg/gob/encoder_test.go b/src/pkg/gob/encoder_test.go index db0b7db66..c2309352a 100644 --- a/src/pkg/gob/encoder_test.go +++ b/src/pkg/gob/encoder_test.go @@ -33,7 +33,7 @@ type ET3 struct { // Like ET1 but with a different type for a field type ET4 struct { A int - Et2 float + Et2 float64 Next int } @@ -189,13 +189,13 @@ func TestPtrTypeToType(t *testing.T) { func TestTypeToPtrPtrPtrPtrType(t *testing.T) { type Type2 struct { - A ****float + A ****float64 } t2 := Type2{} - t2.A = new(***float) - *t2.A = new(**float) - **t2.A = new(*float) - ***t2.A = new(float) + t2.A = new(***float64) + *t2.A = new(**float64) + **t2.A = new(*float64) + ***t2.A = new(float64) ****t2.A = 27.4 t2pppp := new(***Type2) if err := encAndDec(t2, t2pppp); err != nil { @@ -254,13 +254,13 @@ func TestDefaultsInArray(t *testing.T) { B []bool I []int S []string - F []float + F []float64 } t7 := Type7{ []bool{false, false, true}, []int{0, 0, 1}, []string{"hi", "", "there"}, - []float{0, 0, 1}, + []float64{0, 0, 1}, } var t7p Type7 if err := encAndDec(t7, &t7p); err != nil { diff --git a/src/pkg/gob/type.go b/src/pkg/gob/type.go index c00af87bf..22502a6e6 100644 --- a/src/pkg/gob/type.go +++ b/src/pkg/gob/type.go @@ -93,7 +93,7 @@ var ( tBool = bootstrapType("bool", false, 1) tInt = bootstrapType("int", int(0), 2) tUint = bootstrapType("uint", uint(0), 3) - tFloat = bootstrapType("float", float64(0), 4) + tFloat = bootstrapType("float", 0.0, 4) tBytes = bootstrapType("bytes", make([]byte, 0), 5) tString = bootstrapType("string", "", 6) tComplex = bootstrapType("complex", 0+0i, 7) @@ -529,10 +529,8 @@ func registerBasics() { Register(uint16(0)) Register(uint32(0)) Register(uint64(0)) - Register(float(0)) Register(float32(0)) - Register(float64(0)) - Register(complex(0i)) + Register(0.0) Register(complex64(0i)) Register(complex128(0i)) Register(false) diff --git a/src/pkg/gob/type_test.go b/src/pkg/gob/type_test.go index 106e4f10b..5aecde103 100644 --- a/src/pkg/gob/type_test.go +++ b/src/pkg/gob/type_test.go @@ -135,8 +135,8 @@ type Foo struct { b int32 // will become int c string d []byte - e *float // will become float - f ****float64 // will become float + e *float64 // will become float64 + f ****float64 // will become float64 g *Bar h *Bar // should not interpolate the definition of Bar again i *Foo // will not explode diff --git a/src/pkg/json/decode.go b/src/pkg/json/decode.go index c704cacbd..ff91dd83c 100644 --- a/src/pkg/json/decode.go +++ b/src/pkg/json/decode.go @@ -749,7 +749,7 @@ func (d *decodeState) literalInterface() interface{} { } n, err := strconv.Atof64(string(item)) if err != nil { - d.saveError(&UnmarshalTypeError{"number " + string(item), reflect.Typeof(float64(0))}) + d.saveError(&UnmarshalTypeError{"number " + string(item), reflect.Typeof(0.0)}) } return n } diff --git a/src/pkg/json/decode_test.go b/src/pkg/json/decode_test.go index 68cdea051..9cb27af41 100644 --- a/src/pkg/json/decode_test.go +++ b/src/pkg/json/decode_test.go @@ -52,7 +52,7 @@ var unmarshalTests = []unmarshalTest{ // basic types {`true`, new(bool), true, nil}, {`1`, new(int), 1, nil}, - {`1.2`, new(float), 1.2, nil}, + {`1.2`, new(float64), 1.2, nil}, {`-5`, new(int16), int16(-5), nil}, {`"a\u1234"`, new(string), "a\u1234", nil}, {`"http:\/\/"`, new(string), "http://", nil}, @@ -220,7 +220,6 @@ type All struct { Uint32 uint32 Uint64 uint64 Uintptr uintptr - Float float Float32 float32 Float64 float64 @@ -238,7 +237,6 @@ type All struct { PUint32 *uint32 PUint64 *uint64 PUintptr *uintptr - PFloat *float PFloat32 *float32 PFloat64 *float64 @@ -291,7 +289,6 @@ var allValue = All{ Uint32: 10, Uint64: 11, Uintptr: 12, - Float: 13.1, Float32: 14.1, Float64: 15.1, Foo: "foo", @@ -312,7 +309,7 @@ var allValue = All{ ByteSlice: []byte{27, 28, 29}, Small: Small{Tag: "tag30"}, PSmall: &Small{Tag: "tag31"}, - Interface: float64(5.2), + Interface: 5.2, } var pallValue = All{ @@ -328,7 +325,6 @@ var pallValue = All{ PUint32: &allValue.Uint32, PUint64: &allValue.Uint64, PUintptr: &allValue.Uintptr, - PFloat: &allValue.Float, PFloat32: &allValue.Float32, PFloat64: &allValue.Float64, PString: &allValue.String, @@ -353,7 +349,6 @@ var allValueIndent = `{ "Uint32": 10, "Uint64": 11, "Uintptr": 12, - "Float": 13.1, "Float32": 14.1, "Float64": 15.1, "bar": "foo", @@ -369,7 +364,6 @@ var allValueIndent = `{ "PUint32": null, "PUint64": null, "PUintptr": null, - "PFloat": null, "PFloat32": null, "PFloat64": null, "String": "16", @@ -449,7 +443,6 @@ var pallValueIndent = `{ "Uint32": 0, "Uint64": 0, "Uintptr": 0, - "Float": 0, "Float32": 0, "Float64": 0, "bar": "", @@ -465,7 +458,6 @@ var pallValueIndent = `{ "PUint32": 10, "PUint64": 11, "PUintptr": 12, - "PFloat": 13.1, "PFloat32": 14.1, "PFloat64": 15.1, "String": "", diff --git a/src/pkg/json/stream_test.go b/src/pkg/json/stream_test.go index c83cfe3a9..6ddaed9fe 100644 --- a/src/pkg/json/stream_test.go +++ b/src/pkg/json/stream_test.go @@ -13,14 +13,14 @@ import ( // Test values for the stream test. // One of each JSON kind. var streamTest = []interface{}{ - float64(0.1), + 0.1, "hello", nil, true, false, []interface{}{"a", "b", "c"}, map[string]interface{}{"K": "Kelvin", "ß": "long s"}, - float64(3.14), // another value to make sure something can follow map + 3.14, // another value to make sure something can follow map } var streamEncoded = `0.1 diff --git a/src/pkg/math/all_test.go b/src/pkg/math/all_test.go index 0efef2bbf..d2a7d411e 100644 --- a/src/pkg/math/all_test.go +++ b/src/pkg/math/all_test.go @@ -2076,7 +2076,7 @@ func TestLog1p(t *testing.T) { t.Errorf("Log1p(%g) = %g, want %g", a, f, log1p[i]) } } - a := float64(9) + a := 9.0 if f := Log1p(a); f != Ln10 { t.Errorf("Log1p(%g) = %g, want %g", a, f, Ln10) } diff --git a/src/pkg/math/gamma.go b/src/pkg/math/gamma.go index 4c5b17d05..73ca0e53a 100644 --- a/src/pkg/math/gamma.go +++ b/src/pkg/math/gamma.go @@ -151,7 +151,7 @@ func Gamma(x float64) float64 { } // Reduce argument - z := float64(1) + z := 1.0 for x >= 3 { x = x - 1 z = z * x diff --git a/src/pkg/math/jn.go b/src/pkg/math/jn.go index 7d3174310..9024af3c2 100644 --- a/src/pkg/math/jn.go +++ b/src/pkg/math/jn.go @@ -132,7 +132,7 @@ func Jn(n int, x float64) float64 { } else { temp := x * 0.5 b = temp - a := float64(1) + a := 1.0 for i := 2; i <= n; i++ { a *= float64(i) // a = n! b *= temp // b = (x/2)**n @@ -181,7 +181,7 @@ func Jn(n int, x float64) float64 { q0, q1 = q1, z*q1-q0 } m := n + n - t := float64(0) + t := 0.0 for i := 2 * (n + k); i >= m; i -= 2 { t = 1 / (float64(i)/x - t) } diff --git a/src/pkg/math/lgamma.go b/src/pkg/math/lgamma.go index dc31be929..dc30f468f 100644 --- a/src/pkg/math/lgamma.go +++ b/src/pkg/math/lgamma.go @@ -272,7 +272,7 @@ func Lgamma(x float64) (lgamma float64, sign int) { p := y * (S0 + y*(S1+y*(S2+y*(S3+y*(S4+y*(S5+y*S6)))))) q := 1 + y*(R1+y*(R2+y*(R3+y*(R4+y*(R5+y*R6))))) lgamma = 0.5*y + p/q - z := float64(1) // Lgamma(1+s) = Log(s) + Lgamma(s) + z := 1.0 // Lgamma(1+s) = Log(s) + Lgamma(s) switch i { case 7: z *= (y + 6) diff --git a/src/pkg/math/pow.go b/src/pkg/math/pow.go index f0ad84af6..06b107401 100644 --- a/src/pkg/math/pow.go +++ b/src/pkg/math/pow.go @@ -98,7 +98,7 @@ func Pow(x, y float64) float64 { } // ans = a1 * 2**ae (= 1 for now). - a1 := float64(1) + a1 := 1.0 ae := 0 // ans *= x**yf diff --git a/src/pkg/rand/rand.go b/src/pkg/rand/rand.go index 8c1219a7a..459aed1db 100644 --- a/src/pkg/rand/rand.go +++ b/src/pkg/rand/rand.go @@ -88,9 +88,6 @@ func (r *Rand) Float64() float64 { return float64(r.Int63()) / (1 << 63) } // Float32 returns, as a float32, a pseudo-random number in [0.0,1.0). func (r *Rand) Float32() float32 { return float32(r.Float64()) } -// Float returns, as a float, a pseudo-random number in [0.0,1.0). -func (r *Rand) Float() float { return float(r.Float64()) } - // Perm returns, as a slice of n ints, a pseudo-random permutation of the integers [0,n). func (r *Rand) Perm(n int) []int { m := make([]int, n) @@ -140,9 +137,6 @@ func Float64() float64 { return globalRand.Float64() } // Float32 returns, as a float32, a pseudo-random number in [0.0,1.0). func Float32() float32 { return globalRand.Float32() } -// Float returns, as a float, a pseudo-random number in [0.0,1.0). -func Float() float { return globalRand.Float() } - // Perm returns, as a slice of n ints, a pseudo-random permutation of the integers [0,n). func Perm(n int) []int { return globalRand.Perm(n) } diff --git a/src/pkg/rand/rand_test.go b/src/pkg/rand/rand_test.go index b9bf43208..2476ebaf6 100644 --- a/src/pkg/rand/rand_test.go +++ b/src/pkg/rand/rand_test.go @@ -131,8 +131,8 @@ func TestStandardNormalValues(t *testing.T) { } func TestNonStandardNormalValues(t *testing.T) { - for sd := float64(0.5); sd < 1000; sd *= 2 { - for m := float64(0.5); m < 1000; m *= 2 { + for sd := 0.5; sd < 1000; sd *= 2 { + for m := 0.5; m < 1000; m *= 2 { for _, seed := range testSeeds { testNormalDistribution(t, numTestSamples, m, sd, seed) } @@ -182,7 +182,7 @@ func TestStandardExponentialValues(t *testing.T) { } func TestNonStandardExponentialValues(t *testing.T) { - for rate := float64(0.05); rate < 10; rate *= 2 { + for rate := 0.05; rate < 10; rate *= 2 { for _, seed := range testSeeds { testExponentialDistribution(t, numTestSamples, rate, seed) } diff --git a/src/pkg/rand/zipf.go b/src/pkg/rand/zipf.go index c4e7b7d93..38e8ec516 100644 --- a/src/pkg/rand/zipf.go +++ b/src/pkg/rand/zipf.go @@ -55,7 +55,7 @@ func NewZipf(r *Rand, s float64, v float64, imax uint64) *Zipf { // Uint64 returns a value drawn from the Zipf distributed described // by the Zipf object. func (z *Zipf) Uint64() uint64 { - k := float64(0.0) + k := 0.0 for { r := z.r.Float64() // r on [0,1] diff --git a/src/pkg/reflect/all_test.go b/src/pkg/reflect/all_test.go index 7d34e5ca3..3675be6f1 100644 --- a/src/pkg/reflect/all_test.go +++ b/src/pkg/reflect/all_test.go @@ -48,7 +48,6 @@ var typeTests = []pair{ {struct{ x uint16 }{}, "uint16"}, {struct{ x uint32 }{}, "uint32"}, {struct{ x uint64 }{}, "uint64"}, - {struct{ x float }{}, "float"}, {struct{ x float32 }{}, "float32"}, {struct{ x float64 }{}, "float64"}, {struct{ x int8 }{}, "int8"}, @@ -244,8 +243,6 @@ func TestSet(t *testing.T) { } case *FloatValue: switch v.Type().Kind() { - case Float: - v.Set(128.5) case Float32: v.Set(256.25) case Float64: @@ -253,8 +250,6 @@ func TestSet(t *testing.T) { } case *ComplexValue: switch v.Type().Kind() { - case Complex: - v.Set(53200.0 + 100i) case Complex64: v.Set(532.125 + 10i) case Complex128: @@ -304,17 +299,13 @@ func TestSetValue(t *testing.T) { } case *FloatValue: switch v.Type().Kind() { - case Float: - v.SetValue(NewValue(float(128.5))) case Float32: v.SetValue(NewValue(float32(256.25))) case Float64: - v.SetValue(NewValue(float64(512.125))) + v.SetValue(NewValue(512.125)) } case *ComplexValue: switch v.Type().Kind() { - case Complex: - v.SetValue(NewValue(complex(53200.0 + 100i))) case Complex64: v.SetValue(NewValue(complex64(532.125 + 10i))) case Complex128: @@ -470,7 +461,7 @@ func TestInterfaceGet(t *testing.T) { assert(t, v2.Type().String(), "interface { }") i2 := v2.(*InterfaceValue).Interface() v3 := NewValue(i2) - assert(t, v3.Type().String(), "float") + assert(t, v3.Type().String(), "float64") } func TestInterfaceValue(t *testing.T) { @@ -482,11 +473,11 @@ func TestInterfaceValue(t *testing.T) { v2 := v1.(*PtrValue).Elem().(*StructValue).Field(0) assert(t, v2.Type().String(), "interface { }") v3 := v2.(*InterfaceValue).Elem() - assert(t, v3.Type().String(), "float") + assert(t, v3.Type().String(), "float64") i3 := v2.Interface() - if _, ok := i3.(float); !ok { - t.Error("v2.Interface() did not return float, got ", Typeof(i3)) + if _, ok := i3.(float64); !ok { + t.Error("v2.Interface() did not return float64, got ", Typeof(i3)) } } @@ -697,11 +688,11 @@ type _Complex struct { a int b [3]*_Complex c *string - d map[float]float + d map[float64]float64 } func TestDeepEqualComplexStruct(t *testing.T) { - m := make(map[float]float) + m := make(map[float64]float64) stra, strb := "hello", "hello" a, b := new(_Complex), new(_Complex) *a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m} @@ -712,7 +703,7 @@ func TestDeepEqualComplexStruct(t *testing.T) { } func TestDeepEqualComplexStructInequality(t *testing.T) { - m := make(map[float]float) + m := make(map[float64]float64) stra, strb := "hello", "helloo" // Difference is here a, b := new(_Complex), new(_Complex) *a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m} @@ -1317,12 +1308,12 @@ func TestImportPath(t *testing.T) { func TestDotDotDot(t *testing.T) { // Test example from FuncType.DotDotDot documentation. - var f func(x int, y ...float) + var f func(x int, y ...float64) typ := Typeof(f).(*FuncType) if typ.NumIn() == 2 && typ.In(0) == Typeof(int(0)) { sl, ok := typ.In(1).(*SliceType) if ok { - if sl.Elem() == Typeof(float(0)) { + if sl.Elem() == Typeof(0.0) { // ok return } @@ -1330,7 +1321,7 @@ func TestDotDotDot(t *testing.T) { } // Failed - t.Errorf("want NumIn() = 2, In(0) = int, In(1) = []float") + t.Errorf("want NumIn() = 2, In(0) = int, In(1) = []float64") s := fmt.Sprintf("have NumIn() = %d", typ.NumIn()) for i := 0; i < typ.NumIn(); i++ { s += fmt.Sprintf(", In(%d) = %s", i, typ.In(i)) diff --git a/src/pkg/reflect/type.go b/src/pkg/reflect/type.go index 9a7467b32..8dcbb2413 100644 --- a/src/pkg/reflect/type.go +++ b/src/pkg/reflect/type.go @@ -264,10 +264,8 @@ const ( Uint32 Uint64 Uintptr - Float Float32 Float64 - Complex Complex64 Complex128 Array @@ -306,9 +304,10 @@ var kindNames = []string{ Uint32: "uint32", Uint64: "uint64", Uintptr: "uintptr", - Float: "float", Float32: "float32", Float64: "float64", + Complex64: "complex64", + Complex128: "complex128", Array: "array", Chan: "chan", Func: "func", diff --git a/src/pkg/reflect/value.go b/src/pkg/reflect/value.go index e0bcb1a39..4d7d87237 100644 --- a/src/pkg/reflect/value.go +++ b/src/pkg/reflect/value.go @@ -142,8 +142,6 @@ type FloatValue struct { // Get returns the underlying int value. func (v *FloatValue) Get() float64 { switch v.typ.Kind() { - case Float: - return float64(*(*float)(v.addr)) case Float32: return float64(*(*float32)(v.addr)) case Float64: @@ -160,8 +158,6 @@ func (v *FloatValue) Set(x float64) { switch v.typ.Kind() { default: panic("reflect: invalid float kind") - case Float: - *(*float)(v.addr) = float(x) case Float32: *(*float32)(v.addr) = float32(x) case Float64: @@ -191,8 +187,6 @@ type ComplexValue struct { // Get returns the underlying complex value. func (v *ComplexValue) Get() complex128 { switch v.typ.Kind() { - case Complex: - return complex128(*(*complex)(v.addr)) case Complex64: return complex128(*(*complex64)(v.addr)) case Complex128: @@ -209,8 +203,6 @@ func (v *ComplexValue) Set(x complex128) { switch v.typ.Kind() { default: panic("reflect: invalid complex kind") - case Complex: - *(*complex)(v.addr) = complex(x) case Complex64: *(*complex64)(v.addr) = complex64(x) case Complex128: diff --git a/src/pkg/runtime/type.go b/src/pkg/runtime/type.go index d92fe5f2a..a350d4a0b 100644 --- a/src/pkg/runtime/type.go +++ b/src/pkg/runtime/type.go @@ -51,10 +51,8 @@ const ( kindUint32 kindUint64 kindUintptr - kindFloat kindFloat32 kindFloat64 - kindComplex kindComplex64 kindComplex128 kindArray diff --git a/src/pkg/runtime/type.h b/src/pkg/runtime/type.h index 4b5bd7ac2..3fb368ebd 100644 --- a/src/pkg/runtime/type.h +++ b/src/pkg/runtime/type.h @@ -41,10 +41,8 @@ enum { KindUint32, KindUint64, KindUintptr, - KindFloat, KindFloat32, KindFloat64, - KindComplex, KindComplex64, KindComplex128, KindArray, diff --git a/src/pkg/sort/search.go b/src/pkg/sort/search.go index b3ddd2dfa..6828e19b6 100644 --- a/src/pkg/sort/search.go +++ b/src/pkg/sort/search.go @@ -74,7 +74,7 @@ func Search(n int, f func(int) bool) int { // Convenience wrappers for common cases. -// SearchInts searches x in a sorted slice of ints and returns the index +// SearchInts searches for x in a sorted slice of ints and returns the index // as specified by Search. The array must be sorted in ascending order. // func SearchInts(a []int, x int) int { @@ -82,15 +82,15 @@ func SearchInts(a []int, x int) int { } -// SearchFloats searches x in a sorted slice of floats and returns the index +// SearchFloat64s searches for x in a sorted slice of float64s and returns the index // as specified by Search. The array must be sorted in ascending order. // -func SearchFloats(a []float, x float) int { +func SearchFloat64s(a []float64, x float64) int { return Search(len(a), func(i int) bool { return a[i] >= x }) } -// SearchStrings searches x in a sorted slice of strings and returns the index +// SearchStrings searches for x in a sorted slice of strings and returns the index // as specified by Search. The array must be sorted in ascending order. // func SearchStrings(a []string, x string) int { @@ -102,8 +102,8 @@ func SearchStrings(a []string, x string) int { func (p IntArray) Search(x int) int { return SearchInts(p, x) } -// Search returns the result of applying SearchFloats to the receiver and x. -func (p FloatArray) Search(x float) int { return SearchFloats(p, x) } +// Search returns the result of applying SearchFloat64s to the receiver and x. +func (p Float64Array) Search(x float64) int { return SearchFloat64s(p, x) } // Search returns the result of applying SearchStrings to the receiver and x. diff --git a/src/pkg/sort/search_test.go b/src/pkg/sort/search_test.go index e16e2c93f..939f66af3 100644 --- a/src/pkg/sort/search_test.go +++ b/src/pkg/sort/search_test.go @@ -96,7 +96,7 @@ func TestSearchEfficiency(t *testing.T) { // Smoke tests for convenience wrappers - not comprehensive. -var fdata = []float{0: -3.14, 1: 0, 2: 1, 3: 2, 4: 1000.7} +var fdata = []float64{0: -3.14, 1: 0, 2: 1, 3: 2, 4: 1000.7} var sdata = []string{0: "f", 1: "foo", 2: "foobar", 3: "x"} var wrappertests = []struct { @@ -105,10 +105,10 @@ var wrappertests = []struct { i int }{ {"SearchInts", SearchInts(data, 11), 8}, - {"SearchFloats", SearchFloats(fdata, 2.1), 4}, + {"SearchFloat64s", SearchFloat64s(fdata, 2.1), 4}, {"SearchStrings", SearchStrings(sdata, ""), 0}, {"IntArray.Search", IntArray(data).Search(0), 2}, - {"FloatArray.Search", FloatArray(fdata).Search(2.0), 3}, + {"Float64Array.Search", Float64Array(fdata).Search(2.0), 3}, {"StringArray.Search", StringArray(sdata).Search("x"), 3}, } diff --git a/src/pkg/sort/sort.go b/src/pkg/sort/sort.go index 02e647fca..c7945d21b 100644 --- a/src/pkg/sort/sort.go +++ b/src/pkg/sort/sort.go @@ -166,15 +166,15 @@ func (p IntArray) Swap(i, j int) { p[i], p[j] = p[j], p[i] } func (p IntArray) Sort() { Sort(p) } -// FloatArray attaches the methods of Interface to []float, sorting in increasing order. -type FloatArray []float +// Float64Array attaches the methods of Interface to []float64, sorting in increasing order. +type Float64Array []float64 -func (p FloatArray) Len() int { return len(p) } -func (p FloatArray) Less(i, j int) bool { return p[i] < p[j] } -func (p FloatArray) Swap(i, j int) { p[i], p[j] = p[j], p[i] } +func (p Float64Array) Len() int { return len(p) } +func (p Float64Array) Less(i, j int) bool { return p[i] < p[j] } +func (p Float64Array) Swap(i, j int) { p[i], p[j] = p[j], p[i] } // Sort is a convenience method. -func (p FloatArray) Sort() { Sort(p) } +func (p Float64Array) Sort() { Sort(p) } // StringArray attaches the methods of Interface to []string, sorting in increasing order. @@ -192,15 +192,15 @@ func (p StringArray) Sort() { Sort(p) } // SortInts sorts an array of ints in increasing order. func SortInts(a []int) { Sort(IntArray(a)) } -// SortFloats sorts an array of floats in increasing order. -func SortFloats(a []float) { Sort(FloatArray(a)) } +// SortFloat64s sorts an array of float64s in increasing order. +func SortFloat64s(a []float64) { Sort(Float64Array(a)) } // SortStrings sorts an array of strings in increasing order. func SortStrings(a []string) { Sort(StringArray(a)) } // IntsAreSorted tests whether an array of ints is sorted in increasing order. func IntsAreSorted(a []int) bool { return IsSorted(IntArray(a)) } -// FloatsAreSorted tests whether an array of floats is sorted in increasing order. -func FloatsAreSorted(a []float) bool { return IsSorted(FloatArray(a)) } +// Float64sAreSorted tests whether an array of float64s is sorted in increasing order. +func Float64sAreSorted(a []float64) bool { return IsSorted(Float64Array(a)) } // StringsAreSorted tests whether an array of strings is sorted in increasing order. func StringsAreSorted(a []string) bool { return IsSorted(StringArray(a)) } diff --git a/src/pkg/sort/sort_test.go b/src/pkg/sort/sort_test.go index 2085a67c8..1bea8f032 100644 --- a/src/pkg/sort/sort_test.go +++ b/src/pkg/sort/sort_test.go @@ -13,7 +13,7 @@ import ( var ints = [...]int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586} -var floats = [...]float{74.3, 59.0, 238.2, -784.0, 2.3, 9845.768, -959.7485, 905, 7.8, 7.8} +var float64s = [...]float64{74.3, 59.0, 238.2, -784.0, 2.3, 9845.768, -959.7485, 905, 7.8, 7.8} var strings = [...]string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"} func TestSortIntArray(t *testing.T) { @@ -26,12 +26,12 @@ func TestSortIntArray(t *testing.T) { } } -func TestSortFloatArray(t *testing.T) { - data := floats - a := FloatArray(data[0:]) +func TestSortFloat64Array(t *testing.T) { + data := float64s + a := Float64Array(data[0:]) Sort(a) if !IsSorted(a) { - t.Errorf("sorted %v", floats) + t.Errorf("sorted %v", float64s) t.Errorf(" got %v", data) } } @@ -55,11 +55,11 @@ func TestSortInts(t *testing.T) { } } -func TestSortFloats(t *testing.T) { - data := floats - SortFloats(data[0:]) - if !FloatsAreSorted(data[0:]) { - t.Errorf("sorted %v", floats) +func TestSortFloat64s(t *testing.T) { + data := float64s + SortFloat64s(data[0:]) + if !Float64sAreSorted(data[0:]) { + t.Errorf("sorted %v", float64s) t.Errorf(" got %v", data) } } diff --git a/src/pkg/strconv/atof.go b/src/pkg/strconv/atof.go index bcb138f7a..72f162c51 100644 --- a/src/pkg/strconv/atof.go +++ b/src/pkg/strconv/atof.go @@ -243,7 +243,7 @@ out: // Compute exact floating-point integer from d's digits. // Caller is responsible for avoiding overflow. func decimalAtof64Int(neg bool, d *decimal) float64 { - f := float64(0) + f := 0.0 for i := 0; i < d.nd; i++ { f = f*10 + float64(d.d[i]-'0') } @@ -400,17 +400,6 @@ func Atof64(s string) (f float64, err os.Error) { return f, err } -// Atof is like Atof32 or Atof64, depending on the size of float. -func Atof(s string) (f float, err os.Error) { - if FloatSize == 32 { - f1, err1 := Atof32(s) - return float(f1), err1 - } - f1, err1 := Atof64(s) - return float(f1), err1 -} - - // AtofN converts the string s to a 64-bit floating-point number, // but it rounds the result assuming that it will be stored in a value // of n bits (32 or 64). diff --git a/src/pkg/strconv/atof_test.go b/src/pkg/strconv/atof_test.go index 68c50bfbe..6cc60e549 100644 --- a/src/pkg/strconv/atof_test.go +++ b/src/pkg/strconv/atof_test.go @@ -150,15 +150,6 @@ func testAtof(t *testing.T, opt bool) { test.in, out32, err, test.out, test.err, out) } } - - if FloatSize == 64 || float64(float32(out)) == out { - outf, err := Atof(test.in) - outs := Ftoa(outf, 'g', -1) - if outs != test.out || !reflect.DeepEqual(err, test.err) { - t.Errorf("Ftoa(%v) = %v, %v want %v, %v # %v", - test.in, outf, err, test.out, test.err, out) - } - } } SetOptimize(oldopt) } @@ -167,26 +158,26 @@ func TestAtof(t *testing.T) { testAtof(t, true) } func TestAtofSlow(t *testing.T) { testAtof(t, false) } -func BenchmarkAtofDecimal(b *testing.B) { +func BenchmarkAtof64Decimal(b *testing.B) { for i := 0; i < b.N; i++ { - Atof("33909") + Atof64("33909") } } -func BenchmarkAtofFloat(b *testing.B) { +func BenchmarkAtof64Float(b *testing.B) { for i := 0; i < b.N; i++ { - Atof("339.7784") + Atof64("339.7784") } } -func BenchmarkAtofFloatExp(b *testing.B) { +func BenchmarkAtof64FloatExp(b *testing.B) { for i := 0; i < b.N; i++ { - Atof("-5.09e75") + Atof64("-5.09e75") } } -func BenchmarkAtofBig(b *testing.B) { +func BenchmarkAtof64Big(b *testing.B) { for i := 0; i < b.N; i++ { - Atof("123456789123456789123456789") + Atof64("123456789123456789123456789") } } diff --git a/src/pkg/strconv/ftoa.go b/src/pkg/strconv/ftoa.go index a6091fc6c..4ec3cdbb9 100644 --- a/src/pkg/strconv/ftoa.go +++ b/src/pkg/strconv/ftoa.go @@ -22,20 +22,6 @@ type floatInfo struct { var float32info = floatInfo{23, 8, -127} var float64info = floatInfo{52, 11, -1023} -func floatsize() int { - // Figure out whether float is float32 or float64. - // 1e-35 is representable in both, but 1e-70 - // is too small for a float32. - var f float = 1e-35 - if f*f == 0 { - return 32 - } - return 64 -} - -// Floatsize gives the size of the float type, either 32 or 64. -var FloatSize = floatsize() - // Ftoa32 converts the 32-bit floating-point number f to a string, // according to the format fmt and precision prec. // @@ -77,14 +63,6 @@ func FtoaN(f float64, fmt byte, prec int, n int) string { return Ftoa64(f, fmt, prec) } -// Ftoa behaves as Ftoa32 or Ftoa64, depending on the size of the float type. -func Ftoa(f float, fmt byte, prec int) string { - if FloatSize == 32 { - return Ftoa32(float32(f), fmt, prec) - } - return Ftoa64(float64(f), fmt, prec) -} - func genericFtoa(bits uint64, fmt byte, prec int, flt *floatInfo) string { neg := bits>>flt.expbits>>flt.mantbits != 0 exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1) diff --git a/src/pkg/strconv/ftoa_test.go b/src/pkg/strconv/ftoa_test.go index 6044afdae..3a862a2be 100644 --- a/src/pkg/strconv/ftoa_test.go +++ b/src/pkg/strconv/ftoa_test.go @@ -121,10 +121,6 @@ var ftoatests = []ftoaTest{ } func TestFtoa(t *testing.T) { - if FloatSize != 32 { - println("floatsize: ", FloatSize) - panic("floatsize") - } for i := 0; i < len(ftoatests); i++ { test := &ftoatests[i] s := Ftoa64(test.f, test.fmt, test.prec) diff --git a/src/pkg/testing/quick/quick.go b/src/pkg/testing/quick/quick.go index 0b1659725..a5568b048 100644 --- a/src/pkg/testing/quick/quick.go +++ b/src/pkg/testing/quick/quick.go @@ -60,18 +60,16 @@ func Value(t reflect.Type, rand *rand.Rand) (value reflect.Value, ok bool) { switch concrete := t.(type) { case *reflect.BoolType: return reflect.NewValue(rand.Int()&1 == 0), true - case *reflect.FloatType, *reflect.IntType, *reflect.UintType: + case *reflect.FloatType, *reflect.IntType, *reflect.UintType, *reflect.ComplexType: switch t.Kind() { case reflect.Float32: return reflect.NewValue(randFloat32(rand)), true case reflect.Float64: return reflect.NewValue(randFloat64(rand)), true - case reflect.Float: - if t.Size() == 4 { - return reflect.NewValue(float(randFloat32(rand))), true - } else { - return reflect.NewValue(float(randFloat64(rand))), true - } + case reflect.Complex64: + return reflect.NewValue(complex(randFloat32(rand), randFloat32(rand))), true + case reflect.Complex128: + return reflect.NewValue(complex(randFloat64(rand), randFloat64(rand))), true case reflect.Int16: return reflect.NewValue(int16(randInt64(rand))), true case reflect.Int32: @@ -157,7 +155,7 @@ type Config struct { MaxCount int // MaxCountScale is a non-negative scale factor applied to the default // maximum. If zero, the default is unchanged. - MaxCountScale float + MaxCountScale float64 // If non-nil, rand is a source of random numbers. Otherwise a default // pseudo-random source will be used. Rand *rand.Rand @@ -183,7 +181,7 @@ func (c *Config) getMaxCount() (maxCount int) { maxCount = c.MaxCount if maxCount == 0 { if c.MaxCountScale != 0 { - maxCount = int(c.MaxCountScale * float(*defaultMaxCount)) + maxCount = int(c.MaxCountScale * float64(*defaultMaxCount)) } else { maxCount = *defaultMaxCount } diff --git a/src/pkg/testing/quick/quick_test.go b/src/pkg/testing/quick/quick_test.go index c7bff962b..b126e4a16 100644 --- a/src/pkg/testing/quick/quick_test.go +++ b/src/pkg/testing/quick/quick_test.go @@ -17,7 +17,9 @@ func fFloat32(a float32) float32 { return a } func fFloat64(a float64) float64 { return a } -func fFloat(a float) float { return a } +func fComplex64(a complex64) complex64 { return a } + +func fComplex128(a complex128) complex128 { return a } func fInt16(a int16) int16 { return a } @@ -71,7 +73,8 @@ func TestCheckEqual(t *testing.T) { reportError("fBool", CheckEqual(fBool, fBool, nil), t) reportError("fFloat32", CheckEqual(fFloat32, fFloat32, nil), t) reportError("fFloat64", CheckEqual(fFloat64, fFloat64, nil), t) - reportError("fFloat", CheckEqual(fFloat, fFloat, nil), t) + reportError("fComplex64", CheckEqual(fComplex64, fComplex64, nil), t) + reportError("fComplex128", CheckEqual(fComplex128, fComplex128, nil), t) reportError("fInt16", CheckEqual(fInt16, fInt16, nil), t) reportError("fInt32", CheckEqual(fInt32, fInt32, nil), t) reportError("fInt64", CheckEqual(fInt64, fInt64, nil), t) diff --git a/src/pkg/xml/xml_test.go b/src/pkg/xml/xml_test.go index 9ab199a30..317ecabd9 100644 --- a/src/pkg/xml/xml_test.go +++ b/src/pkg/xml/xml_test.go @@ -227,7 +227,6 @@ type allScalars struct { Uint32 uint32 Uint64 uint64 Uintptr uintptr - Float float Float32 float32 Float64 float64 String string @@ -249,7 +248,6 @@ var all = allScalars{ Uint32: 9, Uint64: 10, Uintptr: 11, - Float: 12.0, Float32: 13.0, Float64: 14.0, String: "15", diff --git a/test/append.go b/test/append.go index 17c665227..96421c36b 100644 --- a/test/append.go +++ b/test/append.go @@ -193,7 +193,7 @@ func verifyInterface() { case 2: e[i] = fmt.Sprintf("%d", i) case 3: - e[i] = float(i) + e[i] = float64(i) } } diff --git a/test/blank.go b/test/blank.go index 6e69f8aaa..681a5e77c 100644 --- a/test/blank.go +++ b/test/blank.go @@ -28,7 +28,7 @@ const ( c4 ) -var ints = []string { +var ints = []string{ "1", "2", "3", @@ -36,15 +36,15 @@ var ints = []string { func f() (int, int) { call += "f" - return 1,2 + return 1, 2 } -func g() (float, float) { +func g() (float64, float64) { call += "g" - return 3,4 + return 3, 4 } -func h(_ int, _ float) { +func h(_ int, _ float64) { } func i() int { @@ -55,43 +55,64 @@ func i() int { var _ = i() func main() { - if call != "i" {panic("init did not run")} + if call != "i" { + panic("init did not run") + } call = "" _, _ = f() a, _ := f() - if a != 1 {panic(a)} + if a != 1 { + panic(a) + } b, _ := g() - if b != 3 {panic(b)} + if b != 3 { + panic(b) + } _, a = f() - if a != 2 {panic(a)} + if a != 2 { + panic(a) + } _, b = g() - if b != 4 {panic(b)} + if b != 4 { + panic(b) + } _ = i() - if call != "ffgfgi" {panic(call)} - if c4 != 4 {panic(c4)} + if call != "ffgfgi" { + panic(call) + } + if c4 != 4 { + panic(c4) + } out := "" for _, s := range ints { out += s } - if out != "123" {panic(out)} + if out != "123" { + panic(out) + } sum := 0 for s := range ints { sum += s } - if sum != 3 {panic(sum)} + if sum != 3 { + panic(sum) + } - h(a,b) + h(a, b) } // useless but legal var _ int = 1 var _ = 2 var _, _ = 3, 4 + const _ = 3 const _, _ = 4, 5 + type _ int + func _() { panic("oops") } diff --git a/test/cmplx.go b/test/cmplx.go index fad96c605..d5a77d684 100644 --- a/test/cmplx.go +++ b/test/cmplx.go @@ -7,26 +7,19 @@ package main var ( - f float f32 float32 f64 float64 - c complex - c64 complex64 + c64 complex64 c128 complex128 ) - + func main() { // ok - c = cmplx(f, f) - c64 = cmplx(f32, f32) - c128 = cmplx(f64, f64) + c64 = complex(f32, f32) + c128 = complex(f64, f64) - _ = complex(0) // ok - _ = cmplx(f, f32) // ERROR "cmplx" - _ = cmplx(f, f64) // ERROR "cmplx" - _ = cmplx(f32, f) // ERROR "cmplx" - _ = cmplx(f32, f64) // ERROR "cmplx" - _ = cmplx(f64, f) // ERROR "cmplx" - _ = cmplx(f64, f32) // ERROR "cmplx" + _ = complex128(0) // ok + _ = complex(f32, f64) // ERROR "complex" + _ = complex(f64, f32) // ERROR "complex" } diff --git a/test/cmplxdivide.c b/test/cmplxdivide.c index b3c6055ed..b340f04d8 100644 --- a/test/cmplxdivide.c +++ b/test/cmplxdivide.c @@ -72,7 +72,7 @@ main(void) if(iscnan(n) && d == 0) q = (NAN+NAN*I) / zero; - printf("\tTest{cmplx(%s, %s), cmplx(%s, %s), cmplx(%s, %s)},\n", + printf("\tTest{complex(%s, %s), complex(%s, %s), complex(%s, %s)},\n", fmt(creal(n)), fmt(cimag(n)), fmt(creal(d)), fmt(cimag(d)), fmt(creal(q)), fmt(cimag(q))); diff --git a/test/cmplxdivide1.go b/test/cmplxdivide1.go index 96ea704a3..6a1dee9fe 100644 --- a/test/cmplxdivide1.go +++ b/test/cmplxdivide1.go @@ -1,2407 +1,2406 @@ // # generated by cmplxdivide.c package main - var tests = []Test{ - Test{cmplx(0, 0), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(0, 1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(0, -1), cmplx(negzero, 0)}, - Test{cmplx(0, 0), cmplx(0, 2), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 0), cmplx(1, 0), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(1, 1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(1, -1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(1, 2), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 0), cmplx(-1, 0), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-1, 1), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-1, -1), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-1, 2), cmplx(0, negzero)}, - Test{cmplx(0, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(0, 0), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(2, 0), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(2, 1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(2, -1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(2, 2), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, 0), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(0, 0), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, nan), cmplx(0, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(0, 0), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(0, 0), cmplx(nan, inf)}, - Test{cmplx(0, 1), cmplx(0, 1), cmplx(1, 0)}, - Test{cmplx(0, 1), cmplx(0, -1), cmplx(-1, 0)}, - Test{cmplx(0, 1), cmplx(0, 2), cmplx(0.5, 0)}, - Test{cmplx(0, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(1, 0), cmplx(0, 1)}, - Test{cmplx(0, 1), cmplx(1, 1), cmplx(0.5, 0.5)}, - Test{cmplx(0, 1), cmplx(1, -1), cmplx(-0.5, 0.5)}, - Test{cmplx(0, 1), cmplx(1, 2), cmplx(0.4, 0.2)}, - Test{cmplx(0, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(-1, 0), cmplx(negzero, -1)}, - Test{cmplx(0, 1), cmplx(-1, 1), cmplx(0.5, -0.5)}, - Test{cmplx(0, 1), cmplx(-1, -1), cmplx(-0.5, -0.5)}, - Test{cmplx(0, 1), cmplx(-1, 2), cmplx(0.4, -0.2)}, - Test{cmplx(0, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(0, 1), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(0, 1), cmplx(2, 0), cmplx(0, 0.5)}, - Test{cmplx(0, 1), cmplx(2, 1), cmplx(0.2, 0.4)}, - Test{cmplx(0, 1), cmplx(2, -1), cmplx(-0.2, 0.4)}, - Test{cmplx(0, 1), cmplx(2, 2), cmplx(0.25, 0.25)}, - Test{cmplx(0, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, 1), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(0, 1), cmplx(inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 1), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, nan), cmplx(0, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(0, 1), cmplx(-inf, -inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(0, 0), cmplx(nan, -inf)}, - Test{cmplx(0, -1), cmplx(0, 1), cmplx(-1, negzero)}, - Test{cmplx(0, -1), cmplx(0, -1), cmplx(1, negzero)}, - Test{cmplx(0, -1), cmplx(0, 2), cmplx(-0.5, negzero)}, - Test{cmplx(0, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(0, inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(0, -inf), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(1, 0), cmplx(0, -1)}, - Test{cmplx(0, -1), cmplx(1, 1), cmplx(-0.5, -0.5)}, - Test{cmplx(0, -1), cmplx(1, -1), cmplx(0.5, -0.5)}, - Test{cmplx(0, -1), cmplx(1, 2), cmplx(-0.4, -0.2)}, - Test{cmplx(0, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(1, inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(1, -inf), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(-1, 0), cmplx(negzero, 1)}, - Test{cmplx(0, -1), cmplx(-1, 1), cmplx(-0.5, 0.5)}, - Test{cmplx(0, -1), cmplx(-1, -1), cmplx(0.5, 0.5)}, - Test{cmplx(0, -1), cmplx(-1, 2), cmplx(-0.4, 0.2)}, - Test{cmplx(0, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(-1, inf), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-1, -inf), cmplx(0, 0)}, - Test{cmplx(0, -1), cmplx(2, 0), cmplx(0, -0.5)}, - Test{cmplx(0, -1), cmplx(2, 1), cmplx(-0.2, -0.4)}, - Test{cmplx(0, -1), cmplx(2, -1), cmplx(0.2, -0.4)}, - Test{cmplx(0, -1), cmplx(2, 2), cmplx(-0.25, -0.25)}, - Test{cmplx(0, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(2, inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(2, -inf), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, -1), cmplx(nan, inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(0, -1), cmplx(inf, 0), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(inf, 1), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(inf, -1), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(inf, 2), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(inf, nan), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(inf, inf), cmplx(negzero, negzero)}, - Test{cmplx(0, -1), cmplx(inf, -inf), cmplx(0, negzero)}, - Test{cmplx(0, -1), cmplx(-inf, 0), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, 1), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, -1), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, 2), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, nan), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, inf), cmplx(negzero, 0)}, - Test{cmplx(0, -1), cmplx(-inf, -inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(0, 0), cmplx(nan, inf)}, - Test{cmplx(0, 2), cmplx(0, 1), cmplx(2, 0)}, - Test{cmplx(0, 2), cmplx(0, -1), cmplx(-2, 0)}, - Test{cmplx(0, 2), cmplx(0, 2), cmplx(1, 0)}, - Test{cmplx(0, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 2), cmplx(1, 0), cmplx(0, 2)}, - Test{cmplx(0, 2), cmplx(1, 1), cmplx(1, 1)}, - Test{cmplx(0, 2), cmplx(1, -1), cmplx(-1, 1)}, - Test{cmplx(0, 2), cmplx(1, 2), cmplx(0.8, 0.4)}, - Test{cmplx(0, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 2), cmplx(-1, 0), cmplx(negzero, -2)}, - Test{cmplx(0, 2), cmplx(-1, 1), cmplx(1, -1)}, - Test{cmplx(0, 2), cmplx(-1, -1), cmplx(-1, -1)}, - Test{cmplx(0, 2), cmplx(-1, 2), cmplx(0.8, -0.4)}, - Test{cmplx(0, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(0, 2), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(0, 2), cmplx(2, 0), cmplx(0, 1)}, - Test{cmplx(0, 2), cmplx(2, 1), cmplx(0.4, 0.8)}, - Test{cmplx(0, 2), cmplx(2, -1), cmplx(-0.4, 0.8)}, - Test{cmplx(0, 2), cmplx(2, 2), cmplx(0.5, 0.5)}, - Test{cmplx(0, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, 2), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 2), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(0, 2), cmplx(inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(0, 2), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, nan), cmplx(0, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(0, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)}, - Test{cmplx(0, nan), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(0, 0), cmplx(nan, inf)}, - Test{cmplx(0, inf), cmplx(0, 1), cmplx(inf, nan)}, - Test{cmplx(0, inf), cmplx(0, -1), cmplx(-inf, nan)}, - Test{cmplx(0, inf), cmplx(0, 2), cmplx(inf, nan)}, - Test{cmplx(0, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(1, 0), cmplx(nan, inf)}, - Test{cmplx(0, inf), cmplx(1, 1), cmplx(inf, inf)}, - Test{cmplx(0, inf), cmplx(1, -1), cmplx(-inf, inf)}, - Test{cmplx(0, inf), cmplx(1, 2), cmplx(inf, inf)}, - Test{cmplx(0, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-1, 0), cmplx(nan, -inf)}, - Test{cmplx(0, inf), cmplx(-1, 1), cmplx(inf, -inf)}, - Test{cmplx(0, inf), cmplx(-1, -1), cmplx(-inf, -inf)}, - Test{cmplx(0, inf), cmplx(-1, 2), cmplx(inf, -inf)}, - Test{cmplx(0, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(2, 0), cmplx(nan, inf)}, - Test{cmplx(0, inf), cmplx(2, 1), cmplx(inf, inf)}, - Test{cmplx(0, inf), cmplx(2, -1), cmplx(-inf, inf)}, - Test{cmplx(0, inf), cmplx(2, 2), cmplx(inf, inf)}, - Test{cmplx(0, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(0, 0), cmplx(nan, -inf)}, - Test{cmplx(0, -inf), cmplx(0, 1), cmplx(-inf, nan)}, - Test{cmplx(0, -inf), cmplx(0, -1), cmplx(inf, nan)}, - Test{cmplx(0, -inf), cmplx(0, 2), cmplx(-inf, nan)}, - Test{cmplx(0, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(1, 0), cmplx(nan, -inf)}, - Test{cmplx(0, -inf), cmplx(1, 1), cmplx(-inf, -inf)}, - Test{cmplx(0, -inf), cmplx(1, -1), cmplx(inf, -inf)}, - Test{cmplx(0, -inf), cmplx(1, 2), cmplx(-inf, -inf)}, - Test{cmplx(0, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-1, 0), cmplx(nan, inf)}, - Test{cmplx(0, -inf), cmplx(-1, 1), cmplx(-inf, inf)}, - Test{cmplx(0, -inf), cmplx(-1, -1), cmplx(inf, inf)}, - Test{cmplx(0, -inf), cmplx(-1, 2), cmplx(-inf, inf)}, - Test{cmplx(0, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(2, 0), cmplx(nan, -inf)}, - Test{cmplx(0, -inf), cmplx(2, 1), cmplx(-inf, -inf)}, - Test{cmplx(0, -inf), cmplx(2, -1), cmplx(inf, -inf)}, - Test{cmplx(0, -inf), cmplx(2, 2), cmplx(-inf, -inf)}, - Test{cmplx(0, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(0, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(0, 0), cmplx(inf, nan)}, - Test{cmplx(1, 0), cmplx(0, 1), cmplx(0, -1)}, - Test{cmplx(1, 0), cmplx(0, -1), cmplx(negzero, 1)}, - Test{cmplx(1, 0), cmplx(0, 2), cmplx(0, -0.5)}, - Test{cmplx(1, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 0), cmplx(1, 0), cmplx(1, 0)}, - Test{cmplx(1, 0), cmplx(1, 1), cmplx(0.5, -0.5)}, - Test{cmplx(1, 0), cmplx(1, -1), cmplx(0.5, 0.5)}, - Test{cmplx(1, 0), cmplx(1, 2), cmplx(0.2, -0.4)}, - Test{cmplx(1, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 0), cmplx(-1, 0), cmplx(-1, negzero)}, - Test{cmplx(1, 0), cmplx(-1, 1), cmplx(-0.5, -0.5)}, - Test{cmplx(1, 0), cmplx(-1, -1), cmplx(-0.5, 0.5)}, - Test{cmplx(1, 0), cmplx(-1, 2), cmplx(-0.2, -0.4)}, - Test{cmplx(1, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 0), cmplx(2, 0), cmplx(0.5, 0)}, - Test{cmplx(1, 0), cmplx(2, 1), cmplx(0.4, -0.2)}, - Test{cmplx(1, 0), cmplx(2, -1), cmplx(0.4, 0.2)}, - Test{cmplx(1, 0), cmplx(2, 2), cmplx(0.25, -0.25)}, - Test{cmplx(1, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, 0), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(inf, inf), cmplx(0, negzero)}, - Test{cmplx(1, 0), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(1, 0), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, 0), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(1, 1), cmplx(0, 1), cmplx(1, -1)}, - Test{cmplx(1, 1), cmplx(0, -1), cmplx(-1, 1)}, - Test{cmplx(1, 1), cmplx(0, 2), cmplx(0.5, -0.5)}, - Test{cmplx(1, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(1, 0), cmplx(1, 1)}, - Test{cmplx(1, 1), cmplx(1, 1), cmplx(1, 0)}, - Test{cmplx(1, 1), cmplx(1, -1), cmplx(0, 1)}, - Test{cmplx(1, 1), cmplx(1, 2), cmplx(0.6, -0.2)}, - Test{cmplx(1, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(-1, 0), cmplx(-1, -1)}, - Test{cmplx(1, 1), cmplx(-1, 1), cmplx(negzero, -1)}, - Test{cmplx(1, 1), cmplx(-1, -1), cmplx(-1, negzero)}, - Test{cmplx(1, 1), cmplx(-1, 2), cmplx(0.2, -0.6)}, - Test{cmplx(1, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(2, 0), cmplx(0.5, 0.5)}, - Test{cmplx(1, 1), cmplx(2, 1), cmplx(0.6, 0.2)}, - Test{cmplx(1, 1), cmplx(2, -1), cmplx(0.2, 0.6)}, - Test{cmplx(1, 1), cmplx(2, 2), cmplx(0.5, 0)}, - Test{cmplx(1, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, 1), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 1), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(1, 1), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(1, 1), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(1, -1), cmplx(0, 1), cmplx(-1, -1)}, - Test{cmplx(1, -1), cmplx(0, -1), cmplx(1, 1)}, - Test{cmplx(1, -1), cmplx(0, 2), cmplx(-0.5, -0.5)}, - Test{cmplx(1, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(0, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, -1), cmplx(0, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(1, 0), cmplx(1, -1)}, - Test{cmplx(1, -1), cmplx(1, 1), cmplx(0, -1)}, - Test{cmplx(1, -1), cmplx(1, -1), cmplx(1, 0)}, - Test{cmplx(1, -1), cmplx(1, 2), cmplx(-0.2, -0.6)}, - Test{cmplx(1, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(1, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, -1), cmplx(1, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(-1, 0), cmplx(-1, 1)}, - Test{cmplx(1, -1), cmplx(-1, 1), cmplx(-1, negzero)}, - Test{cmplx(1, -1), cmplx(-1, -1), cmplx(negzero, 1)}, - Test{cmplx(1, -1), cmplx(-1, 2), cmplx(-0.6, -0.2)}, - Test{cmplx(1, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(-1, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, -1), cmplx(-1, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(2, 0), cmplx(0.5, -0.5)}, - Test{cmplx(1, -1), cmplx(2, 1), cmplx(0.2, -0.6)}, - Test{cmplx(1, -1), cmplx(2, -1), cmplx(0.6, -0.2)}, - Test{cmplx(1, -1), cmplx(2, 2), cmplx(0, -0.5)}, - Test{cmplx(1, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(2, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, -1), cmplx(2, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, -1), cmplx(nan, inf), cmplx(negzero, negzero)}, - Test{cmplx(1, -1), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(inf, 0), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, 1), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, -1), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, 2), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, nan), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, inf), cmplx(0, negzero)}, - Test{cmplx(1, -1), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(1, -1), cmplx(-inf, 0), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, 1), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, -1), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, 2), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, nan), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, inf), cmplx(negzero, 0)}, - Test{cmplx(1, -1), cmplx(-inf, -inf), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(1, 2), cmplx(0, 1), cmplx(2, -1)}, - Test{cmplx(1, 2), cmplx(0, -1), cmplx(-2, 1)}, - Test{cmplx(1, 2), cmplx(0, 2), cmplx(1, -0.5)}, - Test{cmplx(1, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(1, 0), cmplx(1, 2)}, - Test{cmplx(1, 2), cmplx(1, 1), cmplx(1.5, 0.5)}, - Test{cmplx(1, 2), cmplx(1, -1), cmplx(-0.5, 1.5)}, - Test{cmplx(1, 2), cmplx(1, 2), cmplx(1, 0)}, - Test{cmplx(1, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(-1, 0), cmplx(-1, -2)}, - Test{cmplx(1, 2), cmplx(-1, 1), cmplx(0.5, -1.5)}, - Test{cmplx(1, 2), cmplx(-1, -1), cmplx(-1.5, -0.5)}, - Test{cmplx(1, 2), cmplx(-1, 2), cmplx(0.6, -0.8)}, - Test{cmplx(1, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(2, 0), cmplx(0.5, 1)}, - Test{cmplx(1, 2), cmplx(2, 1), cmplx(0.8, 0.6)}, - Test{cmplx(1, 2), cmplx(2, -1), cmplx(0, 1)}, - Test{cmplx(1, 2), cmplx(2, 2), cmplx(0.75, 0.25)}, - Test{cmplx(1, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, 2), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(1, 2), cmplx(inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(1, 2), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(1, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)}, - Test{cmplx(1, nan), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(1, inf), cmplx(0, 1), cmplx(inf, nan)}, - Test{cmplx(1, inf), cmplx(0, -1), cmplx(-inf, nan)}, - Test{cmplx(1, inf), cmplx(0, 2), cmplx(inf, nan)}, - Test{cmplx(1, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(1, 0), cmplx(nan, inf)}, - Test{cmplx(1, inf), cmplx(1, 1), cmplx(inf, inf)}, - Test{cmplx(1, inf), cmplx(1, -1), cmplx(-inf, inf)}, - Test{cmplx(1, inf), cmplx(1, 2), cmplx(inf, inf)}, - Test{cmplx(1, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-1, 0), cmplx(nan, -inf)}, - Test{cmplx(1, inf), cmplx(-1, 1), cmplx(inf, -inf)}, - Test{cmplx(1, inf), cmplx(-1, -1), cmplx(-inf, -inf)}, - Test{cmplx(1, inf), cmplx(-1, 2), cmplx(inf, -inf)}, - Test{cmplx(1, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(2, 0), cmplx(nan, inf)}, - Test{cmplx(1, inf), cmplx(2, 1), cmplx(inf, inf)}, - Test{cmplx(1, inf), cmplx(2, -1), cmplx(-inf, inf)}, - Test{cmplx(1, inf), cmplx(2, 2), cmplx(inf, inf)}, - Test{cmplx(1, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(1, -inf), cmplx(0, 1), cmplx(-inf, nan)}, - Test{cmplx(1, -inf), cmplx(0, -1), cmplx(inf, nan)}, - Test{cmplx(1, -inf), cmplx(0, 2), cmplx(-inf, nan)}, - Test{cmplx(1, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(1, 0), cmplx(nan, -inf)}, - Test{cmplx(1, -inf), cmplx(1, 1), cmplx(-inf, -inf)}, - Test{cmplx(1, -inf), cmplx(1, -1), cmplx(inf, -inf)}, - Test{cmplx(1, -inf), cmplx(1, 2), cmplx(-inf, -inf)}, - Test{cmplx(1, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-1, 0), cmplx(nan, inf)}, - Test{cmplx(1, -inf), cmplx(-1, 1), cmplx(-inf, inf)}, - Test{cmplx(1, -inf), cmplx(-1, -1), cmplx(inf, inf)}, - Test{cmplx(1, -inf), cmplx(-1, 2), cmplx(-inf, inf)}, - Test{cmplx(1, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(2, 0), cmplx(nan, -inf)}, - Test{cmplx(1, -inf), cmplx(2, 1), cmplx(-inf, -inf)}, - Test{cmplx(1, -inf), cmplx(2, -1), cmplx(inf, -inf)}, - Test{cmplx(1, -inf), cmplx(2, 2), cmplx(-inf, -inf)}, - Test{cmplx(1, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(1, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(0, 0), cmplx(-inf, nan)}, - Test{cmplx(-1, 0), cmplx(0, 1), cmplx(0, 1)}, - Test{cmplx(-1, 0), cmplx(0, -1), cmplx(negzero, -1)}, - Test{cmplx(-1, 0), cmplx(0, 2), cmplx(0, 0.5)}, - Test{cmplx(-1, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(0, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(1, 0), cmplx(-1, 0)}, - Test{cmplx(-1, 0), cmplx(1, 1), cmplx(-0.5, 0.5)}, - Test{cmplx(-1, 0), cmplx(1, -1), cmplx(-0.5, -0.5)}, - Test{cmplx(-1, 0), cmplx(1, 2), cmplx(-0.2, 0.4)}, - Test{cmplx(-1, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(-1, 0), cmplx(1, negzero)}, - Test{cmplx(-1, 0), cmplx(-1, 1), cmplx(0.5, 0.5)}, - Test{cmplx(-1, 0), cmplx(-1, -1), cmplx(0.5, -0.5)}, - Test{cmplx(-1, 0), cmplx(-1, 2), cmplx(0.2, 0.4)}, - Test{cmplx(-1, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(-1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(2, 0), cmplx(-0.5, 0)}, - Test{cmplx(-1, 0), cmplx(2, 1), cmplx(-0.4, 0.2)}, - Test{cmplx(-1, 0), cmplx(2, -1), cmplx(-0.4, -0.2)}, - Test{cmplx(-1, 0), cmplx(2, 2), cmplx(-0.25, 0.25)}, - Test{cmplx(-1, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(2, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 0), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(nan, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(inf, 0), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, 1), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, -1), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, 2), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, nan), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, 0), cmplx(inf, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 0), cmplx(-inf, 0), cmplx(0, negzero)}, - Test{cmplx(-1, 0), cmplx(-inf, 1), cmplx(0, negzero)}, - Test{cmplx(-1, 0), cmplx(-inf, -1), cmplx(0, negzero)}, - Test{cmplx(-1, 0), cmplx(-inf, 2), cmplx(0, negzero)}, - Test{cmplx(-1, 0), cmplx(-inf, nan), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(-inf, inf), cmplx(0, 0)}, - Test{cmplx(-1, 0), cmplx(-inf, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-1, 1), cmplx(0, 1), cmplx(1, 1)}, - Test{cmplx(-1, 1), cmplx(0, -1), cmplx(-1, -1)}, - Test{cmplx(-1, 1), cmplx(0, 2), cmplx(0.5, 0.5)}, - Test{cmplx(-1, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(0, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 1), cmplx(1, 0), cmplx(-1, 1)}, - Test{cmplx(-1, 1), cmplx(1, 1), cmplx(0, 1)}, - Test{cmplx(-1, 1), cmplx(1, -1), cmplx(-1, 0)}, - Test{cmplx(-1, 1), cmplx(1, 2), cmplx(0.2, 0.6)}, - Test{cmplx(-1, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 1), cmplx(-1, 0), cmplx(1, -1)}, - Test{cmplx(-1, 1), cmplx(-1, 1), cmplx(1, negzero)}, - Test{cmplx(-1, 1), cmplx(-1, -1), cmplx(negzero, -1)}, - Test{cmplx(-1, 1), cmplx(-1, 2), cmplx(0.6, 0.2)}, - Test{cmplx(-1, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(-1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 1), cmplx(2, 0), cmplx(-0.5, 0.5)}, - Test{cmplx(-1, 1), cmplx(2, 1), cmplx(-0.2, 0.6)}, - Test{cmplx(-1, 1), cmplx(2, -1), cmplx(-0.6, 0.2)}, - Test{cmplx(-1, 1), cmplx(2, 2), cmplx(0, 0.5)}, - Test{cmplx(-1, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(2, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 1), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(nan, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 1), cmplx(inf, 0), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(inf, 1), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(inf, -1), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(inf, 2), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(inf, nan), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(-1, 1), cmplx(-inf, 0), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(-inf, 1), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(-inf, -1), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(-inf, 2), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(-inf, nan), cmplx(0, negzero)}, - Test{cmplx(-1, 1), cmplx(-inf, inf), cmplx(0, 0)}, - Test{cmplx(-1, 1), cmplx(-inf, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(0, 0), cmplx(-inf, -inf)}, - Test{cmplx(-1, -1), cmplx(0, 1), cmplx(-1, 1)}, - Test{cmplx(-1, -1), cmplx(0, -1), cmplx(1, -1)}, - Test{cmplx(-1, -1), cmplx(0, 2), cmplx(-0.5, 0.5)}, - Test{cmplx(-1, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(0, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(0, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(1, 0), cmplx(-1, -1)}, - Test{cmplx(-1, -1), cmplx(1, 1), cmplx(-1, 0)}, - Test{cmplx(-1, -1), cmplx(1, -1), cmplx(0, -1)}, - Test{cmplx(-1, -1), cmplx(1, 2), cmplx(-0.6, 0.2)}, - Test{cmplx(-1, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(1, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(1, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(-1, 0), cmplx(1, 1)}, - Test{cmplx(-1, -1), cmplx(-1, 1), cmplx(negzero, 1)}, - Test{cmplx(-1, -1), cmplx(-1, -1), cmplx(1, negzero)}, - Test{cmplx(-1, -1), cmplx(-1, 2), cmplx(-0.2, 0.6)}, - Test{cmplx(-1, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(-1, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(-1, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(2, 0), cmplx(-0.5, -0.5)}, - Test{cmplx(-1, -1), cmplx(2, 1), cmplx(-0.6, -0.2)}, - Test{cmplx(-1, -1), cmplx(2, -1), cmplx(-0.2, -0.6)}, - Test{cmplx(-1, -1), cmplx(2, 2), cmplx(-0.5, 0)}, - Test{cmplx(-1, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(2, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(2, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -1), cmplx(nan, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(nan, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(-1, -1), cmplx(inf, inf), cmplx(negzero, 0)}, - Test{cmplx(-1, -1), cmplx(inf, -inf), cmplx(0, negzero)}, - Test{cmplx(-1, -1), cmplx(-inf, 0), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, 1), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, -1), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, 2), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, nan), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, inf), cmplx(0, 0)}, - Test{cmplx(-1, -1), cmplx(-inf, -inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-1, 2), cmplx(0, 1), cmplx(2, 1)}, - Test{cmplx(-1, 2), cmplx(0, -1), cmplx(-2, -1)}, - Test{cmplx(-1, 2), cmplx(0, 2), cmplx(1, 0.5)}, - Test{cmplx(-1, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(0, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(0, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 2), cmplx(1, 0), cmplx(-1, 2)}, - Test{cmplx(-1, 2), cmplx(1, 1), cmplx(0.5, 1.5)}, - Test{cmplx(-1, 2), cmplx(1, -1), cmplx(-1.5, 0.5)}, - Test{cmplx(-1, 2), cmplx(1, 2), cmplx(0.6, 0.8)}, - Test{cmplx(-1, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 2), cmplx(-1, 0), cmplx(1, -2)}, - Test{cmplx(-1, 2), cmplx(-1, 1), cmplx(1.5, -0.5)}, - Test{cmplx(-1, 2), cmplx(-1, -1), cmplx(-0.5, -1.5)}, - Test{cmplx(-1, 2), cmplx(-1, 2), cmplx(1, 0)}, - Test{cmplx(-1, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(-1, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(-1, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 2), cmplx(2, 0), cmplx(-0.5, 1)}, - Test{cmplx(-1, 2), cmplx(2, 1), cmplx(0, 1)}, - Test{cmplx(-1, 2), cmplx(2, -1), cmplx(-0.8, 0.6)}, - Test{cmplx(-1, 2), cmplx(2, 2), cmplx(0.25, 0.75)}, - Test{cmplx(-1, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(2, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(2, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, 2), cmplx(nan, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(nan, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, 2), cmplx(inf, 0), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(inf, 1), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(inf, -1), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(inf, 2), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(inf, nan), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(-1, 2), cmplx(inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(-1, 2), cmplx(-inf, 0), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, 1), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, -1), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, 2), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, nan), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(-1, 2), cmplx(-inf, -inf), cmplx(negzero, negzero)}, - Test{cmplx(-1, nan), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-1, inf), cmplx(0, 1), cmplx(inf, nan)}, - Test{cmplx(-1, inf), cmplx(0, -1), cmplx(-inf, nan)}, - Test{cmplx(-1, inf), cmplx(0, 2), cmplx(inf, nan)}, - Test{cmplx(-1, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(1, 0), cmplx(nan, inf)}, - Test{cmplx(-1, inf), cmplx(1, 1), cmplx(inf, inf)}, - Test{cmplx(-1, inf), cmplx(1, -1), cmplx(-inf, inf)}, - Test{cmplx(-1, inf), cmplx(1, 2), cmplx(inf, inf)}, - Test{cmplx(-1, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-1, 0), cmplx(nan, -inf)}, - Test{cmplx(-1, inf), cmplx(-1, 1), cmplx(inf, -inf)}, - Test{cmplx(-1, inf), cmplx(-1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-1, inf), cmplx(-1, 2), cmplx(inf, -inf)}, - Test{cmplx(-1, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(2, 0), cmplx(nan, inf)}, - Test{cmplx(-1, inf), cmplx(2, 1), cmplx(inf, inf)}, - Test{cmplx(-1, inf), cmplx(2, -1), cmplx(-inf, inf)}, - Test{cmplx(-1, inf), cmplx(2, 2), cmplx(inf, inf)}, - Test{cmplx(-1, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(0, 0), cmplx(-inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(0, 1), cmplx(-inf, nan)}, - Test{cmplx(-1, -inf), cmplx(0, -1), cmplx(inf, nan)}, - Test{cmplx(-1, -inf), cmplx(0, 2), cmplx(-inf, nan)}, - Test{cmplx(-1, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(1, 0), cmplx(nan, -inf)}, - Test{cmplx(-1, -inf), cmplx(1, 1), cmplx(-inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(1, -1), cmplx(inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(1, 2), cmplx(-inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-1, 0), cmplx(nan, inf)}, - Test{cmplx(-1, -inf), cmplx(-1, 1), cmplx(-inf, inf)}, - Test{cmplx(-1, -inf), cmplx(-1, -1), cmplx(inf, inf)}, - Test{cmplx(-1, -inf), cmplx(-1, 2), cmplx(-inf, inf)}, - Test{cmplx(-1, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(2, 0), cmplx(nan, -inf)}, - Test{cmplx(-1, -inf), cmplx(2, 1), cmplx(-inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(2, -1), cmplx(inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(2, 2), cmplx(-inf, -inf)}, - Test{cmplx(-1, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-1, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(0, 0), cmplx(inf, nan)}, - Test{cmplx(2, 0), cmplx(0, 1), cmplx(0, -2)}, - Test{cmplx(2, 0), cmplx(0, -1), cmplx(negzero, 2)}, - Test{cmplx(2, 0), cmplx(0, 2), cmplx(0, -1)}, - Test{cmplx(2, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 0), cmplx(1, 0), cmplx(2, 0)}, - Test{cmplx(2, 0), cmplx(1, 1), cmplx(1, -1)}, - Test{cmplx(2, 0), cmplx(1, -1), cmplx(1, 1)}, - Test{cmplx(2, 0), cmplx(1, 2), cmplx(0.4, -0.8)}, - Test{cmplx(2, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 0), cmplx(-1, 0), cmplx(-2, negzero)}, - Test{cmplx(2, 0), cmplx(-1, 1), cmplx(-1, -1)}, - Test{cmplx(2, 0), cmplx(-1, -1), cmplx(-1, 1)}, - Test{cmplx(2, 0), cmplx(-1, 2), cmplx(-0.4, -0.8)}, - Test{cmplx(2, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 0), cmplx(2, 0), cmplx(1, 0)}, - Test{cmplx(2, 0), cmplx(2, 1), cmplx(0.8, -0.4)}, - Test{cmplx(2, 0), cmplx(2, -1), cmplx(0.8, 0.4)}, - Test{cmplx(2, 0), cmplx(2, 2), cmplx(0.5, -0.5)}, - Test{cmplx(2, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, 0), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(inf, inf), cmplx(0, negzero)}, - Test{cmplx(2, 0), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(2, 0), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, 0), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(2, 1), cmplx(0, 1), cmplx(1, -2)}, - Test{cmplx(2, 1), cmplx(0, -1), cmplx(-1, 2)}, - Test{cmplx(2, 1), cmplx(0, 2), cmplx(0.5, -1)}, - Test{cmplx(2, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(1, 0), cmplx(2, 1)}, - Test{cmplx(2, 1), cmplx(1, 1), cmplx(1.5, -0.5)}, - Test{cmplx(2, 1), cmplx(1, -1), cmplx(0.5, 1.5)}, - Test{cmplx(2, 1), cmplx(1, 2), cmplx(0.8, -0.6)}, - Test{cmplx(2, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(-1, 0), cmplx(-2, -1)}, - Test{cmplx(2, 1), cmplx(-1, 1), cmplx(-0.5, -1.5)}, - Test{cmplx(2, 1), cmplx(-1, -1), cmplx(-1.5, 0.5)}, - Test{cmplx(2, 1), cmplx(-1, 2), cmplx(0, -1)}, - Test{cmplx(2, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(2, 0), cmplx(1, 0.5)}, - Test{cmplx(2, 1), cmplx(2, 1), cmplx(1, 0)}, - Test{cmplx(2, 1), cmplx(2, -1), cmplx(0.6, 0.8)}, - Test{cmplx(2, 1), cmplx(2, 2), cmplx(0.75, -0.25)}, - Test{cmplx(2, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, 1), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 1), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(inf, inf), cmplx(0, negzero)}, - Test{cmplx(2, 1), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(2, 1), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, 1), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(2, -1), cmplx(0, 1), cmplx(-1, -2)}, - Test{cmplx(2, -1), cmplx(0, -1), cmplx(1, 2)}, - Test{cmplx(2, -1), cmplx(0, 2), cmplx(-0.5, -1)}, - Test{cmplx(2, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(0, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(0, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(1, 0), cmplx(2, -1)}, - Test{cmplx(2, -1), cmplx(1, 1), cmplx(0.5, -1.5)}, - Test{cmplx(2, -1), cmplx(1, -1), cmplx(1.5, 0.5)}, - Test{cmplx(2, -1), cmplx(1, 2), cmplx(0, -1)}, - Test{cmplx(2, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(1, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(1, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(-1, 0), cmplx(-2, 1)}, - Test{cmplx(2, -1), cmplx(-1, 1), cmplx(-1.5, -0.5)}, - Test{cmplx(2, -1), cmplx(-1, -1), cmplx(-0.5, 1.5)}, - Test{cmplx(2, -1), cmplx(-1, 2), cmplx(-0.8, -0.6)}, - Test{cmplx(2, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(-1, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(-1, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(2, 0), cmplx(1, -0.5)}, - Test{cmplx(2, -1), cmplx(2, 1), cmplx(0.6, -0.8)}, - Test{cmplx(2, -1), cmplx(2, -1), cmplx(1, 0)}, - Test{cmplx(2, -1), cmplx(2, 2), cmplx(0.25, -0.75)}, - Test{cmplx(2, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(2, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(2, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, -1), cmplx(nan, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(nan, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(inf, 0), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, 1), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, -1), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, 2), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, nan), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, inf), cmplx(0, negzero)}, - Test{cmplx(2, -1), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(2, -1), cmplx(-inf, 0), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(-inf, 1), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(-inf, -1), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(-inf, 2), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(-inf, nan), cmplx(negzero, 0)}, - Test{cmplx(2, -1), cmplx(-inf, inf), cmplx(negzero, negzero)}, - Test{cmplx(2, -1), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(2, 2), cmplx(0, 1), cmplx(2, -2)}, - Test{cmplx(2, 2), cmplx(0, -1), cmplx(-2, 2)}, - Test{cmplx(2, 2), cmplx(0, 2), cmplx(1, -1)}, - Test{cmplx(2, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(0, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(0, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(1, 0), cmplx(2, 2)}, - Test{cmplx(2, 2), cmplx(1, 1), cmplx(2, 0)}, - Test{cmplx(2, 2), cmplx(1, -1), cmplx(0, 2)}, - Test{cmplx(2, 2), cmplx(1, 2), cmplx(1.2, -0.4)}, - Test{cmplx(2, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(-1, 0), cmplx(-2, -2)}, - Test{cmplx(2, 2), cmplx(-1, 1), cmplx(negzero, -2)}, - Test{cmplx(2, 2), cmplx(-1, -1), cmplx(-2, negzero)}, - Test{cmplx(2, 2), cmplx(-1, 2), cmplx(0.4, -1.2)}, - Test{cmplx(2, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(-1, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(-1, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(2, 0), cmplx(1, 1)}, - Test{cmplx(2, 2), cmplx(2, 1), cmplx(1.2, 0.4)}, - Test{cmplx(2, 2), cmplx(2, -1), cmplx(0.4, 1.2)}, - Test{cmplx(2, 2), cmplx(2, 2), cmplx(1, 0)}, - Test{cmplx(2, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(2, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(2, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, 2), cmplx(nan, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(nan, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, 2), cmplx(inf, 0), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, 1), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, -1), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, 2), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, nan), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, inf), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(inf, -inf), cmplx(0, 0)}, - Test{cmplx(2, 2), cmplx(-inf, 0), cmplx(negzero, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, 1), cmplx(negzero, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, -1), cmplx(negzero, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, 2), cmplx(negzero, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, nan), cmplx(negzero, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, inf), cmplx(0, negzero)}, - Test{cmplx(2, 2), cmplx(-inf, -inf), cmplx(negzero, 0)}, - Test{cmplx(2, nan), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(2, inf), cmplx(0, 1), cmplx(inf, nan)}, - Test{cmplx(2, inf), cmplx(0, -1), cmplx(-inf, nan)}, - Test{cmplx(2, inf), cmplx(0, 2), cmplx(inf, nan)}, - Test{cmplx(2, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(1, 0), cmplx(nan, inf)}, - Test{cmplx(2, inf), cmplx(1, 1), cmplx(inf, inf)}, - Test{cmplx(2, inf), cmplx(1, -1), cmplx(-inf, inf)}, - Test{cmplx(2, inf), cmplx(1, 2), cmplx(inf, inf)}, - Test{cmplx(2, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-1, 0), cmplx(nan, -inf)}, - Test{cmplx(2, inf), cmplx(-1, 1), cmplx(inf, -inf)}, - Test{cmplx(2, inf), cmplx(-1, -1), cmplx(-inf, -inf)}, - Test{cmplx(2, inf), cmplx(-1, 2), cmplx(inf, -inf)}, - Test{cmplx(2, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(2, 0), cmplx(nan, inf)}, - Test{cmplx(2, inf), cmplx(2, 1), cmplx(inf, inf)}, - Test{cmplx(2, inf), cmplx(2, -1), cmplx(-inf, inf)}, - Test{cmplx(2, inf), cmplx(2, 2), cmplx(inf, inf)}, - Test{cmplx(2, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(2, -inf), cmplx(0, 1), cmplx(-inf, nan)}, - Test{cmplx(2, -inf), cmplx(0, -1), cmplx(inf, nan)}, - Test{cmplx(2, -inf), cmplx(0, 2), cmplx(-inf, nan)}, - Test{cmplx(2, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(1, 0), cmplx(nan, -inf)}, - Test{cmplx(2, -inf), cmplx(1, 1), cmplx(-inf, -inf)}, - Test{cmplx(2, -inf), cmplx(1, -1), cmplx(inf, -inf)}, - Test{cmplx(2, -inf), cmplx(1, 2), cmplx(-inf, -inf)}, - Test{cmplx(2, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-1, 0), cmplx(nan, inf)}, - Test{cmplx(2, -inf), cmplx(-1, 1), cmplx(-inf, inf)}, - Test{cmplx(2, -inf), cmplx(-1, -1), cmplx(inf, inf)}, - Test{cmplx(2, -inf), cmplx(-1, 2), cmplx(-inf, inf)}, - Test{cmplx(2, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(2, 0), cmplx(nan, -inf)}, - Test{cmplx(2, -inf), cmplx(2, 1), cmplx(-inf, -inf)}, - Test{cmplx(2, -inf), cmplx(2, -1), cmplx(inf, -inf)}, - Test{cmplx(2, -inf), cmplx(2, 2), cmplx(-inf, -inf)}, - Test{cmplx(2, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(2, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 0), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, 2), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(0, 0), cmplx(nan, inf)}, - Test{cmplx(nan, inf), cmplx(0, 1), cmplx(inf, nan)}, - Test{cmplx(nan, inf), cmplx(0, -1), cmplx(-inf, nan)}, - Test{cmplx(nan, inf), cmplx(0, 2), cmplx(inf, nan)}, - Test{cmplx(nan, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(1, 0), cmplx(nan, inf)}, - Test{cmplx(nan, inf), cmplx(1, 1), cmplx(inf, inf)}, - Test{cmplx(nan, inf), cmplx(1, -1), cmplx(-inf, inf)}, - Test{cmplx(nan, inf), cmplx(1, 2), cmplx(inf, inf)}, - Test{cmplx(nan, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-1, 0), cmplx(nan, -inf)}, - Test{cmplx(nan, inf), cmplx(-1, 1), cmplx(inf, -inf)}, - Test{cmplx(nan, inf), cmplx(-1, -1), cmplx(-inf, -inf)}, - Test{cmplx(nan, inf), cmplx(-1, 2), cmplx(inf, -inf)}, - Test{cmplx(nan, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(2, 0), cmplx(nan, inf)}, - Test{cmplx(nan, inf), cmplx(2, 1), cmplx(inf, inf)}, - Test{cmplx(nan, inf), cmplx(2, -1), cmplx(-inf, inf)}, - Test{cmplx(nan, inf), cmplx(2, 2), cmplx(inf, inf)}, - Test{cmplx(nan, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(0, 0), cmplx(nan, -inf)}, - Test{cmplx(nan, -inf), cmplx(0, 1), cmplx(-inf, nan)}, - Test{cmplx(nan, -inf), cmplx(0, -1), cmplx(inf, nan)}, - Test{cmplx(nan, -inf), cmplx(0, 2), cmplx(-inf, nan)}, - Test{cmplx(nan, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(1, 0), cmplx(nan, -inf)}, - Test{cmplx(nan, -inf), cmplx(1, 1), cmplx(-inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(1, -1), cmplx(inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(1, 2), cmplx(-inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-1, 0), cmplx(nan, inf)}, - Test{cmplx(nan, -inf), cmplx(-1, 1), cmplx(-inf, inf)}, - Test{cmplx(nan, -inf), cmplx(-1, -1), cmplx(inf, inf)}, - Test{cmplx(nan, -inf), cmplx(-1, 2), cmplx(-inf, inf)}, - Test{cmplx(nan, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(2, 0), cmplx(nan, -inf)}, - Test{cmplx(nan, -inf), cmplx(2, 1), cmplx(-inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(2, -1), cmplx(inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(2, 2), cmplx(-inf, -inf)}, - Test{cmplx(nan, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(nan, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(0, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 0), cmplx(0, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, 0), cmplx(0, -1), cmplx(nan, inf)}, - Test{cmplx(inf, 0), cmplx(0, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(1, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 0), cmplx(1, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 0), cmplx(1, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 0), cmplx(1, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-1, 0), cmplx(-inf, nan)}, - Test{cmplx(inf, 0), cmplx(-1, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, 0), cmplx(-1, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, 0), cmplx(-1, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(2, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 0), cmplx(2, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 0), cmplx(2, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 0), cmplx(2, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 0), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(inf, 1), cmplx(0, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, 1), cmplx(0, -1), cmplx(nan, inf)}, - Test{cmplx(inf, 1), cmplx(0, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(1, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 1), cmplx(1, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 1), cmplx(1, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 1), cmplx(1, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-1, 0), cmplx(-inf, nan)}, - Test{cmplx(inf, 1), cmplx(-1, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, 1), cmplx(-1, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, 1), cmplx(-1, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(2, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 1), cmplx(2, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 1), cmplx(2, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 1), cmplx(2, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(inf, -1), cmplx(0, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, -1), cmplx(0, -1), cmplx(nan, inf)}, - Test{cmplx(inf, -1), cmplx(0, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(1, 0), cmplx(inf, nan)}, - Test{cmplx(inf, -1), cmplx(1, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, -1), cmplx(1, -1), cmplx(inf, inf)}, - Test{cmplx(inf, -1), cmplx(1, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-1, 0), cmplx(-inf, nan)}, - Test{cmplx(inf, -1), cmplx(-1, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, -1), cmplx(-1, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, -1), cmplx(-1, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(2, 0), cmplx(inf, nan)}, - Test{cmplx(inf, -1), cmplx(2, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, -1), cmplx(2, -1), cmplx(inf, inf)}, - Test{cmplx(inf, -1), cmplx(2, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(inf, 2), cmplx(0, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, 2), cmplx(0, -1), cmplx(nan, inf)}, - Test{cmplx(inf, 2), cmplx(0, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(1, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 2), cmplx(1, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 2), cmplx(1, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 2), cmplx(1, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-1, 0), cmplx(-inf, nan)}, - Test{cmplx(inf, 2), cmplx(-1, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, 2), cmplx(-1, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, 2), cmplx(-1, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(2, 0), cmplx(inf, nan)}, - Test{cmplx(inf, 2), cmplx(2, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, 2), cmplx(2, -1), cmplx(inf, inf)}, - Test{cmplx(inf, 2), cmplx(2, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, 2), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(0, 0), cmplx(inf, nan)}, - Test{cmplx(inf, nan), cmplx(0, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, nan), cmplx(0, -1), cmplx(nan, inf)}, - Test{cmplx(inf, nan), cmplx(0, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(1, 0), cmplx(inf, nan)}, - Test{cmplx(inf, nan), cmplx(1, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, nan), cmplx(1, -1), cmplx(inf, inf)}, - Test{cmplx(inf, nan), cmplx(1, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-1, 0), cmplx(-inf, nan)}, - Test{cmplx(inf, nan), cmplx(-1, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, nan), cmplx(-1, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, nan), cmplx(-1, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(2, 0), cmplx(inf, nan)}, - Test{cmplx(inf, nan), cmplx(2, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, nan), cmplx(2, -1), cmplx(inf, inf)}, - Test{cmplx(inf, nan), cmplx(2, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(0, 0), cmplx(inf, inf)}, - Test{cmplx(inf, inf), cmplx(0, 1), cmplx(inf, -inf)}, - Test{cmplx(inf, inf), cmplx(0, -1), cmplx(-inf, inf)}, - Test{cmplx(inf, inf), cmplx(0, 2), cmplx(inf, -inf)}, - Test{cmplx(inf, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(1, 0), cmplx(inf, inf)}, - Test{cmplx(inf, inf), cmplx(1, 1), cmplx(inf, nan)}, - Test{cmplx(inf, inf), cmplx(1, -1), cmplx(nan, inf)}, - Test{cmplx(inf, inf), cmplx(1, 2), cmplx(inf, nan)}, - Test{cmplx(inf, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-1, 0), cmplx(-inf, -inf)}, - Test{cmplx(inf, inf), cmplx(-1, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, inf), cmplx(-1, -1), cmplx(-inf, nan)}, - Test{cmplx(inf, inf), cmplx(-1, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(2, 0), cmplx(inf, inf)}, - Test{cmplx(inf, inf), cmplx(2, 1), cmplx(inf, nan)}, - Test{cmplx(inf, inf), cmplx(2, -1), cmplx(nan, inf)}, - Test{cmplx(inf, inf), cmplx(2, 2), cmplx(inf, nan)}, - Test{cmplx(inf, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(0, 0), cmplx(inf, -inf)}, - Test{cmplx(inf, -inf), cmplx(0, 1), cmplx(-inf, -inf)}, - Test{cmplx(inf, -inf), cmplx(0, -1), cmplx(inf, inf)}, - Test{cmplx(inf, -inf), cmplx(0, 2), cmplx(-inf, -inf)}, - Test{cmplx(inf, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(1, 0), cmplx(inf, -inf)}, - Test{cmplx(inf, -inf), cmplx(1, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, -inf), cmplx(1, -1), cmplx(inf, nan)}, - Test{cmplx(inf, -inf), cmplx(1, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-1, 0), cmplx(-inf, inf)}, - Test{cmplx(inf, -inf), cmplx(-1, 1), cmplx(-inf, nan)}, - Test{cmplx(inf, -inf), cmplx(-1, -1), cmplx(nan, inf)}, - Test{cmplx(inf, -inf), cmplx(-1, 2), cmplx(-inf, nan)}, - Test{cmplx(inf, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(2, 0), cmplx(inf, -inf)}, - Test{cmplx(inf, -inf), cmplx(2, 1), cmplx(nan, -inf)}, - Test{cmplx(inf, -inf), cmplx(2, -1), cmplx(inf, nan)}, - Test{cmplx(inf, -inf), cmplx(2, 2), cmplx(nan, -inf)}, - Test{cmplx(inf, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(inf, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(0, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 0), cmplx(0, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, 0), cmplx(0, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, 0), cmplx(0, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, 0), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(1, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 0), cmplx(1, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 0), cmplx(1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 0), cmplx(1, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 0), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-1, 0), cmplx(inf, nan)}, - Test{cmplx(-inf, 0), cmplx(-1, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, 0), cmplx(-1, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, 0), cmplx(-1, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, 0), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(2, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 0), cmplx(2, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 0), cmplx(2, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 0), cmplx(2, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 0), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 0), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-inf, 1), cmplx(0, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, 1), cmplx(0, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, 1), cmplx(0, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, 1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(1, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 1), cmplx(1, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 1), cmplx(1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 1), cmplx(1, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-1, 0), cmplx(inf, nan)}, - Test{cmplx(-inf, 1), cmplx(-1, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, 1), cmplx(-1, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, 1), cmplx(-1, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, 1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(2, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 1), cmplx(2, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 1), cmplx(2, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 1), cmplx(2, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(0, 0), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -1), cmplx(0, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, -1), cmplx(0, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, -1), cmplx(0, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, -1), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(1, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, -1), cmplx(1, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, -1), cmplx(1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -1), cmplx(1, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, -1), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-1, 0), cmplx(inf, nan)}, - Test{cmplx(-inf, -1), cmplx(-1, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, -1), cmplx(-1, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, -1), cmplx(-1, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, -1), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(2, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, -1), cmplx(2, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, -1), cmplx(2, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -1), cmplx(2, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, -1), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -1), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-inf, 2), cmplx(0, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, 2), cmplx(0, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, 2), cmplx(0, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, 2), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(1, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 2), cmplx(1, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 2), cmplx(1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 2), cmplx(1, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 2), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-1, 0), cmplx(inf, nan)}, - Test{cmplx(-inf, 2), cmplx(-1, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, 2), cmplx(-1, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, 2), cmplx(-1, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, 2), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(2, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, 2), cmplx(2, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, 2), cmplx(2, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, 2), cmplx(2, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, 2), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, 2), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(0, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, nan), cmplx(0, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, nan), cmplx(0, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, nan), cmplx(0, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, nan), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(1, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, nan), cmplx(1, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, nan), cmplx(1, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, nan), cmplx(1, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, nan), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-1, 0), cmplx(inf, nan)}, - Test{cmplx(-inf, nan), cmplx(-1, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, nan), cmplx(-1, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, nan), cmplx(-1, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, nan), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(2, 0), cmplx(-inf, nan)}, - Test{cmplx(-inf, nan), cmplx(2, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, nan), cmplx(2, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, nan), cmplx(2, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, nan), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, nan), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(0, 0), cmplx(-inf, inf)}, - Test{cmplx(-inf, inf), cmplx(0, 1), cmplx(inf, inf)}, - Test{cmplx(-inf, inf), cmplx(0, -1), cmplx(-inf, -inf)}, - Test{cmplx(-inf, inf), cmplx(0, 2), cmplx(inf, inf)}, - Test{cmplx(-inf, inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(1, 0), cmplx(-inf, inf)}, - Test{cmplx(-inf, inf), cmplx(1, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, inf), cmplx(1, -1), cmplx(-inf, nan)}, - Test{cmplx(-inf, inf), cmplx(1, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-1, 0), cmplx(inf, -inf)}, - Test{cmplx(-inf, inf), cmplx(-1, 1), cmplx(inf, nan)}, - Test{cmplx(-inf, inf), cmplx(-1, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, inf), cmplx(-1, 2), cmplx(inf, nan)}, - Test{cmplx(-inf, inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(2, 0), cmplx(-inf, inf)}, - Test{cmplx(-inf, inf), cmplx(2, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, inf), cmplx(2, -1), cmplx(-inf, nan)}, - Test{cmplx(-inf, inf), cmplx(2, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, inf), cmplx(-inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(0, 0), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -inf), cmplx(0, 1), cmplx(-inf, inf)}, - Test{cmplx(-inf, -inf), cmplx(0, -1), cmplx(inf, -inf)}, - Test{cmplx(-inf, -inf), cmplx(0, 2), cmplx(-inf, inf)}, - Test{cmplx(-inf, -inf), cmplx(0, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(0, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(0, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(1, 0), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -inf), cmplx(1, 1), cmplx(-inf, nan)}, - Test{cmplx(-inf, -inf), cmplx(1, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, -inf), cmplx(1, 2), cmplx(-inf, nan)}, - Test{cmplx(-inf, -inf), cmplx(1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-1, 0), cmplx(inf, inf)}, - Test{cmplx(-inf, -inf), cmplx(-1, 1), cmplx(nan, inf)}, - Test{cmplx(-inf, -inf), cmplx(-1, -1), cmplx(inf, nan)}, - Test{cmplx(-inf, -inf), cmplx(-1, 2), cmplx(nan, inf)}, - Test{cmplx(-inf, -inf), cmplx(-1, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-1, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-1, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(2, 0), cmplx(-inf, -inf)}, - Test{cmplx(-inf, -inf), cmplx(2, 1), cmplx(-inf, nan)}, - Test{cmplx(-inf, -inf), cmplx(2, -1), cmplx(nan, -inf)}, - Test{cmplx(-inf, -inf), cmplx(2, 2), cmplx(-inf, nan)}, - Test{cmplx(-inf, -inf), cmplx(2, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(2, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(2, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(nan, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(inf, -inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, 0), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, 1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, -1), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, 2), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, nan), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, inf), cmplx(nan, nan)}, - Test{cmplx(-inf, -inf), cmplx(-inf, -inf), cmplx(nan, nan)}, + Test{complex(0, 0), complex(0, 0), complex(-nan, -nan)}, + Test{complex(0, 0), complex(0, 1), complex(0, 0)}, + Test{complex(0, 0), complex(0, -1), complex(negzero, 0)}, + Test{complex(0, 0), complex(0, 2), complex(0, 0)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(1, 0), complex(0, 0)}, + Test{complex(0, 0), complex(1, 1), complex(0, 0)}, + Test{complex(0, 0), complex(1, -1), complex(0, 0)}, + Test{complex(0, 0), complex(1, 2), complex(0, 0)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(-1, 0), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-1, 1), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-1, -1), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-1, 2), complex(0, negzero)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(2, 0), complex(0, 0)}, + Test{complex(0, 0), complex(2, 1), complex(0, 0)}, + Test{complex(0, 0), complex(2, -1), complex(0, 0)}, + Test{complex(0, 0), complex(2, 2), complex(0, 0)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(0, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(0, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(0, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(inf, 0), complex(0, 0)}, + Test{complex(0, 0), complex(inf, 1), complex(0, 0)}, + Test{complex(0, 0), complex(inf, -1), complex(0, 0)}, + Test{complex(0, 0), complex(inf, 2), complex(0, 0)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 0), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(0, 0), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(0, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(0, 0), complex(-nan, inf)}, + Test{complex(0, 1), complex(0, 1), complex(1, 0)}, + Test{complex(0, 1), complex(0, -1), complex(-1, 0)}, + Test{complex(0, 1), complex(0, 2), complex(0.5, 0)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(1, 0), complex(0, 1)}, + Test{complex(0, 1), complex(1, 1), complex(0.5, 0.5)}, + Test{complex(0, 1), complex(1, -1), complex(-0.5, 0.5)}, + Test{complex(0, 1), complex(1, 2), complex(0.4, 0.2)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(-1, 0), complex(negzero, -1)}, + Test{complex(0, 1), complex(-1, 1), complex(0.5, -0.5)}, + Test{complex(0, 1), complex(-1, -1), complex(-0.5, -0.5)}, + Test{complex(0, 1), complex(-1, 2), complex(0.4, -0.2)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(2, 0), complex(0, 0.5)}, + Test{complex(0, 1), complex(2, 1), complex(0.2, 0.4)}, + Test{complex(0, 1), complex(2, -1), complex(-0.2, 0.4)}, + Test{complex(0, 1), complex(2, 2), complex(0.25, 0.25)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(0, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(0, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(0, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(inf, 0), complex(0, 0)}, + Test{complex(0, 1), complex(inf, 1), complex(0, 0)}, + Test{complex(0, 1), complex(inf, -1), complex(0, 0)}, + Test{complex(0, 1), complex(inf, 2), complex(0, 0)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 1), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(0, 1), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(0, 1), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(0, 1), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(0, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(0, 0), complex(-nan, -inf)}, + Test{complex(0, -1), complex(0, 1), complex(-1, negzero)}, + Test{complex(0, -1), complex(0, -1), complex(1, negzero)}, + Test{complex(0, -1), complex(0, 2), complex(-0.5, negzero)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(1, 0), complex(0, -1)}, + Test{complex(0, -1), complex(1, 1), complex(-0.5, -0.5)}, + Test{complex(0, -1), complex(1, -1), complex(0.5, -0.5)}, + Test{complex(0, -1), complex(1, 2), complex(-0.4, -0.2)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(-1, 0), complex(negzero, 1)}, + Test{complex(0, -1), complex(-1, 1), complex(-0.5, 0.5)}, + Test{complex(0, -1), complex(-1, -1), complex(0.5, 0.5)}, + Test{complex(0, -1), complex(-1, 2), complex(-0.4, 0.2)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(2, 0), complex(0, -0.5)}, + Test{complex(0, -1), complex(2, 1), complex(-0.2, -0.4)}, + Test{complex(0, -1), complex(2, -1), complex(0.2, -0.4)}, + Test{complex(0, -1), complex(2, 2), complex(-0.25, -0.25)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(0, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(0, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(0, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(inf, 0), complex(0, negzero)}, + Test{complex(0, -1), complex(inf, 1), complex(0, negzero)}, + Test{complex(0, -1), complex(inf, -1), complex(0, negzero)}, + Test{complex(0, -1), complex(inf, 2), complex(0, negzero)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, -1), complex(-inf, 0), complex(negzero, 0)}, + Test{complex(0, -1), complex(-inf, 1), complex(negzero, 0)}, + Test{complex(0, -1), complex(-inf, -1), complex(negzero, 0)}, + Test{complex(0, -1), complex(-inf, 2), complex(negzero, 0)}, + Test{complex(0, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(0, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(0, 2), complex(0, 0), complex(-nan, inf)}, + Test{complex(0, 2), complex(0, 1), complex(2, 0)}, + Test{complex(0, 2), complex(0, -1), complex(-2, 0)}, + Test{complex(0, 2), complex(0, 2), complex(1, 0)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(1, 0), complex(0, 2)}, + Test{complex(0, 2), complex(1, 1), complex(1, 1)}, + Test{complex(0, 2), complex(1, -1), complex(-1, 1)}, + Test{complex(0, 2), complex(1, 2), complex(0.8, 0.4)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(-1, 0), complex(negzero, -2)}, + Test{complex(0, 2), complex(-1, 1), complex(1, -1)}, + Test{complex(0, 2), complex(-1, -1), complex(-1, -1)}, + Test{complex(0, 2), complex(-1, 2), complex(0.8, -0.4)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(2, 0), complex(0, 1)}, + Test{complex(0, 2), complex(2, 1), complex(0.4, 0.8)}, + Test{complex(0, 2), complex(2, -1), complex(-0.4, 0.8)}, + Test{complex(0, 2), complex(2, 2), complex(0.5, 0.5)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(0, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(0, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(0, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(inf, 0), complex(0, 0)}, + Test{complex(0, 2), complex(inf, 1), complex(0, 0)}, + Test{complex(0, 2), complex(inf, -1), complex(0, 0)}, + Test{complex(0, 2), complex(inf, 2), complex(0, 0)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(0, 2), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(0, 2), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(0, 2), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(0, 2), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(0, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(0, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(0, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(1, 0), complex(0, 0), complex(inf, -nan)}, + Test{complex(1, 0), complex(0, 1), complex(0, -1)}, + Test{complex(1, 0), complex(0, -1), complex(negzero, 1)}, + Test{complex(1, 0), complex(0, 2), complex(0, -0.5)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(1, 0), complex(1, 0)}, + Test{complex(1, 0), complex(1, 1), complex(0.5, -0.5)}, + Test{complex(1, 0), complex(1, -1), complex(0.5, 0.5)}, + Test{complex(1, 0), complex(1, 2), complex(0.2, -0.4)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(-1, 0), complex(-1, negzero)}, + Test{complex(1, 0), complex(-1, 1), complex(-0.5, -0.5)}, + Test{complex(1, 0), complex(-1, -1), complex(-0.5, 0.5)}, + Test{complex(1, 0), complex(-1, 2), complex(-0.2, -0.4)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(2, 0), complex(0.5, 0)}, + Test{complex(1, 0), complex(2, 1), complex(0.4, -0.2)}, + Test{complex(1, 0), complex(2, -1), complex(0.4, 0.2)}, + Test{complex(1, 0), complex(2, 2), complex(0.25, -0.25)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(1, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(1, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(1, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(inf, 0), complex(0, 0)}, + Test{complex(1, 0), complex(inf, 1), complex(0, 0)}, + Test{complex(1, 0), complex(inf, -1), complex(0, 0)}, + Test{complex(1, 0), complex(inf, 2), complex(0, 0)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 0), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(1, 0), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(1, 0), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(1, 0), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(0, 0), complex(inf, inf)}, + Test{complex(1, 1), complex(0, 1), complex(1, -1)}, + Test{complex(1, 1), complex(0, -1), complex(-1, 1)}, + Test{complex(1, 1), complex(0, 2), complex(0.5, -0.5)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(1, 0), complex(1, 1)}, + Test{complex(1, 1), complex(1, 1), complex(1, 0)}, + Test{complex(1, 1), complex(1, -1), complex(0, 1)}, + Test{complex(1, 1), complex(1, 2), complex(0.6, -0.2)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(-1, 0), complex(-1, -1)}, + Test{complex(1, 1), complex(-1, 1), complex(negzero, -1)}, + Test{complex(1, 1), complex(-1, -1), complex(-1, negzero)}, + Test{complex(1, 1), complex(-1, 2), complex(0.2, -0.6)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(2, 0), complex(0.5, 0.5)}, + Test{complex(1, 1), complex(2, 1), complex(0.6, 0.2)}, + Test{complex(1, 1), complex(2, -1), complex(0.2, 0.6)}, + Test{complex(1, 1), complex(2, 2), complex(0.5, 0)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(1, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(1, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(1, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(inf, 0), complex(0, 0)}, + Test{complex(1, 1), complex(inf, 1), complex(0, 0)}, + Test{complex(1, 1), complex(inf, -1), complex(0, 0)}, + Test{complex(1, 1), complex(inf, 2), complex(0, 0)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 1), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(1, 1), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(1, 1), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(1, 1), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, -1), complex(0, 0), complex(inf, -inf)}, + Test{complex(1, -1), complex(0, 1), complex(-1, -1)}, + Test{complex(1, -1), complex(0, -1), complex(1, 1)}, + Test{complex(1, -1), complex(0, 2), complex(-0.5, -0.5)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(1, 0), complex(1, -1)}, + Test{complex(1, -1), complex(1, 1), complex(0, -1)}, + Test{complex(1, -1), complex(1, -1), complex(1, 0)}, + Test{complex(1, -1), complex(1, 2), complex(-0.2, -0.6)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(-1, 0), complex(-1, 1)}, + Test{complex(1, -1), complex(-1, 1), complex(-1, negzero)}, + Test{complex(1, -1), complex(-1, -1), complex(negzero, 1)}, + Test{complex(1, -1), complex(-1, 2), complex(-0.6, -0.2)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(2, 0), complex(0.5, -0.5)}, + Test{complex(1, -1), complex(2, 1), complex(0.2, -0.6)}, + Test{complex(1, -1), complex(2, -1), complex(0.6, -0.2)}, + Test{complex(1, -1), complex(2, 2), complex(0, -0.5)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(1, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(1, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(1, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(inf, 0), complex(0, negzero)}, + Test{complex(1, -1), complex(inf, 1), complex(0, negzero)}, + Test{complex(1, -1), complex(inf, -1), complex(0, negzero)}, + Test{complex(1, -1), complex(inf, 2), complex(0, negzero)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, -1), complex(-inf, 0), complex(negzero, 0)}, + Test{complex(1, -1), complex(-inf, 1), complex(negzero, 0)}, + Test{complex(1, -1), complex(-inf, -1), complex(negzero, 0)}, + Test{complex(1, -1), complex(-inf, 2), complex(negzero, 0)}, + Test{complex(1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(1, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(1, 2), complex(0, 0), complex(inf, inf)}, + Test{complex(1, 2), complex(0, 1), complex(2, -1)}, + Test{complex(1, 2), complex(0, -1), complex(-2, 1)}, + Test{complex(1, 2), complex(0, 2), complex(1, -0.5)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(1, 0), complex(1, 2)}, + Test{complex(1, 2), complex(1, 1), complex(1.5, 0.5)}, + Test{complex(1, 2), complex(1, -1), complex(-0.5, 1.5)}, + Test{complex(1, 2), complex(1, 2), complex(1, 0)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(-1, 0), complex(-1, -2)}, + Test{complex(1, 2), complex(-1, 1), complex(0.5, -1.5)}, + Test{complex(1, 2), complex(-1, -1), complex(-1.5, -0.5)}, + Test{complex(1, 2), complex(-1, 2), complex(0.6, -0.8)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(2, 0), complex(0.5, 1)}, + Test{complex(1, 2), complex(2, 1), complex(0.8, 0.6)}, + Test{complex(1, 2), complex(2, -1), complex(0, 1)}, + Test{complex(1, 2), complex(2, 2), complex(0.75, 0.25)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(1, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(1, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(1, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(inf, 0), complex(0, 0)}, + Test{complex(1, 2), complex(inf, 1), complex(0, 0)}, + Test{complex(1, 2), complex(inf, -1), complex(0, 0)}, + Test{complex(1, 2), complex(inf, 2), complex(0, 0)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(1, 2), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(1, 2), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(1, 2), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(1, 2), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(1, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(1, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-1, 0), complex(0, 0), complex(-inf, -nan)}, + Test{complex(-1, 0), complex(0, 1), complex(0, 1)}, + Test{complex(-1, 0), complex(0, -1), complex(negzero, -1)}, + Test{complex(-1, 0), complex(0, 2), complex(0, 0.5)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(1, 0), complex(-1, 0)}, + Test{complex(-1, 0), complex(1, 1), complex(-0.5, 0.5)}, + Test{complex(-1, 0), complex(1, -1), complex(-0.5, -0.5)}, + Test{complex(-1, 0), complex(1, 2), complex(-0.2, 0.4)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(-1, 0), complex(1, negzero)}, + Test{complex(-1, 0), complex(-1, 1), complex(0.5, 0.5)}, + Test{complex(-1, 0), complex(-1, -1), complex(0.5, -0.5)}, + Test{complex(-1, 0), complex(-1, 2), complex(0.2, 0.4)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(2, 0), complex(-0.5, 0)}, + Test{complex(-1, 0), complex(2, 1), complex(-0.4, 0.2)}, + Test{complex(-1, 0), complex(2, -1), complex(-0.4, -0.2)}, + Test{complex(-1, 0), complex(2, 2), complex(-0.25, 0.25)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(-1, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(-1, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(-1, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(inf, 0), complex(negzero, 0)}, + Test{complex(-1, 0), complex(inf, 1), complex(negzero, 0)}, + Test{complex(-1, 0), complex(inf, -1), complex(negzero, 0)}, + Test{complex(-1, 0), complex(inf, 2), complex(negzero, 0)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 0), complex(-inf, 0), complex(0, negzero)}, + Test{complex(-1, 0), complex(-inf, 1), complex(0, negzero)}, + Test{complex(-1, 0), complex(-inf, -1), complex(0, negzero)}, + Test{complex(-1, 0), complex(-inf, 2), complex(0, negzero)}, + Test{complex(-1, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 0), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 0), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 1), complex(0, 0), complex(-inf, inf)}, + Test{complex(-1, 1), complex(0, 1), complex(1, 1)}, + Test{complex(-1, 1), complex(0, -1), complex(-1, -1)}, + Test{complex(-1, 1), complex(0, 2), complex(0.5, 0.5)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(1, 0), complex(-1, 1)}, + Test{complex(-1, 1), complex(1, 1), complex(0, 1)}, + Test{complex(-1, 1), complex(1, -1), complex(-1, 0)}, + Test{complex(-1, 1), complex(1, 2), complex(0.2, 0.6)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(-1, 0), complex(1, -1)}, + Test{complex(-1, 1), complex(-1, 1), complex(1, negzero)}, + Test{complex(-1, 1), complex(-1, -1), complex(negzero, -1)}, + Test{complex(-1, 1), complex(-1, 2), complex(0.6, 0.2)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(2, 0), complex(-0.5, 0.5)}, + Test{complex(-1, 1), complex(2, 1), complex(-0.2, 0.6)}, + Test{complex(-1, 1), complex(2, -1), complex(-0.6, 0.2)}, + Test{complex(-1, 1), complex(2, 2), complex(0, 0.5)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(-1, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(-1, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(-1, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(inf, 0), complex(negzero, 0)}, + Test{complex(-1, 1), complex(inf, 1), complex(negzero, 0)}, + Test{complex(-1, 1), complex(inf, -1), complex(negzero, 0)}, + Test{complex(-1, 1), complex(inf, 2), complex(negzero, 0)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 1), complex(-inf, 0), complex(0, negzero)}, + Test{complex(-1, 1), complex(-inf, 1), complex(0, negzero)}, + Test{complex(-1, 1), complex(-inf, -1), complex(0, negzero)}, + Test{complex(-1, 1), complex(-inf, 2), complex(0, negzero)}, + Test{complex(-1, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 1), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 1), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, -1), complex(0, 0), complex(-inf, -inf)}, + Test{complex(-1, -1), complex(0, 1), complex(-1, 1)}, + Test{complex(-1, -1), complex(0, -1), complex(1, -1)}, + Test{complex(-1, -1), complex(0, 2), complex(-0.5, 0.5)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(1, 0), complex(-1, -1)}, + Test{complex(-1, -1), complex(1, 1), complex(-1, 0)}, + Test{complex(-1, -1), complex(1, -1), complex(0, -1)}, + Test{complex(-1, -1), complex(1, 2), complex(-0.6, 0.2)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(-1, 0), complex(1, 1)}, + Test{complex(-1, -1), complex(-1, 1), complex(negzero, 1)}, + Test{complex(-1, -1), complex(-1, -1), complex(1, negzero)}, + Test{complex(-1, -1), complex(-1, 2), complex(-0.2, 0.6)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(2, 0), complex(-0.5, -0.5)}, + Test{complex(-1, -1), complex(2, 1), complex(-0.6, -0.2)}, + Test{complex(-1, -1), complex(2, -1), complex(-0.2, -0.6)}, + Test{complex(-1, -1), complex(2, 2), complex(-0.5, 0)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(-1, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(-1, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(-1, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(inf, 0), complex(negzero, negzero)}, + Test{complex(-1, -1), complex(inf, 1), complex(negzero, negzero)}, + Test{complex(-1, -1), complex(inf, -1), complex(negzero, negzero)}, + Test{complex(-1, -1), complex(inf, 2), complex(negzero, negzero)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, -1), complex(-inf, 0), complex(0, 0)}, + Test{complex(-1, -1), complex(-inf, 1), complex(0, 0)}, + Test{complex(-1, -1), complex(-inf, -1), complex(0, 0)}, + Test{complex(-1, -1), complex(-inf, 2), complex(0, 0)}, + Test{complex(-1, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, -1), complex(-nan, inf), complex(negzero, 0)}, + Test{complex(-1, -1), complex(-nan, -inf), complex(0, negzero)}, + Test{complex(-1, 2), complex(0, 0), complex(-inf, inf)}, + Test{complex(-1, 2), complex(0, 1), complex(2, 1)}, + Test{complex(-1, 2), complex(0, -1), complex(-2, -1)}, + Test{complex(-1, 2), complex(0, 2), complex(1, 0.5)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(1, 0), complex(-1, 2)}, + Test{complex(-1, 2), complex(1, 1), complex(0.5, 1.5)}, + Test{complex(-1, 2), complex(1, -1), complex(-1.5, 0.5)}, + Test{complex(-1, 2), complex(1, 2), complex(0.6, 0.8)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(-1, 0), complex(1, -2)}, + Test{complex(-1, 2), complex(-1, 1), complex(1.5, -0.5)}, + Test{complex(-1, 2), complex(-1, -1), complex(-0.5, -1.5)}, + Test{complex(-1, 2), complex(-1, 2), complex(1, 0)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(2, 0), complex(-0.5, 1)}, + Test{complex(-1, 2), complex(2, 1), complex(0, 1)}, + Test{complex(-1, 2), complex(2, -1), complex(-0.8, 0.6)}, + Test{complex(-1, 2), complex(2, 2), complex(0.25, 0.75)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(-1, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(-1, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(-1, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(inf, 0), complex(negzero, 0)}, + Test{complex(-1, 2), complex(inf, 1), complex(negzero, 0)}, + Test{complex(-1, 2), complex(inf, -1), complex(negzero, 0)}, + Test{complex(-1, 2), complex(inf, 2), complex(negzero, 0)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(-1, 2), complex(-inf, 0), complex(0, negzero)}, + Test{complex(-1, 2), complex(-inf, 1), complex(0, negzero)}, + Test{complex(-1, 2), complex(-inf, -1), complex(0, negzero)}, + Test{complex(-1, 2), complex(-inf, 2), complex(0, negzero)}, + Test{complex(-1, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-1, 2), complex(-nan, inf), complex(0, 0)}, + Test{complex(-1, 2), complex(-nan, -inf), complex(negzero, negzero)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(2, 0), complex(0, 0), complex(inf, -nan)}, + Test{complex(2, 0), complex(0, 1), complex(0, -2)}, + Test{complex(2, 0), complex(0, -1), complex(negzero, 2)}, + Test{complex(2, 0), complex(0, 2), complex(0, -1)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(1, 0), complex(2, 0)}, + Test{complex(2, 0), complex(1, 1), complex(1, -1)}, + Test{complex(2, 0), complex(1, -1), complex(1, 1)}, + Test{complex(2, 0), complex(1, 2), complex(0.4, -0.8)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(-1, 0), complex(-2, negzero)}, + Test{complex(2, 0), complex(-1, 1), complex(-1, -1)}, + Test{complex(2, 0), complex(-1, -1), complex(-1, 1)}, + Test{complex(2, 0), complex(-1, 2), complex(-0.4, -0.8)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(2, 0), complex(1, 0)}, + Test{complex(2, 0), complex(2, 1), complex(0.8, -0.4)}, + Test{complex(2, 0), complex(2, -1), complex(0.8, 0.4)}, + Test{complex(2, 0), complex(2, 2), complex(0.5, -0.5)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(2, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(2, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(2, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(inf, 0), complex(0, 0)}, + Test{complex(2, 0), complex(inf, 1), complex(0, 0)}, + Test{complex(2, 0), complex(inf, -1), complex(0, 0)}, + Test{complex(2, 0), complex(inf, 2), complex(0, 0)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 0), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(2, 0), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(2, 0), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(2, 0), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(2, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 0), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 0), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(0, 0), complex(inf, inf)}, + Test{complex(2, 1), complex(0, 1), complex(1, -2)}, + Test{complex(2, 1), complex(0, -1), complex(-1, 2)}, + Test{complex(2, 1), complex(0, 2), complex(0.5, -1)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(1, 0), complex(2, 1)}, + Test{complex(2, 1), complex(1, 1), complex(1.5, -0.5)}, + Test{complex(2, 1), complex(1, -1), complex(0.5, 1.5)}, + Test{complex(2, 1), complex(1, 2), complex(0.8, -0.6)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(-1, 0), complex(-2, -1)}, + Test{complex(2, 1), complex(-1, 1), complex(-0.5, -1.5)}, + Test{complex(2, 1), complex(-1, -1), complex(-1.5, 0.5)}, + Test{complex(2, 1), complex(-1, 2), complex(0, -1)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(2, 0), complex(1, 0.5)}, + Test{complex(2, 1), complex(2, 1), complex(1, 0)}, + Test{complex(2, 1), complex(2, -1), complex(0.6, 0.8)}, + Test{complex(2, 1), complex(2, 2), complex(0.75, -0.25)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(2, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(2, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(2, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(inf, 0), complex(0, 0)}, + Test{complex(2, 1), complex(inf, 1), complex(0, 0)}, + Test{complex(2, 1), complex(inf, -1), complex(0, 0)}, + Test{complex(2, 1), complex(inf, 2), complex(0, 0)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 1), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(2, 1), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(2, 1), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(2, 1), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(2, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 1), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 1), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, -1), complex(0, 0), complex(inf, -inf)}, + Test{complex(2, -1), complex(0, 1), complex(-1, -2)}, + Test{complex(2, -1), complex(0, -1), complex(1, 2)}, + Test{complex(2, -1), complex(0, 2), complex(-0.5, -1)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(1, 0), complex(2, -1)}, + Test{complex(2, -1), complex(1, 1), complex(0.5, -1.5)}, + Test{complex(2, -1), complex(1, -1), complex(1.5, 0.5)}, + Test{complex(2, -1), complex(1, 2), complex(0, -1)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(-1, 0), complex(-2, 1)}, + Test{complex(2, -1), complex(-1, 1), complex(-1.5, -0.5)}, + Test{complex(2, -1), complex(-1, -1), complex(-0.5, 1.5)}, + Test{complex(2, -1), complex(-1, 2), complex(-0.8, -0.6)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(2, 0), complex(1, -0.5)}, + Test{complex(2, -1), complex(2, 1), complex(0.6, -0.8)}, + Test{complex(2, -1), complex(2, -1), complex(1, 0)}, + Test{complex(2, -1), complex(2, 2), complex(0.25, -0.75)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(2, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(2, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(2, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(inf, 0), complex(0, negzero)}, + Test{complex(2, -1), complex(inf, 1), complex(0, negzero)}, + Test{complex(2, -1), complex(inf, -1), complex(0, negzero)}, + Test{complex(2, -1), complex(inf, 2), complex(0, negzero)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, -1), complex(-inf, 0), complex(negzero, 0)}, + Test{complex(2, -1), complex(-inf, 1), complex(negzero, 0)}, + Test{complex(2, -1), complex(-inf, -1), complex(negzero, 0)}, + Test{complex(2, -1), complex(-inf, 2), complex(negzero, 0)}, + Test{complex(2, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, -1), complex(-nan, inf), complex(negzero, negzero)}, + Test{complex(2, -1), complex(-nan, -inf), complex(0, 0)}, + Test{complex(2, 2), complex(0, 0), complex(inf, inf)}, + Test{complex(2, 2), complex(0, 1), complex(2, -2)}, + Test{complex(2, 2), complex(0, -1), complex(-2, 2)}, + Test{complex(2, 2), complex(0, 2), complex(1, -1)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(1, 0), complex(2, 2)}, + Test{complex(2, 2), complex(1, 1), complex(2, 0)}, + Test{complex(2, 2), complex(1, -1), complex(0, 2)}, + Test{complex(2, 2), complex(1, 2), complex(1.2, -0.4)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(-1, 0), complex(-2, -2)}, + Test{complex(2, 2), complex(-1, 1), complex(negzero, -2)}, + Test{complex(2, 2), complex(-1, -1), complex(-2, negzero)}, + Test{complex(2, 2), complex(-1, 2), complex(0.4, -1.2)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(2, 0), complex(1, 1)}, + Test{complex(2, 2), complex(2, 1), complex(1.2, 0.4)}, + Test{complex(2, 2), complex(2, -1), complex(0.4, 1.2)}, + Test{complex(2, 2), complex(2, 2), complex(1, 0)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(2, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(2, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(2, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(inf, 0), complex(0, 0)}, + Test{complex(2, 2), complex(inf, 1), complex(0, 0)}, + Test{complex(2, 2), complex(inf, -1), complex(0, 0)}, + Test{complex(2, 2), complex(inf, 2), complex(0, 0)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(2, 2), complex(-inf, 0), complex(negzero, negzero)}, + Test{complex(2, 2), complex(-inf, 1), complex(negzero, negzero)}, + Test{complex(2, 2), complex(-inf, -1), complex(negzero, negzero)}, + Test{complex(2, 2), complex(-inf, 2), complex(negzero, negzero)}, + Test{complex(2, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(2, 2), complex(-nan, inf), complex(0, negzero)}, + Test{complex(2, 2), complex(-nan, -inf), complex(negzero, 0)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, 0), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, 0), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, 0), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, 1), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, 1), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, 1), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, -1), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, -1), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, -1), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, 2), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, 2), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, 2), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(nan, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(0, 0), complex(inf, -nan)}, + Test{complex(inf, 0), complex(0, 1), complex(-nan, -inf)}, + Test{complex(inf, 0), complex(0, -1), complex(-nan, inf)}, + Test{complex(inf, 0), complex(0, 2), complex(-nan, -inf)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(1, 0), complex(inf, -nan)}, + Test{complex(inf, 0), complex(1, 1), complex(inf, -inf)}, + Test{complex(inf, 0), complex(1, -1), complex(inf, inf)}, + Test{complex(inf, 0), complex(1, 2), complex(inf, -inf)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-1, 0), complex(-inf, -nan)}, + Test{complex(inf, 0), complex(-1, 1), complex(-inf, -inf)}, + Test{complex(inf, 0), complex(-1, -1), complex(-inf, inf)}, + Test{complex(inf, 0), complex(-1, 2), complex(-inf, -inf)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(2, 0), complex(inf, -nan)}, + Test{complex(inf, 0), complex(2, 1), complex(inf, -inf)}, + Test{complex(inf, 0), complex(2, -1), complex(inf, inf)}, + Test{complex(inf, 0), complex(2, 2), complex(inf, -inf)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(inf, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(inf, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(inf, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(0, 0), complex(inf, inf)}, + Test{complex(inf, 1), complex(0, 1), complex(-nan, -inf)}, + Test{complex(inf, 1), complex(0, -1), complex(-nan, inf)}, + Test{complex(inf, 1), complex(0, 2), complex(-nan, -inf)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(1, 0), complex(inf, -nan)}, + Test{complex(inf, 1), complex(1, 1), complex(inf, -inf)}, + Test{complex(inf, 1), complex(1, -1), complex(inf, inf)}, + Test{complex(inf, 1), complex(1, 2), complex(inf, -inf)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-1, 0), complex(-inf, -nan)}, + Test{complex(inf, 1), complex(-1, 1), complex(-inf, -inf)}, + Test{complex(inf, 1), complex(-1, -1), complex(-inf, inf)}, + Test{complex(inf, 1), complex(-1, 2), complex(-inf, -inf)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(2, 0), complex(inf, -nan)}, + Test{complex(inf, 1), complex(2, 1), complex(inf, -inf)}, + Test{complex(inf, 1), complex(2, -1), complex(inf, inf)}, + Test{complex(inf, 1), complex(2, 2), complex(inf, -inf)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(inf, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(inf, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(inf, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(0, 0), complex(inf, -inf)}, + Test{complex(inf, -1), complex(0, 1), complex(-nan, -inf)}, + Test{complex(inf, -1), complex(0, -1), complex(-nan, inf)}, + Test{complex(inf, -1), complex(0, 2), complex(-nan, -inf)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(1, 0), complex(inf, -nan)}, + Test{complex(inf, -1), complex(1, 1), complex(inf, -inf)}, + Test{complex(inf, -1), complex(1, -1), complex(inf, inf)}, + Test{complex(inf, -1), complex(1, 2), complex(inf, -inf)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-1, 0), complex(-inf, -nan)}, + Test{complex(inf, -1), complex(-1, 1), complex(-inf, -inf)}, + Test{complex(inf, -1), complex(-1, -1), complex(-inf, inf)}, + Test{complex(inf, -1), complex(-1, 2), complex(-inf, -inf)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(2, 0), complex(inf, -nan)}, + Test{complex(inf, -1), complex(2, 1), complex(inf, -inf)}, + Test{complex(inf, -1), complex(2, -1), complex(inf, inf)}, + Test{complex(inf, -1), complex(2, 2), complex(inf, -inf)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(inf, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(inf, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(inf, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(0, 0), complex(inf, inf)}, + Test{complex(inf, 2), complex(0, 1), complex(-nan, -inf)}, + Test{complex(inf, 2), complex(0, -1), complex(-nan, inf)}, + Test{complex(inf, 2), complex(0, 2), complex(-nan, -inf)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(1, 0), complex(inf, -nan)}, + Test{complex(inf, 2), complex(1, 1), complex(inf, -inf)}, + Test{complex(inf, 2), complex(1, -1), complex(inf, inf)}, + Test{complex(inf, 2), complex(1, 2), complex(inf, -inf)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-1, 0), complex(-inf, -nan)}, + Test{complex(inf, 2), complex(-1, 1), complex(-inf, -inf)}, + Test{complex(inf, 2), complex(-1, -1), complex(-inf, inf)}, + Test{complex(inf, 2), complex(-1, 2), complex(-inf, -inf)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(2, 0), complex(inf, -nan)}, + Test{complex(inf, 2), complex(2, 1), complex(inf, -inf)}, + Test{complex(inf, 2), complex(2, -1), complex(inf, inf)}, + Test{complex(inf, 2), complex(2, 2), complex(inf, -inf)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(inf, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(inf, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(inf, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(0, 0), complex(-inf, -nan)}, + Test{complex(-inf, 0), complex(0, 1), complex(-nan, inf)}, + Test{complex(-inf, 0), complex(0, -1), complex(-nan, -inf)}, + Test{complex(-inf, 0), complex(0, 2), complex(-nan, inf)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(1, 0), complex(-inf, -nan)}, + Test{complex(-inf, 0), complex(1, 1), complex(-inf, inf)}, + Test{complex(-inf, 0), complex(1, -1), complex(-inf, -inf)}, + Test{complex(-inf, 0), complex(1, 2), complex(-inf, inf)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-1, 0), complex(inf, -nan)}, + Test{complex(-inf, 0), complex(-1, 1), complex(inf, inf)}, + Test{complex(-inf, 0), complex(-1, -1), complex(inf, -inf)}, + Test{complex(-inf, 0), complex(-1, 2), complex(inf, inf)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(2, 0), complex(-inf, -nan)}, + Test{complex(-inf, 0), complex(2, 1), complex(-inf, inf)}, + Test{complex(-inf, 0), complex(2, -1), complex(-inf, -inf)}, + Test{complex(-inf, 0), complex(2, 2), complex(-inf, inf)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(nan, 0), complex(nan, nan)}, + Test{complex(-inf, 0), complex(nan, 1), complex(nan, nan)}, + Test{complex(-inf, 0), complex(nan, -1), complex(nan, nan)}, + Test{complex(-inf, 0), complex(nan, 2), complex(nan, nan)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 0), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 0), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(0, 0), complex(-inf, inf)}, + Test{complex(-inf, 1), complex(0, 1), complex(-nan, inf)}, + Test{complex(-inf, 1), complex(0, -1), complex(-nan, -inf)}, + Test{complex(-inf, 1), complex(0, 2), complex(-nan, inf)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(1, 0), complex(-inf, -nan)}, + Test{complex(-inf, 1), complex(1, 1), complex(-inf, inf)}, + Test{complex(-inf, 1), complex(1, -1), complex(-inf, -inf)}, + Test{complex(-inf, 1), complex(1, 2), complex(-inf, inf)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-1, 0), complex(inf, -nan)}, + Test{complex(-inf, 1), complex(-1, 1), complex(inf, inf)}, + Test{complex(-inf, 1), complex(-1, -1), complex(inf, -inf)}, + Test{complex(-inf, 1), complex(-1, 2), complex(inf, inf)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(2, 0), complex(-inf, -nan)}, + Test{complex(-inf, 1), complex(2, 1), complex(-inf, inf)}, + Test{complex(-inf, 1), complex(2, -1), complex(-inf, -inf)}, + Test{complex(-inf, 1), complex(2, 2), complex(-inf, inf)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(nan, 0), complex(nan, nan)}, + Test{complex(-inf, 1), complex(nan, 1), complex(nan, nan)}, + Test{complex(-inf, 1), complex(nan, -1), complex(nan, nan)}, + Test{complex(-inf, 1), complex(nan, 2), complex(nan, nan)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(0, 0), complex(-inf, -inf)}, + Test{complex(-inf, -1), complex(0, 1), complex(-nan, inf)}, + Test{complex(-inf, -1), complex(0, -1), complex(-nan, -inf)}, + Test{complex(-inf, -1), complex(0, 2), complex(-nan, inf)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(1, 0), complex(-inf, -nan)}, + Test{complex(-inf, -1), complex(1, 1), complex(-inf, inf)}, + Test{complex(-inf, -1), complex(1, -1), complex(-inf, -inf)}, + Test{complex(-inf, -1), complex(1, 2), complex(-inf, inf)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-1, 0), complex(inf, -nan)}, + Test{complex(-inf, -1), complex(-1, 1), complex(inf, inf)}, + Test{complex(-inf, -1), complex(-1, -1), complex(inf, -inf)}, + Test{complex(-inf, -1), complex(-1, 2), complex(inf, inf)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(2, 0), complex(-inf, -nan)}, + Test{complex(-inf, -1), complex(2, 1), complex(-inf, inf)}, + Test{complex(-inf, -1), complex(2, -1), complex(-inf, -inf)}, + Test{complex(-inf, -1), complex(2, 2), complex(-inf, inf)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(nan, 0), complex(nan, nan)}, + Test{complex(-inf, -1), complex(nan, 1), complex(nan, nan)}, + Test{complex(-inf, -1), complex(nan, -1), complex(nan, nan)}, + Test{complex(-inf, -1), complex(nan, 2), complex(nan, nan)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, -1), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, -1), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(0, 0), complex(-inf, inf)}, + Test{complex(-inf, 2), complex(0, 1), complex(-nan, inf)}, + Test{complex(-inf, 2), complex(0, -1), complex(-nan, -inf)}, + Test{complex(-inf, 2), complex(0, 2), complex(-nan, inf)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(1, 0), complex(-inf, -nan)}, + Test{complex(-inf, 2), complex(1, 1), complex(-inf, inf)}, + Test{complex(-inf, 2), complex(1, -1), complex(-inf, -inf)}, + Test{complex(-inf, 2), complex(1, 2), complex(-inf, inf)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-1, 0), complex(inf, -nan)}, + Test{complex(-inf, 2), complex(-1, 1), complex(inf, inf)}, + Test{complex(-inf, 2), complex(-1, -1), complex(inf, -inf)}, + Test{complex(-inf, 2), complex(-1, 2), complex(inf, inf)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(2, 0), complex(-inf, -nan)}, + Test{complex(-inf, 2), complex(2, 1), complex(-inf, inf)}, + Test{complex(-inf, 2), complex(2, -1), complex(-inf, -inf)}, + Test{complex(-inf, 2), complex(2, 2), complex(-inf, inf)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(nan, 0), complex(nan, nan)}, + Test{complex(-inf, 2), complex(nan, 1), complex(nan, nan)}, + Test{complex(-inf, 2), complex(nan, -1), complex(nan, nan)}, + Test{complex(-inf, 2), complex(nan, 2), complex(nan, nan)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, + Test{complex(-inf, 2), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-inf, 2), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(nan, nan), complex(0, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(0, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-1, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(2, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 0), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, + Test{complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, + Test{complex(nan, nan), complex(nan, nan), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, inf), complex(nan, nan)}, + Test{complex(nan, nan), complex(-nan, -inf), complex(nan, nan)}, + Test{complex(-nan, inf), complex(0, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(0, 1), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(0, -1), complex(-inf, -nan)}, + Test{complex(-nan, inf), complex(0, 2), complex(inf, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(1, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(1, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(1, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(1, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-1, 0), complex(-nan, -inf)}, + Test{complex(-nan, inf), complex(-1, 1), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(-1, -1), complex(-inf, -inf)}, + Test{complex(-nan, inf), complex(-1, 2), complex(inf, -inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(2, 0), complex(-nan, inf)}, + Test{complex(-nan, inf), complex(2, 1), complex(inf, inf)}, + Test{complex(-nan, inf), complex(2, -1), complex(-inf, inf)}, + Test{complex(-nan, inf), complex(2, 2), complex(inf, inf)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(0, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(0, 1), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(0, -1), complex(inf, -nan)}, + Test{complex(-nan, -inf), complex(0, 2), complex(-inf, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(1, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(1, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(1, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(1, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-1, 0), complex(-nan, inf)}, + Test{complex(-nan, -inf), complex(-1, 1), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(-1, -1), complex(inf, inf)}, + Test{complex(-nan, -inf), complex(-1, 2), complex(-inf, inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(2, 0), complex(-nan, -inf)}, + Test{complex(-nan, -inf), complex(2, 1), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(2, -1), complex(inf, -inf)}, + Test{complex(-nan, -inf), complex(2, 2), complex(-inf, -inf)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, 0), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, -1), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, 2), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 0), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, -1), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-inf, 2), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(nan, nan), complex(nan, nan)}, + Test{complex(-nan, -inf), complex(-nan, inf), complex(-nan, -nan)}, + Test{complex(-nan, -inf), complex(-nan, -inf), complex(-nan, -nan)}, } diff --git a/test/complit.go b/test/complit.go index f3b7c9abe..f5f7aca9d 100644 --- a/test/complit.go +++ b/test/complit.go @@ -6,9 +6,16 @@ package main -type T struct { i int; f float; s string; next *T } +type T struct { + i int + f float64 + s string + next *T +} -type R struct { num int } +type R struct { + num int +} func itor(a int) *R { r := new(R) @@ -18,11 +25,16 @@ func itor(a int) *R { func eq(a []*R) { for i := 0; i < len(a); i++ { - if a[i].num != i { panic("bad") } + if a[i].num != i { + panic("bad") + } } } -type P struct { a, b int } +type P struct { + a, b int +} + func NewP(a, b int) *P { return &P{a, b} } @@ -34,37 +46,57 @@ func main() { var tp *T tp = &T{0, 7.2, "hi", &t} - a1 := []int{1,2,3} - if len(a1) != 3 { panic("a1") } - a2 := [10]int{1,2,3} - if len(a2) != 10 || cap(a2) != 10 { panic("a2") } + a1 := []int{1, 2, 3} + if len(a1) != 3 { + panic("a1") + } + a2 := [10]int{1, 2, 3} + if len(a2) != 10 || cap(a2) != 10 { + panic("a2") + } - a3 := [10]int{1,2,3,} - if len(a3) != 10 || a2[3] != 0 { panic("a3") } + a3 := [10]int{1, 2, 3} + if len(a3) != 10 || a2[3] != 0 { + panic("a3") + } var oai []int - oai = []int{1,2,3} - if len(oai) != 3 { panic("oai") } + oai = []int{1, 2, 3} + if len(oai) != 3 { + panic("oai") + } at := [...]*T{&t, tp, &t} - if len(at) != 3 { panic("at") } + if len(at) != 3 { + panic("at") + } c := make(chan int) ac := []chan int{c, c, c} - if len(ac) != 3 { panic("ac") } + if len(ac) != 3 { + panic("ac") + } aat := [][len(at)]*T{at, at} - if len(aat) != 2 || len(aat[1]) != 3 { panic("aat") } + if len(aat) != 2 || len(aat[1]) != 3 { + panic("aat") + } s := string([]byte{'h', 'e', 'l', 'l', 'o'}) - if s != "hello" { panic("s") } + if s != "hello" { + panic("s") + } - m := map[string]float{"one":1.0, "two":2.0, "pi":22./7.} - if len(m) != 3 { panic("m") } + m := map[string]float64{"one": 1.0, "two": 2.0, "pi": 22. / 7.} + if len(m) != 3 { + panic("m") + } eq([]*R{itor(0), itor(1), itor(2), itor(3), itor(4), itor(5)}) p1 := NewP(1, 2) p2 := NewP(1, 2) - if p1 == p2 { panic("NewP") } + if p1 == p2 { + panic("NewP") + } } diff --git a/test/const1.go b/test/const1.go index cf07055cf..67f36e4fd 100644 --- a/test/const1.go +++ b/test/const1.go @@ -6,76 +6,77 @@ package main -type I interface {} +type I interface{} + const ( // assume all types behave similarly to int8/uint8 - Int8 int8 = 101 - Minus1 int8 = -1 - Uint8 uint8 = 102 - Const = 103 + Int8 int8 = 101 + Minus1 int8 = -1 + Uint8 uint8 = 102 + Const = 103 - Float32 float32 = 104.5 - Float float = 105.5 + Float32 float32 = 104.5 + Float64 float64 = 105.5 ConstFloat = 106.5 - Big float64 = 1e300 + Big float64 = 1e300 String = "abc" - Bool = true + Bool = true ) var ( - a1 = Int8 * 100 // ERROR "overflow" - a2 = Int8 * -1 // OK - a3 = Int8 * 1000 // ERROR "overflow" - a4 = Int8 * int8(1000) // ERROR "overflow" - a5 = int8(Int8 * 1000) // ERROR "overflow" - a6 = int8(Int8 * int8(1000)) // ERROR "overflow" - a7 = Int8 - 2*Int8 - 2*Int8 // ERROR "overflow" - a8 = Int8 * Const / 100 // ERROR "overflow" - a9 = Int8 * (Const / 100) // OK + a1 = Int8 * 100 // ERROR "overflow" + a2 = Int8 * -1 // OK + a3 = Int8 * 1000 // ERROR "overflow" + a4 = Int8 * int8(1000) // ERROR "overflow" + a5 = int8(Int8 * 1000) // ERROR "overflow" + a6 = int8(Int8 * int8(1000)) // ERROR "overflow" + a7 = Int8 - 2*Int8 - 2*Int8 // ERROR "overflow" + a8 = Int8 * Const / 100 // ERROR "overflow" + a9 = Int8 * (Const / 100) // OK - b1 = Uint8 * Uint8 // ERROR "overflow" - b2 = Uint8 * -1 // ERROR "overflow" - b3 = Uint8 - Uint8 // OK - b4 = Uint8 - Uint8 - Uint8 // ERROR "overflow" - b5 = uint8(^0) // ERROR "overflow" - b6 = ^uint8(0) // OK - b7 = uint8(Minus1) // ERROR "overflow" - b8 = uint8(int8(-1)) // ERROR "overflow" - b8a = uint8(-1) // ERROR "overflow" - b9 byte = (1<<10) >> 8 // OK - b10 byte = (1<<10) // ERROR "overflow" - b11 byte = (byte(1)<<10) >> 8 // ERROR "overflow" - b12 byte = 1000 // ERROR "overflow" - b13 byte = byte(1000) // ERROR "overflow" - b14 byte = byte(100) * byte(100) // ERROR "overflow" - b15 byte = byte(100) * 100 // ERROR "overflow" - b16 byte = byte(0) * 1000 // ERROR "overflow" - b16a byte = 0 * 1000 // OK - b17 byte = byte(0) * byte(1000) // ERROR "overflow" - b18 byte = Uint8/0 // ERROR "division by zero" + b1 = Uint8 * Uint8 // ERROR "overflow" + b2 = Uint8 * -1 // ERROR "overflow" + b3 = Uint8 - Uint8 // OK + b4 = Uint8 - Uint8 - Uint8 // ERROR "overflow" + b5 = uint8(^0) // ERROR "overflow" + b6 = ^uint8(0) // OK + b7 = uint8(Minus1) // ERROR "overflow" + b8 = uint8(int8(-1)) // ERROR "overflow" + b8a = uint8(-1) // ERROR "overflow" + b9 byte = (1 << 10) >> 8 // OK + b10 byte = (1 << 10) // ERROR "overflow" + b11 byte = (byte(1) << 10) >> 8 // ERROR "overflow" + b12 byte = 1000 // ERROR "overflow" + b13 byte = byte(1000) // ERROR "overflow" + b14 byte = byte(100) * byte(100) // ERROR "overflow" + b15 byte = byte(100) * 100 // ERROR "overflow" + b16 byte = byte(0) * 1000 // ERROR "overflow" + b16a byte = 0 * 1000 // OK + b17 byte = byte(0) * byte(1000) // ERROR "overflow" + b18 byte = Uint8 / 0 // ERROR "division by zero" - c1 float64 = Big - c2 float64 = Big*Big // ERROR "overflow" - c3 float64 = float64(Big)*Big // ERROR "overflow" - c4 = Big*Big // ERROR "overflow" - c5 = Big/0 // ERROR "division by zero" + c1 float64 = Big + c2 float64 = Big * Big // ERROR "overflow" + c3 float64 = float64(Big) * Big // ERROR "overflow" + c4 = Big * Big // ERROR "overflow" + c5 = Big / 0 // ERROR "division by zero" ) func f(int) func main() { - f(Int8) // ERROR "convert|wrong type|cannot" - f(Minus1) // ERROR "convert|wrong type|cannot" - f(Uint8) // ERROR "convert|wrong type|cannot" - f(Const) // OK - f(Float32) // ERROR "convert|wrong type|cannot" - f(Float) // ERROR "convert|wrong type|cannot" - f(ConstFloat) // ERROR "truncate" - f(ConstFloat - 0.5) // OK - f(Big) // ERROR "convert|wrong type|cannot" - f(String) // ERROR "convert|wrong type|cannot|incompatible" - f(Bool) // ERROR "convert|wrong type|cannot|incompatible" + f(Int8) // ERROR "convert|wrong type|cannot" + f(Minus1) // ERROR "convert|wrong type|cannot" + f(Uint8) // ERROR "convert|wrong type|cannot" + f(Const) // OK + f(Float32) // ERROR "convert|wrong type|cannot" + f(Float64) // ERROR "convert|wrong type|cannot" + f(ConstFloat) // ERROR "truncate" + f(ConstFloat - 0.5) // OK + f(Big) // ERROR "convert|wrong type|cannot" + f(String) // ERROR "convert|wrong type|cannot|incompatible" + f(Bool) // ERROR "convert|wrong type|cannot|incompatible" } -const ptr = nil // ERROR "const.*nil" +const ptr = nil // ERROR "const.*nil" diff --git a/test/convlit.go b/test/convlit.go index 94889d4a9..90ac5490c 100644 --- a/test/convlit.go +++ b/test/convlit.go @@ -11,54 +11,56 @@ package main // the language spec says for now. var x1 = string(1) var x2 string = string(1) -var x3 = int(1.5) // ERROR "convert|truncate" -var x4 int = int(1.5) // ERROR "convert|truncate" +var x3 = int(1.5) // ERROR "convert|truncate" +var x4 int = int(1.5) // ERROR "convert|truncate" var x5 = "a" + string(1) -var x6 = int(1e100) // ERROR "overflow" -var x7 = float(1e1000) // ERROR "overflow" +var x6 = int(1e100) // ERROR "overflow" +var x7 = float32(1e1000) // ERROR "overflow" // implicit conversions merit scrutiny var s string -var bad1 string = 1 // ERROR "conver|incompatible|invalid|cannot" -var bad2 = s + 1 // ERROR "conver|incompatible|invalid" -var bad3 = s + 'a' // ERROR "conver|incompatible|invalid" -var bad4 = "a" + 1 // ERROR "literals|incompatible|convert|invalid" -var bad5 = "a" + 'a' // ERROR "literals|incompatible|convert|invalid" +var bad1 string = 1 // ERROR "conver|incompatible|invalid|cannot" +var bad2 = s + 1 // ERROR "conver|incompatible|invalid" +var bad3 = s + 'a' // ERROR "conver|incompatible|invalid" +var bad4 = "a" + 1 // ERROR "literals|incompatible|convert|invalid" +var bad5 = "a" + 'a' // ERROR "literals|incompatible|convert|invalid" -var bad6 int = 1.5 // ERROR "convert|truncate" -var bad7 int = 1e100 // ERROR "overflow" -var bad8 float32 = 1e200 // ERROR "overflow" +var bad6 int = 1.5 // ERROR "convert|truncate" +var bad7 int = 1e100 // ERROR "overflow" +var bad8 float32 = 1e200 // ERROR "overflow" // but these implicit conversions are okay var good1 string = "a" var good2 int = 1.0 var good3 int = 1e9 -var good4 float = 1e20 +var good4 float64 = 1e20 // explicit conversion of string is okay var _ = []int("abc") var _ = []byte("abc") // implicit is not -var _ []int = "abc" // ERROR "cannot use|incompatible|invalid" -var _ []byte = "abc" // ERROR "cannot use|incompatible|invalid" +var _ []int = "abc" // ERROR "cannot use|incompatible|invalid" +var _ []byte = "abc" // ERROR "cannot use|incompatible|invalid" // named string is okay type Tstring string + var ss Tstring = "abc" var _ = []int(ss) var _ = []byte(ss) // implicit is still not -var _ []int = ss // ERROR "cannot use|incompatible|invalid" -var _ []byte = ss // ERROR "cannot use|incompatible|invalid" +var _ []int = ss // ERROR "cannot use|incompatible|invalid" +var _ []byte = ss // ERROR "cannot use|incompatible|invalid" // named slice is not type Tint []int type Tbyte []byte -var _ = Tint("abc") // ERROR "convert|incompatible|invalid" -var _ = Tbyte("abc") // ERROR "convert|incompatible|invalid" + +var _ = Tint("abc") // ERROR "convert|incompatible|invalid" +var _ = Tbyte("abc") // ERROR "convert|incompatible|invalid" // implicit is still not -var _ Tint = "abc" // ERROR "cannot use|incompatible|invalid" -var _ Tbyte = "abc" // ERROR "cannot use|incompatible|invalid" +var _ Tint = "abc" // ERROR "cannot use|incompatible|invalid" +var _ Tbyte = "abc" // ERROR "cannot use|incompatible|invalid" diff --git a/test/decl.go b/test/decl.go index c31082bcf..95b6346c3 100644 --- a/test/decl.go +++ b/test/decl.go @@ -8,26 +8,26 @@ package main -func f1() int { return 1 } -func f2() (float, int) { return 1, 2 } -func f3() (float, int, string) { return 1, 2, "3" } +func f1() int { return 1 } +func f2() (float32, int) { return 1, 2 } +func f3() (float32, int, string) { return 1, 2, "3" } func x() (s string) { a, b, s := f3() _, _ = a, b - return // tests that result var is in scope for redeclaration + return // tests that result var is in scope for redeclaration } func main() { i, f, s := f3() - j, f := f2() // redeclare f + j, f := f2() // redeclare f k := f1() m, g, s := f3() m, h, s := f3() { // new block should be ok. i, f, s := f3() - j, f := f2() // redeclare f + j, f := f2() // redeclare f k := f1() m, g, s := f3() m, h, s := f3() diff --git a/test/declbad.go b/test/declbad.go index 269ebdefb..5e5e14501 100644 --- a/test/declbad.go +++ b/test/declbad.go @@ -8,51 +8,51 @@ package main -func f1() int { return 1 } -func f2() (float, int) { return 1, 2 } -func f3() (float, int, string) { return 1, 2, "3" } +func f1() int { return 1 } +func f2() (float32, int) { return 1, 2 } +func f3() (float32, int, string) { return 1, 2, "3" } func main() { { // simple redeclaration i := f1() - i := f1() // ERROR "redeclared|no new" + i := f1() // ERROR "redeclared|no new" _ = i } { // change of type for f i, f, s := f3() - f, g, t := f3() // ERROR "redeclared|cannot assign|incompatible" + f, g, t := f3() // ERROR "redeclared|cannot assign|incompatible" _, _, _, _, _ = i, f, s, g, t } { // change of type for i i, f, s := f3() - j, i, t := f3() // ERROR "redeclared|cannot assign|incompatible" + j, i, t := f3() // ERROR "redeclared|cannot assign|incompatible" _, _, _, _, _ = i, f, s, j, t } { // no new variables i, f, s := f3() - i, f := f2() // ERROR "redeclared|no new" + i, f := f2() // ERROR "redeclared|no new" _, _, _ = i, f, s } { // single redeclaration i, f, s := f3() - i := f1() // ERROR "redeclared|no new|incompatible" + i := f1() // ERROR "redeclared|no new|incompatible" _, _, _ = i, f, s } - // double redeclaration + // double redeclaration { i, f, s := f3() - i, f := f2() // ERROR "redeclared|no new" + i, f := f2() // ERROR "redeclared|no new" _, _, _ = i, f, s } { // triple redeclaration i, f, s := f3() - i, f, s := f3() // ERROR "redeclared|no new" + i, f, s := f3() // ERROR "redeclared|no new" _, _, _ = i, f, s } } diff --git a/test/fixedbugs/bug006.go b/test/fixedbugs/bug006.go index e7694f95b..43b5dfb12 100644 --- a/test/fixedbugs/bug006.go +++ b/test/fixedbugs/bug006.go @@ -9,11 +9,16 @@ package main import "os" const ( - x float = iota; - g float = 4.5 * iota; -); + x float64 = iota + g float64 = 4.5 * iota +) func main() { - if g == 0.0 { print("zero\n");} - if g != 4.5 { print(" fail\n"); os.Exit(1); } + if g == 0.0 { + print("zero\n") + } + if g != 4.5 { + print(" fail\n") + os.Exit(1) + } } diff --git a/test/fixedbugs/bug007.go b/test/fixedbugs/bug007.go index bd970de5f..d65f6da45 100644 --- a/test/fixedbugs/bug007.go +++ b/test/fixedbugs/bug007.go @@ -7,7 +7,9 @@ package main type ( - Point struct { x, y float }; + Point struct { + x, y float64 + } Polar Point ) diff --git a/test/fixedbugs/bug010.go b/test/fixedbugs/bug010.go index e71c4d7f0..7d96988d4 100644 --- a/test/fixedbugs/bug010.go +++ b/test/fixedbugs/bug010.go @@ -7,14 +7,14 @@ package main -func f(i int, f float) { - i = 8; - f = 8.0; - return; +func f(i int, f float64) { + i = 8 + f = 8.0 + return } func main() { - f(3, float(5)) + f(3, float64(5)) } /* diff --git a/test/fixedbugs/bug011.go b/test/fixedbugs/bug011.go index 551adb77d..ce627472c 100644 --- a/test/fixedbugs/bug011.go +++ b/test/fixedbugs/bug011.go @@ -8,19 +8,19 @@ package main type T struct { - x, y int; + x, y int } -func (t *T) m(a int, b float) int { - return (t.x+a) * (t.y+int(b)); +func (t *T) m(a int, b float64) int { + return (t.x + a) * (t.y + int(b)) } func main() { - var t *T = new(T); - t.x = 1; - t.y = 2; - r10 := t.m(1, 3.0); - _ = r10; + var t *T = new(T) + t.x = 1 + t.y = 2 + r10 := t.m(1, 3.0) + _ = r10 } /* bug11.go:16: fatal error: walktype: switch 1 unknown op CALLMETH l(16) <int32>INT32 diff --git a/test/fixedbugs/bug035.go b/test/fixedbugs/bug035.go index 461c0607a..bd2a633f2 100644 --- a/test/fixedbugs/bug035.go +++ b/test/fixedbugs/bug035.go @@ -6,8 +6,8 @@ package main -func f9(a int) (i int, f float) { - i := 9; // ERROR "redecl|no new" - f := float(9); // ERROR "redecl|no new" - return i, f; +func f9(a int) (i int, f float64) { + i := 9 // ERROR "redecl|no new" + f := float64(9) // ERROR "redecl|no new" + return i, f } diff --git a/test/fixedbugs/bug047.go b/test/fixedbugs/bug047.go index f3749e739..5a776abce 100644 --- a/test/fixedbugs/bug047.go +++ b/test/fixedbugs/bug047.go @@ -9,15 +9,15 @@ package main func main() { type T struct { - s string; - f float; - }; - var s string = "hello"; - var f float = 0.2; - t := T{s, f}; + s string + f float64 + } + var s string = "hello" + var f float64 = 0.2 + t := T{s, f} - type M map[int] int; - m0 := M{7:8}; + type M map[int]int + m0 := M{7: 8} - _, _ = t, m0; + _, _ = t, m0 } diff --git a/test/fixedbugs/bug080.go b/test/fixedbugs/bug080.go index a5003d29b..bae16cdb2 100644 --- a/test/fixedbugs/bug080.go +++ b/test/fixedbugs/bug080.go @@ -4,18 +4,18 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -package main - -func f1() (x int, y float) { - return; +package main + +func f1() (x int, y float64) { + return } -func f2 (x int, y float) { - return; +func f2(x int, y float64) { + return } func main() { - f2(f1()); // this should be a legal call + f2(f1()) // this should be a legal call } /* diff --git a/test/fixedbugs/bug109.go b/test/fixedbugs/bug109.go index c679771f2..766657723 100644 --- a/test/fixedbugs/bug109.go +++ b/test/fixedbugs/bug109.go @@ -5,10 +5,11 @@ // license that can be found in the LICENSE file. package main -func f(a float) float { - e := 1.0; - e = e * a; - return e; + +func f(a float64) float64 { + e := 1.0 + e = e * a + return e } /* diff --git a/test/fixedbugs/bug167.go b/test/fixedbugs/bug167.go index 729299b66..33eb3cb1a 100644 --- a/test/fixedbugs/bug167.go +++ b/test/fixedbugs/bug167.go @@ -7,20 +7,24 @@ package main func f1() { - type T struct { x int } + type T struct { + x int + } } func f2() { - type T struct { x float } + type T struct { + x float64 + } } func main() { - f1(); - f2(); + f1() + f2() } /* 1606416576: conflicting definitions for main.T·bug167 bug167.6: type main.T·bug167 struct { x int } -bug167.6: type main.T·bug167 struct { x float } +bug167.6: type main.T·bug167 struct { x float64 } */ diff --git a/test/fixedbugs/bug193.go b/test/fixedbugs/bug193.go index f6b03e13d..5ef02b1c1 100644 --- a/test/fixedbugs/bug193.go +++ b/test/fixedbugs/bug193.go @@ -7,10 +7,10 @@ package main func main() { - s := uint(10); - ss := 1<<s; - y1 := float(ss); - y2 := float(1<<s); // ERROR "shift" - y3 := string(1<<s); // ERROR "shift" - _, _, _, _, _ = s, ss, y1, y2, y3; + s := uint(10) + ss := 1 << s + y1 := float64(ss) + y2 := float64(1 << s) // ERROR "shift" + y3 := string(1 << s) // ERROR "shift" + _, _, _, _, _ = s, ss, y1, y2, y3 } diff --git a/test/fixedbugs/bug220.go b/test/fixedbugs/bug220.go index 3f8aaa4ec..ff027ddc2 100644 --- a/test/fixedbugs/bug220.go +++ b/test/fixedbugs/bug220.go @@ -7,8 +7,8 @@ package main func main() { - m := make(map[int]map[uint]float); - - m[0] = make(map[uint]float), false; // 6g used to reject this - m[1] = nil; + m := make(map[int]map[uint]float64) + + m[0] = make(map[uint]float64), false // 6g used to reject this + m[1] = nil } diff --git a/test/fixedbugs/bug230.go b/test/fixedbugs/bug230.go index 81b256e31..c7ad1a366 100644 --- a/test/fixedbugs/bug230.go +++ b/test/fixedbugs/bug230.go @@ -8,14 +8,17 @@ package main type S string type I int -type F float +type F float64 func (S) m() {} func (I) m() {} func (F) m() {} func main() { - c := make(chan interface { m() }, 10) + c := make(chan interface { + m() + }, + 10) c <- I(0) c <- F(1) c <- S("hi") diff --git a/test/fixedbugs/bug238.go b/test/fixedbugs/bug238.go index 8b7c7ac38..7e8660d37 100644 --- a/test/fixedbugs/bug238.go +++ b/test/fixedbugs/bug238.go @@ -17,6 +17,6 @@ const f struct{} = 6 // ERROR "convert|wrong|invalid" const g interface{} = 7 // ERROR "constant|wrong|invalid" const h bool = false const i int = 2 -const j float = 5 +const j float64 = 5 func main() { println(a, b, c, d, e, f, g) } diff --git a/test/fixedbugs/bug248.dir/bug2.go b/test/fixedbugs/bug248.dir/bug2.go index 68c0ce0bc..4ea187a4b 100644 --- a/test/fixedbugs/bug248.dir/bug2.go +++ b/test/fixedbugs/bug248.dir/bug2.go @@ -23,7 +23,7 @@ type t0 int func (t0) M(p0.T) {} -type t1 float +type t1 float64 func (t1) M(p1.T) {} diff --git a/test/fixedbugs/bug248.dir/bug3.go b/test/fixedbugs/bug248.dir/bug3.go index c96bf1676..e5a244955 100644 --- a/test/fixedbugs/bug248.dir/bug3.go +++ b/test/fixedbugs/bug248.dir/bug3.go @@ -26,7 +26,7 @@ type t0 int func (t0) M(p0.T) {} // t1 satisfies I1 and p1.I -type t1 float +type t1 float64 func (t1) M(p1.T) {} diff --git a/test/fixedbugs/bug299.go b/test/fixedbugs/bug299.go index 4d7314432..1c7adb5f5 100644 --- a/test/fixedbugs/bug299.go +++ b/test/fixedbugs/bug299.go @@ -11,9 +11,9 @@ type T struct { x int y (int) int - *float + *float64 // not legal according to spec - (complex) // ERROR "non-declaration|expected|parenthesize" + (complex128) // ERROR "non-declaration|expected|parenthesize" (*string) // ERROR "non-declaration|expected|parenthesize" *(bool) // ERROR "non-declaration|expected|parenthesize" } diff --git a/test/fixedbugs/bug307.go b/test/fixedbugs/bug307.go index a1a30dfb7..1b42c09ab 100644 --- a/test/fixedbugs/bug307.go +++ b/test/fixedbugs/bug307.go @@ -5,11 +5,11 @@ // license that can be found in the LICENSE file. // Valid program, gccgo reported an error. -// bug307.go:14:6: error: cmplx arguments must have identical types +// bug307.go:14:6: error: complex arguments must have identical types package main func main() { var f float64 - _ = cmplx(1 / f, 0) + _ = complex(1/f, 0) } diff --git a/test/fixedbugs/bug315.go b/test/fixedbugs/bug315.go index 198bae77a..c59ef29e6 100644 --- a/test/fixedbugs/bug315.go +++ b/test/fixedbugs/bug315.go @@ -9,7 +9,7 @@ package main func main() { - a := cmplx(2, 2) + a := complex(2, 2) a /= 2 } diff --git a/test/fixedbugs/bug316.go b/test/fixedbugs/bug316.go index bd4d99eb6..2146408a1 100644 --- a/test/fixedbugs/bug316.go +++ b/test/fixedbugs/bug316.go @@ -9,7 +9,7 @@ package main const ( - c = cmplx(1, 2) + c = complex(1, 2) r = real(c) // was: const initializer must be constant i = imag(c) // was: const initializer must be constant ) diff --git a/test/func.go b/test/func.go index 0c1a07979..e8ed928bc 100644 --- a/test/func.go +++ b/test/func.go @@ -21,10 +21,10 @@ func f2(a int) { } func f3(a, b int) int { - return a+b + return a + b } -func f4(a, b int, c float) int { +func f4(a, b int, c float32) int { return (a+b)/2 + int(c) } @@ -36,12 +36,12 @@ func f6(a int) (r int) { return 6 } -func f7(a int) (x int, y float) { +func f7(a int) (x int, y float32) { return 7, 7.0 } -func f8(a int) (x int, y float) { +func f8(a int) (x int, y float32) { return 8, 8.0 } @@ -49,12 +49,12 @@ type T struct { x, y int } -func (t *T) m10(a int, b float) int { - return (t.x+a) * (t.y+int(b)) +func (t *T) m10(a int, b float32) int { + return (t.x + a) * (t.y + int(b)) } -func f9(a int) (i int, f float) { +func f9(a int) (i int, f float32) { i = 9 f = 9.0 return diff --git a/test/func1.go b/test/func1.go index 56f4dfcba..056ff9877 100644 --- a/test/func1.go +++ b/test/func1.go @@ -8,11 +8,11 @@ package main -func f1(a int) (int, float) { // BUG (not caught by compiler): multiple return values must have names +func f1(a int) (int, float32) { // BUG (not caught by compiler): multiple return values must have names return 7, 7.0 } -func f2(a int) (a int, b float) { // ERROR "redeclared|definition" +func f2(a int) (a int, b float32) { // ERROR "redeclared|definition" return 8, 8.0 } diff --git a/test/golden.out b/test/golden.out index 04c71327b..83e8327a5 100644 --- a/test/golden.out +++ b/test/golden.out @@ -60,7 +60,6 @@ Hello World! =========== ken/cplx3.go (+1.292308e+000-1.384615e-001i) (+1.292308e+000-1.384615e-001i) -64 =========== ken/cplx4.go c = (-5.000000-6.000000i) diff --git a/test/interface/explicit.go b/test/interface/explicit.go index b952f8fc8..b6a582fff 100644 --- a/test/interface/explicit.go +++ b/test/interface/explicit.go @@ -51,21 +51,25 @@ func main() { t = T(e) // ERROR "need explicit|need type assertion|incompatible" } -type M interface { M() } +type M interface { + M() +} + var m M -var _ = m.(int) // ERROR "impossible type assertion" +var _ = m.(int) // ERROR "impossible type assertion" type Int int -func (Int) M(float) {} -var _ = m.(Int) // ERROR "impossible type assertion" +func (Int) M(float64) {} + +var _ = m.(Int) // ERROR "impossible type assertion" var ii int var jj Int -var m1 M = ii // ERROR "incompatible|missing" -var m2 M = jj // ERROR "incompatible|wrong type for M method" +var m1 M = ii // ERROR "incompatible|missing" +var m2 M = jj // ERROR "incompatible|wrong type for M method" -var m3 = M(ii) // ERROR "invalid|missing" -var m4 = M(jj) // ERROR "invalid|wrong type for M method" +var m3 = M(ii) // ERROR "invalid|missing" +var m4 = M(jj) // ERROR "invalid|wrong type for M method" diff --git a/test/iota.go b/test/iota.go index 20b77c6cc..c40ca1f38 100644 --- a/test/iota.go +++ b/test/iota.go @@ -17,8 +17,8 @@ const ( x int = iota y = iota z = 1 << iota - f float = 2 * iota - g float = 4.5 * float(iota) + f float32 = 2 * iota + g float32 = 4.5 * float32(iota) ) const ( @@ -57,7 +57,7 @@ const ( ) const ( - p = float(iota) + p = float32(iota) q r ) @@ -68,9 +68,9 @@ const ( ) const ( - abit, amask = 1 << iota, 1 << iota - 1 - bbit, bmask = 1 << iota, 1 << iota - 1 - cbit, cmask = 1 << iota, 1 << iota - 1 + abit, amask = 1 << iota, 1<<iota - 1 + bbit, bmask = 1 << iota, 1<<iota - 1 + cbit, cmask = 1 << iota, 1<<iota - 1 ) func main() { diff --git a/test/ken/cplx0.go b/test/ken/cplx0.go index 6e9bfd023..ba1fa196f 100644 --- a/test/ken/cplx0.go +++ b/test/ken/cplx0.go @@ -13,7 +13,7 @@ const ( C1 = R + I // ADD(5,6) ) -func doprint(c complex) { println(c) } +func doprint(c complex128) { println(c) } func main() { diff --git a/test/ken/cplx1.go b/test/ken/cplx1.go index 26b113992..8ec7d40f5 100644 --- a/test/ken/cplx1.go +++ b/test/ken/cplx1.go @@ -48,7 +48,7 @@ func main() { booltest(6+9i, false) } -func booltest(a complex, r bool) { +func booltest(a complex64, r bool) { var b bool b = a == C1 diff --git a/test/ken/cplx2.go b/test/ken/cplx2.go index 5a66dc9a9..b36e93ecd 100644 --- a/test/ken/cplx2.go +++ b/test/ken/cplx2.go @@ -28,13 +28,13 @@ const ( func main() { - r := 5 + 0i + var r complex64 = 5 + 0i if r != R { println("opcode 1", r, R) panic("fail") } - i := 6i + var i complex64 = 6i if i != I { println("opcode 2", i, I) panic("fail") diff --git a/test/ken/cplx3.go b/test/ken/cplx3.go index 997894b41..83acc15ff 100644 --- a/test/ken/cplx3.go +++ b/test/ken/cplx3.go @@ -16,24 +16,18 @@ const ( C1 = R + I // ADD(5,6) ) -var complexBits = reflect.Typeof(complex(0i)).Size() * 8 - func main() { c0 := C1 c0 = (c0 + c0 + c0) / (c0 + c0 + 3i) println(c0) - c := *(*complex)(unsafe.Pointer(&c0)) + c := *(*complex128)(unsafe.Pointer(&c0)) println(c) - println(complexBits) - var a interface{} switch c := reflect.NewValue(a).(type) { case *reflect.ComplexValue: - if complexBits == 64 { - v := c.Get() - _, _ = complex64(v), true - } + v := c.Get() + _, _ = complex128(v), true } } diff --git a/test/ken/cplx4.go b/test/ken/cplx4.go index 3c6f1f68c..8524e47ae 100644 --- a/test/ken/cplx4.go +++ b/test/ken/cplx4.go @@ -15,7 +15,7 @@ const ( C1 = R + I // ADD(5,6) ) -func doprint(c complex) { fmt.Printf("c = %f\n", c) } +func doprint(c complex128) { fmt.Printf("c = %f\n", c) } func main() { @@ -32,12 +32,12 @@ func main() { c2 := complex128(C1) fmt.Printf("c = %G\n", c2) - // real, imag, cmplx - c3 := cmplx(real(c2)+3, imag(c2)-5) + c2 + // real, imag, complex + c3 := complex(real(c2)+3, imag(c2)-5) + c2 fmt.Printf("c = %G\n", c3) // compiler used to crash on nested divide - c4 := cmplx(real(c3/2), imag(c3/2)) + c4 := complex(real(c3/2), imag(c3/2)) if c4 != c3/2 { fmt.Printf("BUG: c3 = %G != c4 = %G\n", c3, c4) } diff --git a/test/ken/cplx5.go b/test/ken/cplx5.go index af2a1c57d..d425a7c4c 100644 --- a/test/ken/cplx5.go +++ b/test/ken/cplx5.go @@ -6,49 +6,49 @@ package main -var a [12]complex -var s []complex -var c chan complex +var a [12]complex128 +var s []complex128 +var c chan complex128 var f struct { - c complex + c complex128 } -var m map[complex]complex +var m map[complex128]complex128 func main() { - // array of complex + // array of complex128 for i := 0; i < len(a); i++ { - a[i] = cmplx(float(i), float(-i)) + a[i] = complex(float64(i), float64(-i)) } println(a[5]) - // slice of complex - s = make([]complex, len(a)) + // slice of complex128 + s = make([]complex128, len(a)) for i := 0; i < len(s); i++ { s[i] = a[i] } println(s[5]) // chan - c = make(chan complex) + c = make(chan complex128) go chantest(c) println(<-c) - // pointer of complex + // pointer of complex128 v := a[5] pv := &v println(*pv) - // field of complex + // field of complex128 f.c = a[5] println(f.c) - // map of complex - m = make(map[complex]complex) + // map of complex128 + m = make(map[complex128]complex128) for i := 0; i < len(s); i++ { m[-a[i]] = a[i] } println(m[5i-5]) - println(m[cmplx(-5, 5)]) + println(m[complex(-5, 5)]) } -func chantest(c chan complex) { c <- a[5] } +func chantest(c chan complex128) { c <- a[5] } diff --git a/test/ken/robfunc.go b/test/ken/robfunc.go index 12b4b6d7b..6b3d4b2e4 100644 --- a/test/ken/robfunc.go +++ b/test/ken/robfunc.go @@ -8,8 +8,8 @@ package main func assertequal(is, shouldbe int, msg string) { if is != shouldbe { - print("assertion fail" + msg + "\n"); - panic(1); + print("assertion fail" + msg + "\n") + panic(1) } } @@ -20,75 +20,75 @@ func f2(a int) { } func f3(a, b int) int { - return a+b; + return a + b } -func f4(a, b int, c float) int { - return (a+b)/2 + int(c); +func f4(a, b int, c float64) int { + return (a+b)/2 + int(c) } func f5(a int) int { - return 5; + return 5 } func f6(a int) (r int) { - return 6; + return 6 } -func f7(a int) (x int, y float) { - return 7, 7.0; +func f7(a int) (x int, y float64) { + return 7, 7.0 } -func f8(a int) (x int, y float) { - return 8, 8.0; +func f8(a int) (x int, y float64) { + return 8, 8.0 } type T struct { - x, y int; + x, y int } -func (t *T) m10(a int, b float) int { - return (t.x+a) * (t.y+int(b)); +func (t *T) m10(a int, b float64) int { + return (t.x + a) * (t.y + int(b)) } -func f9(a int) (in int, fl float) { - i := 9; - f := float(9); - return i, f; +func f9(a int) (in int, fl float64) { + i := 9 + f := float64(9) + return i, f } func main() { - f1(); - f2(1); - r3 := f3(1, 2); - assertequal(r3, 3, "3"); - r4 := f4(0, 2, 3.0); - assertequal(r4, 4, "4"); - r5 := f5(1); - assertequal(r5, 5, "5"); - r6 := f6(1); - assertequal(r6, 6, "6"); - var r7 int; - var s7 float; - r7, s7 = f7(1); - assertequal(r7, 7, "r7"); - assertequal(int(s7), 7, "s7"); - var r8 int; - var s8 float; - r8, s8 = f8(1); - assertequal(r8, 8, "r8"); - assertequal(int(s8), 8, "s8"); - var r9 int; - var s9 float; - r9, s9 = f9(1); - assertequal(r9, 9, "r9"); - assertequal(int(s9), 9, "s9"); - var t *T = new(T); - t.x = 1; - t.y = 2; - r10 := t.m10(1, 3.0); - assertequal(r10, 10, "10"); + f1() + f2(1) + r3 := f3(1, 2) + assertequal(r3, 3, "3") + r4 := f4(0, 2, 3.0) + assertequal(r4, 4, "4") + r5 := f5(1) + assertequal(r5, 5, "5") + r6 := f6(1) + assertequal(r6, 6, "6") + var r7 int + var s7 float64 + r7, s7 = f7(1) + assertequal(r7, 7, "r7") + assertequal(int(s7), 7, "s7") + var r8 int + var s8 float64 + r8, s8 = f8(1) + assertequal(r8, 8, "r8") + assertequal(int(s8), 8, "s8") + var r9 int + var s9 float64 + r9, s9 = f9(1) + assertequal(r9, 9, "r9") + assertequal(int(s9), 9, "s9") + var t *T = new(T) + t.x = 1 + t.y = 2 + r10 := t.m10(1, 3.0) + assertequal(r10, 10, "10") } diff --git a/test/ken/simpconv.go b/test/ken/simpconv.go index cb443e3a1..feb85d299 100644 --- a/test/ken/simpconv.go +++ b/test/ken/simpconv.go @@ -6,20 +6,23 @@ package main -type vlong int64; -type short int16; +type vlong int64 +type short int16 -func -main() { - s1 := vlong(0); - for i:=short(0); i<10; i=i+1 { - s1 = s1 + vlong(i); +func main() { + s1 := vlong(0) + for i := short(0); i < 10; i = i + 1 { + s1 = s1 + vlong(i) + } + if s1 != 45 { + panic(s1) } - if s1 != 45 { panic(s1); } - s2 := float(0); - for i:=0; i<10; i=i+1 { - s2 = s2 + float(i); + s2 := float64(0) + for i := 0; i < 10; i = i + 1 { + s2 = s2 + float64(i) + } + if s2 != 45 { + panic(s2) } - if s2 != 45 { panic(s2); } } diff --git a/test/ken/slicearray.go b/test/ken/slicearray.go index 6e7088e19..5c31270fc 100644 --- a/test/ken/slicearray.go +++ b/test/ken/slicearray.go @@ -8,8 +8,8 @@ package main var bx [10]byte var by []byte -var fx [10]float -var fy []float +var fx [10]float64 +var fy []float64 var lb, hb int var t int @@ -87,7 +87,7 @@ func main() { by = bx[2:8] tstb() - // width 4 (float) + // width 4 (float64) lb = 0 hb = 10 fy = fx[lb:hb] @@ -204,7 +204,7 @@ func init() { by = nil for i := 0; i < len(fx); i++ { - fx[i] = float(i + 20) + fx[i] = float64(i + 20) } fy = nil } diff --git a/test/ken/sliceslice.go b/test/ken/sliceslice.go index 5a35acaf4..639042128 100644 --- a/test/ken/sliceslice.go +++ b/test/ken/sliceslice.go @@ -8,8 +8,8 @@ package main var bx []byte var by []byte -var fx []float -var fy []float +var fx []float64 +var fy []float64 var lb, hb int var t int @@ -78,7 +78,7 @@ func main() { by = bx[2:8] tstb() - // width 4 (float) + // width 4 (float64) lb = 0 hb = 10 fy = fx[lb:hb] @@ -195,9 +195,9 @@ func init() { } by = nil - fx = make([]float, 10) + fx = make([]float64, 10) for i := 0; i < len(fx); i++ { - fx[i] = float(i + 20) + fx[i] = float64(i + 20) } fy = nil } diff --git a/test/literal.go b/test/literal.go index 9bdbabca8..bf0538812 100644 --- a/test/literal.go +++ b/test/literal.go @@ -18,7 +18,7 @@ func assert(cond bool, msg string) { } } -func equal(a, b float) bool { +func equal(a, b float32) bool { return a == b } @@ -116,23 +116,23 @@ func main() { _, _, _, _ = u30, u31, u32, u33 // float - var f00 float = 3.14159 - var f01 float = -3.14159 - var f02 float = +3.14159 - var f03 float = 0.0 - var f04 float = .0 - var f05 float = 0. - var f06 float = -0.0 - var f07 float = 1e10 - var f08 float = -1e10 - var f09 float = 1e-10 - var f10 float = 1e+10 - var f11 float = 1.e-10 - var f12 float = 1.e+10 - var f13 float = .1e-10 - var f14 float = .1e+10 - var f15 float = 1.1e-10 - var f16 float = 1.1e+10 + var f00 float32 = 3.14159 + var f01 float32 = -3.14159 + var f02 float32 = +3.14159 + var f03 float32 = 0.0 + var f04 float32 = .0 + var f05 float32 = 0. + var f06 float32 = -0.0 + var f07 float32 = 1e10 + var f08 float32 = -1e10 + var f09 float32 = 1e-10 + var f10 float32 = 1e+10 + var f11 float32 = 1.e-10 + var f12 float32 = 1.e+10 + var f13 float32 = .1e-10 + var f14 float32 = .1e+10 + var f15 float32 = 1.1e-10 + var f16 float32 = 1.1e+10 assert(f01 == -f00, "f01") assert(f02 == -f01, "f02") assert(f03 == f04, "f03") diff --git a/test/map.go b/test/map.go index ddff7c7a7..c3963499b 100644 --- a/test/map.go +++ b/test/map.go @@ -21,73 +21,73 @@ func P(a []string) string { } s += `"` + a[i] + `"` } - s +="}" + s += "}" return s } func main() { // Test a map literal. - mlit := map[string] int { "0":0, "1":1, "2":2, "3":3, "4":4 } + mlit := map[string]int{"0": 0, "1": 1, "2": 2, "3": 3, "4": 4} for i := 0; i < len(mlit); i++ { - s := string([]byte{byte(i)+'0'}) + s := string([]byte{byte(i) + '0'}) if mlit[s] != i { fmt.Printf("mlit[%s] = %d\n", s, mlit[s]) } } - mib := make(map[int] bool) - mii := make(map[int] int) - mfi := make(map[float] int) - mif := make(map[int] float) - msi := make(map[string] int) - mis := make(map[int] string) - mss := make(map[string] string) - mspa := make(map[string] []string) + mib := make(map[int]bool) + mii := make(map[int]int) + mfi := make(map[float32]int) + mif := make(map[int]float32) + msi := make(map[string]int) + mis := make(map[int]string) + mss := make(map[string]string) + mspa := make(map[string][]string) // BUG need an interface map both ways too type T struct { - i int64 // can't use string here; struct values are only compared at the top level - f float + i int64 // can't use string here; struct values are only compared at the top level + f float32 } - mipT := make(map[int] *T) - mpTi := make(map[*T] int) - mit := make(map[int] T) -// mti := make(map[T] int) + mipT := make(map[int]*T) + mpTi := make(map[*T]int) + mit := make(map[int]T) + // mti := make(map[T] int) - type M map[int] int - mipM := make(map[int] M) + type M map[int]int + mipM := make(map[int]M) - var apT [2*count]*T + var apT [2 * count]*T for i := 0; i < count; i++ { s := strconv.Itoa(i) - s10 := strconv.Itoa(i*10) - f := float(i) - t := T{int64(i),f} + s10 := strconv.Itoa(i * 10) + f := float32(i) + t := T{int64(i), f} apT[i] = new(T) apT[i].i = int64(i) apT[i].f = f - apT[2*i] = new(T) // need twice as many entries as we use, for the nonexistence check + apT[2*i] = new(T) // need twice as many entries as we use, for the nonexistence check apT[2*i].i = int64(i) apT[2*i].f = f - m := M{i: i+1} + m := M{i: i + 1} mib[i] = (i != 0) - mii[i] = 10*i - mfi[float(i)] = 10*i - mif[i] = 10.0*f + mii[i] = 10 * i + mfi[float32(i)] = 10 * i + mif[i] = 10.0 * f mis[i] = s msi[s] = i mss[s] = s10 mss[s] = s10 as := make([]string, 2) - as[0] = s10 - as[1] = s10 + as[0] = s10 + as[1] = s10 mspa[s] = as mipT[i] = apT[i] mpTi[apT[i]] = i mipM[i] = m mit[i] = t - // mti[t] = i + // mti[t] = i } // test len @@ -121,15 +121,15 @@ func main() { if len(mpTi) != count { fmt.Printf("len(mpTi) = %d\n", len(mpTi)) } -// if len(mti) != count { -// fmt.Printf("len(mti) = %d\n", len(mti)) -// } + // if len(mti) != count { + // fmt.Printf("len(mti) = %d\n", len(mti)) + // } if len(mipM) != count { fmt.Printf("len(mipM) = %d\n", len(mipM)) } -// if len(mti) != count { -// fmt.Printf("len(mti) = %d\n", len(mti)) -// } + // if len(mti) != count { + // fmt.Printf("len(mti) = %d\n", len(mti)) + // } if len(mit) != count { fmt.Printf("len(mit) = %d\n", len(mit)) } @@ -137,25 +137,25 @@ func main() { // test construction directly for i := 0; i < count; i++ { s := strconv.Itoa(i) - s10 := strconv.Itoa(i*10) - f := float(i) + s10 := strconv.Itoa(i * 10) + f := float32(i) // BUG m := M(i, i+1) if mib[i] != (i != 0) { fmt.Printf("mib[%d] = %t\n", i, mib[i]) } - if(mii[i] != 10*i) { + if mii[i] != 10*i { fmt.Printf("mii[%d] = %d\n", i, mii[i]) } - if(mfi[f] != 10*i) { + if mfi[f] != 10*i { fmt.Printf("mfi[%d] = %d\n", i, mfi[f]) } - if(mif[i] != 10.0*f) { + if mif[i] != 10.0*f { fmt.Printf("mif[%d] = %g\n", i, mif[i]) } - if(mis[i] != s) { + if mis[i] != s { fmt.Printf("mis[%d] = %s\n", i, mis[i]) } - if(msi[s] != i) { + if msi[s] != i { fmt.Printf("msi[%s] = %d\n", s, msi[s]) } if mss[s] != s10 { @@ -166,22 +166,22 @@ func main() { fmt.Printf("mspa[%s][%d] = %s\n", s, j, mspa[s][j]) } } - if(mipT[i].i != int64(i) || mipT[i].f != f) { + if mipT[i].i != int64(i) || mipT[i].f != f { fmt.Printf("mipT[%d] = %v\n", i, mipT[i]) } - if(mpTi[apT[i]] != i) { + if mpTi[apT[i]] != i { fmt.Printf("mpTi[apT[%d]] = %d\n", i, mpTi[apT[i]]) } - // if(mti[t] != i) { - // fmt.Printf("mti[%s] = %s\n", s, mti[t]) - // } - if (mipM[i][i] != i + 1) { + // if(mti[t] != i) { + // fmt.Printf("mti[%s] = %s\n", s, mti[t]) + // } + if mipM[i][i] != i+1 { fmt.Printf("mipM[%d][%d] = %d\n", i, i, mipM[i][i]) } - // if(mti[t] != i) { - // fmt.Printf("mti[%v] = %d\n", t, mti[t]) - // } - if(mit[i].i != int64(i) || mit[i].f != f) { + // if(mti[t] != i) { + // fmt.Printf("mti[%v] = %d\n", t, mti[t]) + // } + if mit[i].i != int64(i) || mit[i].f != f { fmt.Printf("mit[%d] = {%d %g}\n", i, mit[i].i, mit[i].f) } } @@ -190,7 +190,7 @@ func main() { // failed lookups yield a false value for the boolean. for i := 0; i < count; i++ { s := strconv.Itoa(i) - f := float(i) + f := float32(i) { _, b := mib[i] if !b { @@ -311,23 +311,23 @@ func main() { fmt.Printf("tuple existence assign: mit[%d]\n", i) } } -// { -// _, b := mti[t] -// if !b { -// fmt.Printf("tuple existence decl: mti[%d]\n", i) -// } -// _, b = mti[t] -// if !b { -// fmt.Printf("tuple existence assign: mti[%d]\n", i) -// } -// } + // { + // _, b := mti[t] + // if !b { + // fmt.Printf("tuple existence decl: mti[%d]\n", i) + // } + // _, b = mti[t] + // if !b { + // fmt.Printf("tuple existence assign: mti[%d]\n", i) + // } + // } } // test nonexistence with tuple check // failed lookups yield a false value for the boolean. for i := count; i < 2*count; i++ { s := strconv.Itoa(i) - f := float(i) + f := float32(i) { _, b := mib[i] if b { @@ -438,16 +438,16 @@ func main() { fmt.Printf("tuple nonexistence assign: mipM[%d]", i) } } -// { -// _, b := mti[t] -// if b { -// fmt.Printf("tuple nonexistence decl: mti[%d]", i) -// } -// _, b = mti[t] -// if b { -// fmt.Printf("tuple nonexistence assign: mti[%d]", i) -// } -// } + // { + // _, b := mti[t] + // if b { + // fmt.Printf("tuple nonexistence decl: mti[%d]", i) + // } + // _, b = mti[t] + // if b { + // fmt.Printf("tuple nonexistence assign: mti[%d]", i) + // } + // } { _, b := mit[i] if b { @@ -460,32 +460,31 @@ func main() { } } - // tests for structured map element updates for i := 0; i < count; i++ { s := strconv.Itoa(i) - mspa[s][i % 2] = "deleted" - if mspa[s][i % 2] != "deleted" { - fmt.Printf("update mspa[%s][%d] = %s\n", s, i %2, mspa[s][i % 2]) + mspa[s][i%2] = "deleted" + if mspa[s][i%2] != "deleted" { + fmt.Printf("update mspa[%s][%d] = %s\n", s, i%2, mspa[s][i%2]) } mipT[i].i += 1 if mipT[i].i != int64(i)+1 { fmt.Printf("update mipT[%d].i = %d\n", i, mipT[i].i) } - mipT[i].f = float(i + 1) - if (mipT[i].f != float(i + 1)) { + mipT[i].f = float32(i + 1) + if mipT[i].f != float32(i+1) { fmt.Printf("update mipT[%d].f = %g\n", i, mipT[i].f) } mipM[i][i]++ - if mipM[i][i] != (i + 1) + 1 { + if mipM[i][i] != (i+1)+1 { fmt.Printf("update mipM[%d][%d] = %i\n", i, i, mipM[i][i]) } } // test range on nil map - var mnil map[string] int + var mnil map[string]int for _, _ = range mnil { panic("range mnil") } diff --git a/test/named.go b/test/named.go index d2039bab4..5b6bb81fe 100644 --- a/test/named.go +++ b/test/named.go @@ -12,7 +12,7 @@ package main type Array [10]byte type Bool bool type Chan chan int -type Float float +type Float float32 type Int int type Map map[int]byte type Slice []byte diff --git a/test/nil.go b/test/nil.go index 6a72b72eb..4f4c75527 100644 --- a/test/nil.go +++ b/test/nil.go @@ -10,14 +10,13 @@ type T struct { i int } -type IN interface { -} +type IN interface{} func main() { var i *int - var f *float + var f *float32 var s *string - var m map[float] *int + var m map[float32]*int var c chan int var t *T var in IN diff --git a/test/recover2.go b/test/recover2.go index f33af4457..9affe25d4 100644 --- a/test/recover2.go +++ b/test/recover2.go @@ -58,7 +58,7 @@ func test3() { func test4() { defer mustRecover("interface") var x interface{} = 1 - println(x.(float)) + println(x.(float32)) } type T struct { diff --git a/test/test0.go b/test/test0.go index dd2033a98..d8d86c427 100644 --- a/test/test0.go +++ b/test/test0.go @@ -6,12 +6,11 @@ package main -const - a_const = 0 +const a_const = 0 const ( - pi = /* the usual */ 3.14159265358979323 - e = 2.718281828 + pi = /* the usual */ 3.14159265358979323 + e = 2.718281828 mask1 int = 1 << iota mask2 = 1 << iota mask3 = 1 << iota @@ -19,7 +18,7 @@ const ( ) type ( - Empty interface {} + Empty interface{} Point struct { x, y int } @@ -32,19 +31,21 @@ func (p *Point) Initialize(x, y int) *Point { } func (p *Point) Distance() int { - return p.x * p.x + p.y * p.y + return p.x*p.x + p.y*p.y } var ( - x1 int - x2 int - u, v, w float + x1 int + x2 int + u, v, w float32 ) func foo() {} func min(x, y int) int { - if x < y { return x; } + if x < y { + return x + } return y } @@ -57,24 +58,29 @@ func swap(x, y int) (u, v int) { func control_structs() { var p *Point = new(Point).Initialize(2, 3) i := p.Distance() - var f float = 0.3 + var f float32 = 0.3 _ = f - for {} - for {} + for { + } + for { + } for j := 0; j < i; j++ { if i == 0 { - } else i = 0 - var x float + } else { + i = 0 + } + var x float32 _ = x } - foo: // a label +foo: // a label var j int switch y := 0; true { case i < y: fallthrough case i < j: case i == 0, i == 1, i == j: - i++; i++ + i++ + i++ goto foo default: i = -+-+i diff --git a/test/typeswitch.go b/test/typeswitch.go index 9e6d10ea8..83fb0985a 100644 --- a/test/typeswitch.go +++ b/test/typeswitch.go @@ -21,12 +21,15 @@ const ( Last ) -type S struct { a int } +type S struct { + a int +} + var s S = S{1234} var c = make(chan int) -var a = []int{0,1,2,3} +var a = []int{0, 1, 2, 3} var m = make(map[string]int) @@ -68,10 +71,10 @@ func main() { assert(x == true && i == Bool, "bool") case int: assert(x == 7 && i == Int, "int") - case float: - assert(x == 7.4 && i == Float, "float") + case float64: + assert(x == 7.4 && i == Float, "float64") case string: - assert(x == "hello"&& i == String, "string") + assert(x == "hello" && i == String, "string") case S: assert(x.a == 1234 && i == Struct, "struct") case chan int: diff --git a/test/zerodivide.go b/test/zerodivide.go index cd4f52215..1948528d2 100644 --- a/test/zerodivide.go +++ b/test/zerodivide.go @@ -17,56 +17,90 @@ type Error interface { } type ErrorTest struct { - name string - fn func() - err string + name string + fn func() + err string } var ( - i, j, k int = 0, 0, 1 - i8, j8, k8 int8 = 0, 0, 1 + i, j, k int = 0, 0, 1 + i8, j8, k8 int8 = 0, 0, 1 i16, j16, k16 int16 = 0, 0, 1 i32, j32, k32 int32 = 0, 0, 1 i64, j64, k64 int64 = 0, 0, 1 - u, v, w uint = 0, 0, 1 - u8, v8, w8 uint8 = 0, 0, 1 - u16, v16, w16 uint16 = 0, 0, 1 - u32, v32, w32 uint32 = 0, 0, 1 - u64, v64, w64 uint64 = 0, 0, 1 - up, vp, wp uintptr = 0, 0, 1 + u, v, w uint = 0, 0, 1 + u8, v8, w8 uint8 = 0, 0, 1 + u16, v16, w16 uint16 = 0, 0, 1 + u32, v32, w32 uint32 = 0, 0, 1 + u64, v64, w64 uint64 = 0, 0, 1 + up, vp, wp uintptr = 0, 0, 1 - f, g, h float = 0, 0, 1 - f32, g32, h32 float32 = 0, 0, 1 + f, g, h float64 = 0, 0, 1 + f32, g32, h32 float32 = 0, 0, 1 f64, g64, h64, inf, negInf, nan float64 = 0, 0, 1, math.Inf(1), math.Inf(-1), math.NaN() - c, d, e complex = 0+0i, 0+0i, 1+1i - c64, d64, e64 complex64 = 0+0i, 0+0i, 1+1i - c128, d128, e128 complex128 = 0+0i, 0+0i, 1+1i + c, d, e complex128 = 0 + 0i, 0 + 0i, 1 + 1i + c64, d64, e64 complex64 = 0 + 0i, 0 + 0i, 1 + 1i + c128, d128, e128 complex128 = 0 + 0i, 0 + 0i, 1 + 1i ) // Fool gccgo into thinking that these variables can change. func NotCalled() { - i++; j++; k++ - i8++; j8++; k8++ - i16++; j16++; k16++ - i32++; j32++; k32++ - i64++; j64++; k64++ - - u++; v++; w++ - u8++; v8++; w8++ - u16++; v16++; w16++ - u32++; v32++; w32++ - u64++; v64++; w64++ - up++; vp++; wp++ - - f += 1; g += 1; h += 1 - f32 += 1; g32 += 1; h32 += 1 - f64 += 1; g64 += 1; h64 += 1 - - c += 1+1i; d += 1+1i; e += 1+1i - c64 += 1+1i; d64 += 1+1i; e64 += 1+1i - c128 += 1+1i; d128 += 1+1i; e128 += 1+1i + i++ + j++ + k++ + i8++ + j8++ + k8++ + i16++ + j16++ + k16++ + i32++ + j32++ + k32++ + i64++ + j64++ + k64++ + + u++ + v++ + w++ + u8++ + v8++ + w8++ + u16++ + v16++ + w16++ + u32++ + v32++ + w32++ + u64++ + v64++ + w64++ + up++ + vp++ + wp++ + + f += 1 + g += 1 + h += 1 + f32 += 1 + g32 += 1 + h32 += 1 + f64 += 1 + g64 += 1 + h64 += 1 + + c += 1 + 1i + d += 1 + 1i + e += 1 + 1i + c64 += 1 + 1i + d64 += 1 + 1i + e64 += 1 + 1i + c128 += 1 + 1i + d128 += 1 + 1i + e128 += 1 + 1i } var tmp interface{} @@ -79,52 +113,52 @@ func use(v interface{}) { // Verify error/no error for all types. var errorTests = []ErrorTest{ // All integer divide by zero should error. - ErrorTest{ "int 0/0", func() { use(i/j) }, "divide", }, - ErrorTest{ "int8 0/0", func() { use(i8/j8) }, "divide", }, - ErrorTest{ "int16 0/0", func() { use(i16/j16) }, "divide", }, - ErrorTest{ "int32 0/0", func() { use(i32/j32) }, "divide", }, - ErrorTest{ "int64 0/0", func() { use(i64/j64) }, "divide", }, - - ErrorTest{ "int 1/0", func() { use(k/j) }, "divide", }, - ErrorTest{ "int8 1/0", func() { use(k8/j8) }, "divide", }, - ErrorTest{ "int16 1/0", func() { use(k16/j16) }, "divide", }, - ErrorTest{ "int32 1/0", func() { use(k32/j32) }, "divide", }, - ErrorTest{ "int64 1/0", func() { use(k64/j64) }, "divide", }, - - ErrorTest{ "uint 0/0", func() { use(u/v) }, "divide", }, - ErrorTest{ "uint8 0/0", func() { use(u8/v8) }, "divide", }, - ErrorTest{ "uint16 0/0", func() { use(u16/v16) }, "divide", }, - ErrorTest{ "uint32 0/0", func() { use(u32/v32) }, "divide", }, - ErrorTest{ "uint64 0/0", func() { use(u64/v64) }, "divide", }, - ErrorTest{ "uintptr 0/0", func() { use(up/vp) }, "divide", }, - - ErrorTest{ "uint 1/0", func() { use(w/v) }, "divide", }, - ErrorTest{ "uint8 1/0", func() { use(w8/v8) }, "divide", }, - ErrorTest{ "uint16 1/0", func() { use(w16/v16) }, "divide", }, - ErrorTest{ "uint32 1/0", func() { use(w32/v32) }, "divide", }, - ErrorTest{ "uint64 1/0", func() { use(w64/v64) }, "divide", }, - ErrorTest{ "uintptr 1/0", func() { use(wp/vp) }, "divide", }, - - // All floating divide by zero should not error. - ErrorTest{ "float 0/0", func() { use(f/g) }, "", }, - ErrorTest{ "float32 0/0", func() { use(f32/g32) }, "", }, - ErrorTest{ "float64 0/0", func() { use(f64/g64) }, "", }, - - ErrorTest{ "float 1/0", func() { use(h/g) }, "", }, - ErrorTest{ "float32 1/0", func() { use(h32/g32) }, "", }, - ErrorTest{ "float64 1/0", func() { use(h64/g64) }, "", }, - ErrorTest{ "float64 inf/0", func() { use(inf/g64) }, "", }, - ErrorTest{ "float64 -inf/0", func() { use(negInf/g64) }, "", }, - ErrorTest{ "float64 nan/0", func() { use(nan/g64) }, "", }, + ErrorTest{"int 0/0", func() { use(i / j) }, "divide"}, + ErrorTest{"int8 0/0", func() { use(i8 / j8) }, "divide"}, + ErrorTest{"int16 0/0", func() { use(i16 / j16) }, "divide"}, + ErrorTest{"int32 0/0", func() { use(i32 / j32) }, "divide"}, + ErrorTest{"int64 0/0", func() { use(i64 / j64) }, "divide"}, + + ErrorTest{"int 1/0", func() { use(k / j) }, "divide"}, + ErrorTest{"int8 1/0", func() { use(k8 / j8) }, "divide"}, + ErrorTest{"int16 1/0", func() { use(k16 / j16) }, "divide"}, + ErrorTest{"int32 1/0", func() { use(k32 / j32) }, "divide"}, + ErrorTest{"int64 1/0", func() { use(k64 / j64) }, "divide"}, + + ErrorTest{"uint 0/0", func() { use(u / v) }, "divide"}, + ErrorTest{"uint8 0/0", func() { use(u8 / v8) }, "divide"}, + ErrorTest{"uint16 0/0", func() { use(u16 / v16) }, "divide"}, + ErrorTest{"uint32 0/0", func() { use(u32 / v32) }, "divide"}, + ErrorTest{"uint64 0/0", func() { use(u64 / v64) }, "divide"}, + ErrorTest{"uintptr 0/0", func() { use(up / vp) }, "divide"}, + + ErrorTest{"uint 1/0", func() { use(w / v) }, "divide"}, + ErrorTest{"uint8 1/0", func() { use(w8 / v8) }, "divide"}, + ErrorTest{"uint16 1/0", func() { use(w16 / v16) }, "divide"}, + ErrorTest{"uint32 1/0", func() { use(w32 / v32) }, "divide"}, + ErrorTest{"uint64 1/0", func() { use(w64 / v64) }, "divide"}, + ErrorTest{"uintptr 1/0", func() { use(wp / vp) }, "divide"}, + + // All float64ing divide by zero should not error. + ErrorTest{"float64 0/0", func() { use(f / g) }, ""}, + ErrorTest{"float32 0/0", func() { use(f32 / g32) }, ""}, + ErrorTest{"float64 0/0", func() { use(f64 / g64) }, ""}, + + ErrorTest{"float64 1/0", func() { use(h / g) }, ""}, + ErrorTest{"float32 1/0", func() { use(h32 / g32) }, ""}, + ErrorTest{"float64 1/0", func() { use(h64 / g64) }, ""}, + ErrorTest{"float64 inf/0", func() { use(inf / g64) }, ""}, + ErrorTest{"float64 -inf/0", func() { use(negInf / g64) }, ""}, + ErrorTest{"float64 nan/0", func() { use(nan / g64) }, ""}, // All complex divide by zero should not error. - ErrorTest{ "complex 0/0", func() { use(c/d) }, "", }, - ErrorTest{ "complex64 0/0", func() { use(c64/d64) }, "", }, - ErrorTest{ "complex128 0/0", func() { use(c128/d128) }, "", }, + ErrorTest{"complex 0/0", func() { use(c / d) }, ""}, + ErrorTest{"complex64 0/0", func() { use(c64 / d64) }, ""}, + ErrorTest{"complex128 0/0", func() { use(c128 / d128) }, ""}, - ErrorTest{ "complex 1/0", func() { use(e/d) }, "", }, - ErrorTest{ "complex64 1/0", func() { use(e64/d64) }, "", }, - ErrorTest{ "complex128 1/0", func() { use(e128/d128) }, "", }, + ErrorTest{"complex 1/0", func() { use(e / d) }, ""}, + ErrorTest{"complex64 1/0", func() { use(e64 / d64) }, ""}, + ErrorTest{"complex128 1/0", func() { use(e128 / d128) }, ""}, } func error(fn func()) (error string) { @@ -137,12 +171,12 @@ func error(fn func()) (error string) { return "" } -type FloatTest struct{ - f, g float64 - out float64 +type FloatTest struct { + f, g float64 + out float64 } -var floatTests = []FloatTest{ +var float64Tests = []FloatTest{ FloatTest{0, 0, nan}, FloatTest{nan, 0, nan}, FloatTest{inf, 0, inf}, @@ -194,8 +228,8 @@ func main() { } // At this point we know we don't error on the values we're testing - for _, t := range floatTests { - x := t.f/t.g + for _, t := range float64Tests { + x := t.f / t.g if !alike(x, t.out) { if !bad { bad = true |