delete float, complex - code changes

also:
	cmplx -> complex
	float64(1.0) -> 1.0
	float64(1) -> 1.0

R=gri, r, gri1, r2
CC=golang-dev
https://golang.org/cl/3991043

diff --git a/src/pkg/cmath/asin.go b/src/pkg/cmath/asin.go
index eb87ba5e5bdcc5e6a339dbecee449627606c3931..d6a3ca48026b46cc7028faaca133e3b72af828c2 100644 (file)
--- 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 bf1a9605df7d1dabea4a5d2e37b454f3eaba21fa..6a595b0a60953f1a35a41f000d4dc343025d6646 100644 (file)
--- 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 7a19e8631115539ccdcdfadd48637133ca2d2bec..776b57da7b7a5aaacf33f347ae91175149fe6525 100644 (file)
--- 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 1a639c5969e13654a76eecbe0a56fec16fdb7f16..64c1ef409399001d611b85761b8d33bae6a1ec03 100644 (file)
--- 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 f17a752ecb0c8ea369d66627340db3a1c231feba..f23d2dea7874a030c659b76c40020370a63267f6 100644 (file)
--- 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 8e971dbd3c4e2498ef3649e56d1863fa70fa7887..2063bb8356619c854918c2ed1c80275268048960 100644 (file)
--- 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 b42062b2ab9d934eb97e0e1a62bbadaca3348086..8e6964fee89c010b01984977d86f508f83639101 100644 (file)
--- 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 de2c4db56ea71dd5c2d5bb4ba995dd32cb8be30c..68e1207c674719223eb1811d3dc329cb13402b45 100644 (file)
--- 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 1a88d86792548facc9dabbc3141d6064cf732fcf..b955f0bf7d575c6e063dfb58688f3153b48f107e 100644 (file)
--- 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 1b79da493d9e691a09f029b77ac04f515d97ab52..8900ecddea3079b02336ea756dc08ae2fd0fb986 100644 (file)
--- 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 58bc4b691d00fe4ac4ec0df753b71d02d0d7ccd9..e77a9b9df216caa48bd6f97d25710d5d690673a4 100644 (file)
--- 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 d1945cd7900294bf2a63a14dc4929c0bc15ffe0f..94b517521ec8dff9efe35a1a3a2c5ac2aba735b1 100644 (file)
--- 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 93335ca60f2b9933e0e43d1e480553b3da28e93e..d540ace0502140450c98bcb4c0a44182cf3ff5cd 100644 (file)
--- 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 6bbe7eb8959251b89a042b40273b91e60e5c8116..77ff3a9f3ef4671c7f61742f222470316fdaa923 100644 (file)
--- 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 c378413f102d79426abc7a0fe1f8d8a36222a5a6..e09ec489fd4cdd5fcea324a733d3fe73ab5057c7 100644 (file)
--- 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 f6a09f820c83cc40c20eb351210c4a2f6ea1abf3..d7c70b21decf2299582ae7130d135e7532d8c31e 100644 (file)
--- 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 2b716b14c47b894946b9dceaf7bffbf876fb0a7e..872316cadc0a1aa5fcd0c03a36a0fd0318bafc11 100644 (file)
--- 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 3fa498d688278eb971426e37878ccf459d81c983..12835c4c0288db443db865a9335c9a57e2604f80 100644 (file)
--- 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 6bfe9089db84e9e396093462f70f6663fb2f8206..ff28cf1a9084a3ccfe3c9f4b1a12d8dc6d9b0e29 100644 (file)
--- 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 70f63cf2d9b9eafe648b7473e20a1d9c1dd816a8..e65f47617bdcd7b2964cc0088bdd2349be5e82e7 100644 (file)
--- 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 ae0cfc723745d397d24e0d0ec8856335b459b1d0..5d0e50000325d675898e29638170ac710e7db73b 100755 (executable)
--- 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 81863dd6fe69692f4584a733e4c30fa52eb9fda5..a2b1198465827667ed6f1fce97b09d8d6b894210 100644 (file)
--- 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 b9ffa94fa24b56fa2074f8b043dba4c075df71d8..77ff066d09cdbcd50112a9b6c47ced532e185580 100644 (file)
--- 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 db77ab198de61b95312be98b2bb5d70f039968e2..3f272ce4b6c21739ee5a06f1aac9763b3bc2f972 100644 (file)
--- 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 cace2fd37b766d18c84c4cf287836ed30ee6297a..daa69189792bcea1419b71f71ef5e33a338ad972 100644 (file)
--- 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 fd77f1bc2483f3f2c659bdac741058de7f70e562..b3c35575af4c96e88f6439066127705222b192d3 100644 (file)
--- 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 2659434438b26f6bb747d8dc7fad8823bfc70b24..a8b1a96a93cceed49379d900d99f0ce382e57b3d 100644 (file)
--- 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 04fe2fa05b63d1a96acdbef40e3a4a150fda0622..143a106115021d7f5d313110a3f19b3c4311d3b7 100644 (file)
--- 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 4ebb7380582eede71e3022105dd01b45d13753a8..b91a8b567956e7f762f9c1c140a2468ebc268054 100644 (file)
--- 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 0aafe6d9942ddf594fcb7434b0d45d055f5eee34..3f085b72245d118ae54b7a142f22ee228c48ca57 100644 (file)
--- 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 0121dda31dc3317c3aab1b81f6aa36a2bf97617e..86057bf693cda2d49cd8ce44fd41407ac357045a 100644 (file)
--- 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 412260441fbe07a3b5e0f27958383ec22ac76f62..96029a8789f12c8a405030e47748e46abc4bc3ce 100644 (file)
--- 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 dcc42bc92daf379413b40a682284a88b12e773c2..ebbb17155e4a9de0f323373a08f53ba5f7e6a838 100644 (file)
--- 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 fe5ee1d6175d6e4c6956f34add9718df28a6f32a..78b9fbb4ab06275fa26ecc6ac4d26ef678a645bf 100644 (file)
--- 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 815147e1ae6ce01b2dee021780dd738abb21b2bc..0ca3f522d622aa7d6b2af6a97f253fa3eca869b5 100644 (file)
--- 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 fb1c4e03d86342720e1358abb52b01f190086897..e46857cb8a16103be0c939bd5eac77af5e8047e1 100644 (file)
--- 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 8aadc75a54cc50c9de8737ad526ac8d6bf702f72..8207996dcdc9680c2a8fd7f3fa9028ab6adbd5ca 100644 (file)
--- 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 d150dbe9a9ad54c765d875f8f242b7ee51c904e2..af941c629cd9f4da31fb4d659df6229124900c1c 100644 (file)
--- 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 f88ca72daabe1c78efff010444add64f2021bbc8..2db75215c197881d8d6a9b3044b4dc708139e63a 100644 (file)
--- 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 3431eafa7e9cd57bc735ca4ff1450542b9a03a4a..d286a7e00b879b9666881cf0cab0f54e9cb9424d 100644 (file)
--- 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 db0b7db667019e1fdd553ed59b556fd6ca7a02e2..c2309352a09d0f7a43f84a24878143e102e8eeac 100644 (file)
--- 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 c00af87bf20f934924e22573d25b860ae0f1da27..22502a6e6b9094cadf11144c460a2ed095086ffd 100644 (file)
--- 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 106e4f10b51245e81745eeee95ff7c2995ed6c8b..5aecde103a5c23c963530470a37f7a739a184987 100644 (file)
--- 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 c704cacbd28197c44f3b55ee35f2e0e5e0650aa3..ff91dd83c3360cb2f4acdb699c4965a713eae1bb 100644 (file)
--- 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 68cdea051ea5747fb58862ee9e8a8f8c05c957a8..9cb27af412af2ab59ecdc50510ad3a76e1c43101 100644 (file)
--- 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 c83cfe3a93711d1e76877ed1805df2f6bf09d3e0..6ddaed9fe8f2bf11de018acda8739a6d63cd0bec 100644 (file)
--- 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 0efef2bbf0a8d2272f2f5c6866b22a539a54e525..d2a7d411ec010d8bc511715a481fc7de5756f544 100644 (file)
--- 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 4c5b17d05c73162a895a032dd851ce280e62d2ab..73ca0e53addc44fc1b0445c08c41b3e678c5f5e6 100644 (file)
--- 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 7d3174310767231c4c29493cfe1b1446f5670fbd..9024af3c223e59f910962dc4c34b8fd4012df9ca 100644 (file)
--- 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 dc31be929db5dd05ece91aff00c973659a69814f..dc30f468f4bb928ff0e478f42086f93e1a6b79d9 100644 (file)
--- 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 f0ad84af6b9e04a11e11c09f4cb487cc74738dcf..06b107401b99c56075a56e2be58647092907c06d 100644 (file)
--- 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 8c1219a7a1cacf8ca012effd8ea06afd8b3f11fd..459aed1db4fe6768e5ebae5b6a1bd2fff1d08f0d 100644 (file)
--- 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 b9bf43208a3d607ad7a853abe177ec700d2fbc1f..2476ebaf61df0f9cb7a0ba51ca21077866a01f27 100644 (file)
--- 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 c4e7b7d93e9ab20012aa08106636d6f449e7f166..38e8ec5162acecaacc906744226f134ea53402b5 100644 (file)
--- 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 7d34e5ca30f669f4160781b7ef36be2e94268b54..3675be6f1c1f82cbbf0f08f395f7684c26120fa8 100644 (file)
--- 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 9a7467b32d69090ed28ed70a79a031c3dbe65242..8dcbb241361ed0ae6c20cb44ba429cf44488aa5e 100644 (file)
--- 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 e0bcb1a39d46835d09d87e547f89c6d7487cc5c9..4d7d872373188d60bc92f29edceafd7185504228 100644 (file)
--- 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 d92fe5f2a324ae0b2d541e4abe377cf4fe52fd26..a350d4a0b15e7e5bd195728cff6c3c2e62899ae5 100644 (file)
--- 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 4b5bd7ac2ec70dd9dee66f9062c019c61e35aec8..3fb368ebd9f69e566930359c2e600a8d63a9c7b8 100644 (file)
--- 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 b3ddd2dfa8155ce9f641eeb1959068b19ba67761..6828e19b63bbe41631eac71f4bd9153b7d4d1e77 100644 (file)
--- 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 e16e2c93fb7878027274716bdb26d77e89b51be2..939f66af380483c79daca01ceddfa84c49774689 100644 (file)
--- 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 02e647fca9ab1c87bad5d72ebdbf89eda68a9086..c7945d21b612fffe851c19a6b7b9b755c2cae14c 100644 (file)
--- 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 2085a67c82a2f529dcc3175cdb1d79b758a99aa1..1bea8f032621d9fb74014eca96d475b84ff07b49 100644 (file)
--- 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 bcb138f7ad2ea5f07a631569336654e4796ffea4..72f162c51344c5d4ce0a2413ad16f89ce2b4c978 100644 (file)
--- 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 68c50bfbead64683f7119c55d5f3f7608ab72300..6cc60e549da97003f66c2d933077be319c6fa028 100644 (file)
--- 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 a6091fc6c3883cb041464e2bf378b882ec1e10a1..4ec3cdbb9743c3334c808e15287c9ddc762378b4 100644 (file)
--- 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 6044afdae6d64c022ed2f7a1795abab4d472032e..3a862a2beeb895655166e758c6ab4d8a57f30257 100644 (file)
--- 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 0b1659725bd0d359d5dc0fd7fa7a1c2611d7f8f7..a5568b048307715c98cd39d1d5a8d444676f83b1 100644 (file)
--- 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 c7bff962b9115d5f33e1a7e48818c4ebd3a1d750..b126e4a1669bd32829ed9e09fbea666a5c0fa7f5 100644 (file)
--- 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 9ab199a30e7a8fc3decb3e2378fa7344fa2c053d..317ecabd90de7705fc2cf6c684551a9ad33f79fa 100644 (file)
--- 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 17c665227a8d9a5158b6cce59ada86e7d435b8ca..96421c36b8909bc498210dffb4d87078598ae761 100644 (file)
--- 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 6e69f8aaaeb6eab4a0c3f68654fd2706c46a4c2b..681a5e77cb47fc74fb6798b040c006e5bf1bcc6a 100644 (file)
--- 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 fad96c60589c56f38cafb41b663635f9ad5d318c..d5a77d684a7d08b6d2057e05bb17a1ac7cca3d6f 100644 (file)
--- 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 b3c6055ed2301288f273767a6b41e714707c7ada..b340f04d8873c5082711a811975cd155b73e1d26 100644 (file)
--- 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 96ea704a3e280c5997668008d12fc769bde5ffab..6a1dee9fe784cda31c5417e092932c7f7d60d3de 100644 (file)
--- 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 f3b7c9abe7115d113345243201de4efb4eaad537..f5f7aca9d90f912ed42dbb21b1a2477718810a58 100644 (file)
--- 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 cf07055cfa307d673db7fe46d524b512b480be61..67f36e4fdc94816f61947e8e0d2959546a778501 100644 (file)
--- 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 94889d4a963b4e531cc0b522e4164f2574bbd602..90ac5490c84d2531fd8c97b78f2fe59f72f99128 100644 (file)
--- 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 c31082bcfdc844bfa4992503e01b1e0a48111298..95b6346c3edfa9188d0889b0c091279793c55ce9 100644 (file)
--- 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 269ebdefb53e2ce87bcc01e03234855c0c843817..5e5e145011040dc7f974012b20e4db67a378c133 100644 (file)
--- 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 e7694f95b564d07add36fce1243ec866351012e8..43b5dfb129492c26d93b5db526cfac4fc08dea0c 100644 (file)
--- 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 bd970de5f92a08720ca11285e187f39166bd0e62..d65f6da4503b00e4ef966f7e960f5606cf183a05 100644 (file)
--- 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 e71c4d7f0bccdc76c70abf05f4e3aa06115ac5d6..7d96988d43bd183cf2e7099ce17fb14c7378cbc9 100644 (file)
--- 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 551adb77dfc84eee21941cee303192a4815b5602..ce627472c473a3d4b7fef12006e9901b3e384655 100644 (file)
--- 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 461c0607ac9cae6d1c0083cbe093182a2a25bb24..bd2a633f298eb6ee31c23f954b71d93b87b87adc 100644 (file)
--- 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 f3749e73972d5e9f8395a8786396ceff8dcbde9d..5a776abce8d591cc9a2f794dcf0de75d99822f63 100644 (file)
--- 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 a5003d29b1f3a262c24ce431b711412ed515b3a9..bae16cdb2e90cae4c7b3296ddba2b69c916b85a5 100644 (file)
--- 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 c679771f2ec107e6797e16410d6b230893290188..7666577230fc66589f73f31cdee8ade5557d0324 100644 (file)
--- 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 729299b66572f3bc4d35442d656fd1a37f3b640b..33eb3cb1a955c0d35115bc107afe2cae88b4fdca 100644 (file)
--- 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 f6b03e13d2ee3233c457dddb586fe6bbe7758c8f..5ef02b1c1d77598adfbd42782dd0fbb8ed0ec4fc 100644 (file)
--- 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 3f8aaa4ece588a023c81770e8733fb39fc3c529c..ff027ddc22963a2b2fac556f0ecc0e7818b6074f 100644 (file)
--- 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 81b256e314ad344006f1a306d6fd7aca1a87f6e5..c7ad1a3660c7b57bf8e8ef8a01a314c2f3e1142b 100644 (file)
--- 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 8b7c7ac38332e608150d20a79a3e9013389efec2..7e8660d37e4b15c75da4a54b68ddcadd1cda2ddc 100644 (file)
--- 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 68c0ce0bc49504667d90f2c9623be0aac6f7fa86..4ea187a4b127da99a3c5a913407de92c313c041b 100644 (file)
--- 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 c96bf16768a43d9296ae94ef0252f18ae32dc9cf..e5a24495577300b9f1170004af929feb9ab681e1 100644 (file)
--- 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 4d731443227be92114635001351677821063f129..1c7adb5f5b80327b6c6bf40372cabc5090d8633c 100644 (file)
--- 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 a1a30dfb71c655ce8bd4c4537d4313c030a072d7..1b42c09ab1e3bcfcb5fe3874c0d960f966145e2d 100644 (file)
--- 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 198bae77ab6bd67832c46040380660a26d541ade..c59ef29e6c031356d0ea0af2c356282890adaac6 100644 (file)
--- 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 bd4d99eb6a3a3e218a1222f9f8da88c29ad144fa..2146408a1e285804126cb2301df57ee870b5ea80 100644 (file)
--- 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 0c1a07979df54309c25f12ef9ab4776b8630555d..e8ed928bcd3773d528219357be629480283a5233 100644 (file)
--- 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 56f4dfcba4092674b8d9dceda8fa0eaf4c9c831b..056ff9877d39e83624a514ee3ae1cb24b0554426 100644 (file)
--- 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 04c71327b1796f032f681acc4ff168167ab1c6a2..83e8327a517505254fa8520dccc7fee4ee180e3d 100644 (file)
--- 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 b952f8fc8ad24e662faf1bc00ce30cbf92805b00..b6a582fffba8700287add0f3f9bf01f3c868ced2 100644 (file)
--- 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 20b77c6cc05b6d83d2e1ff83c99cc49dc63ecfc9..c40ca1f382464f943ebd7af7476d8a0edd5d34de 100644 (file)
--- 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 6e9bfd023d0ec04505701a4edb3c5c4278f572b2..ba1fa196fd6874b23e27fb162d4afd8032954af6 100644 (file)
--- 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 26b1139928fe375a09165faa4e9125e348be6eca..8ec7d40f5e58104b6260a1066cb8e18b0359a315 100644 (file)
--- 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 5a66dc9a95484dfdbfc1f1aa1435ab57ca2b16e9..b36e93ecd66493ef724b663bb051ac416a6b7458 100644 (file)
--- 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 997894b4184e2b97c7cf812c634af381fd7b7552..83acc15ff7c12e529dfc2a2437658c9891be96f2 100644 (file)
--- 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 3c6f1f68c96a1e3e1e4474f14c6721b1f73db61b..8524e47aec3b303a95b5e0fae2b3e9b32c1ac8df 100644 (file)
--- 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 af2a1c57d1243e0fc1efb935795f6dd9b8593977..d425a7c4c04da9b29ec34ac4213b0056a6f1be94 100644 (file)
--- 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 12b4b6d7b660941f13da916547bba342af154d2e..6b3d4b2e46086c82b33354f0dbbb7bcb9d09b5dd 100644 (file)
--- 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 cb443e3a19ba7785ba090debf3d5da37737346e0..feb85d29997da3bbf1c5feb4495a0371dffcf13b 100644 (file)
--- 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 6e7088e19c0288a65a8c2d85f87ce7ab1bf29485..5c31270fcd3dca00032b250c9848043581b00fe4 100644 (file)
--- 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 5a35acaf4423d88957ce5997b31a4307ff7bf100..639042128774d1888e4c2e70adf26224dc1789f1 100644 (file)
--- 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 9bdbabca860f9d7f18752fec63d3d67dfdfebc5d..bf05388127ceba120de38ef024f1ed72fbbe27da 100644 (file)
--- 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 ddff7c7a733d74aeb4ce482e60116fbf61b2e229..c3963499bcef1fec02933893a8ba142b32a18825 100644 (file)
--- 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 d2039bab4d4deed5b6f30ebee027bf62ea7a52b2..5b6bb81fe342c1905f8e53c768ce90215273ad9b 100644 (file)
--- 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 6a72b72ebddbd95196e7224b94edcfae8a82032b..4f4c75527606d5ad0d7c34d1127cdc8a41aa5e0c 100644 (file)
--- 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 f33af4457b9bf103627caf0546eec1ab90e4825a..9affe25d47acf8b129af03aad933ef2bae2bbfa7 100644 (file)
--- 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 dd2033a98fde9210511e82b76cf12d6d46c3312f..d8d86c427937955afc6009b09105592038f7a83d 100644 (file)
--- 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 9e6d10ea879bfb21d50642ff14c6a3029a051f04..83fb0985a91e1a9eaf00b21c9df9c149ee9540de 100644 (file)
--- 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 cd4f52215b4065c31f4fc2ce9aec322dd822413d..1948528d2450a36278ab128095ca13f4d407de48 100644 (file)
--- 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