added double precision tests

tests/transcendentals-5-0.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1e-16) || abs((x-ref)/ref) < 1e-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((-3.141592741012573d0),(0.000000000000000d0),(3.141592741012573d0),(6.283185482025146d0));
+    double ref = double4((8.742277955963554d-08),(0.000000000000000d0),(-8.742277955963554d-08),(1.7484555911927038d-07));
+    RET[programIndex] = ok(sin(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-5-1.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1e-16) || abs((x-ref)/ref) < 1e-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((1.000000000000000d0),(-1.000000000000000d0),(-1.5707963705062866d0),(1.5707963705062866d0));
+    double ref = double4((0.8414709848078965d0),(-0.8414709848078965d0),(-1.000000000000000d0),(1.000000000000000d0));
+    RET[programIndex] = ok(sin(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-5-2.ispc

@@ -0,0 +1,28 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { 
+    bool r = (abs(x - ref) < 1e-14) || abs((x-ref)/ref) < 1e-14;
+    if (any(r == false))
+        print("mismatch got %, expected %\n", x, ref);
+    return r;
+}
+
+export void f_v(uniform float RET[]) {
+    double v = double4((-9.424777984619141d0),(4.000000000000000d0),(10.000000000000000d0),(-10.000000000000000d0));
+    double ref = double4((2.3849760909612067d-08),(-0.7568024953079282d0),(-0.5440211108893699d0),(0.5440211108893699d0));
+    RET[programIndex] = ok(sin(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-5-3.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((14.300000190734863d0),(-6.699999809265137d0),(-21.200000762939453d0),(9.000000000000000d0));
+    double ref = double4((0.9867719333537206d0),(-0.40484974621184605d0),(-0.7111606865372466d0),(0.4121184852417566d0));
+    RET[programIndex] = ok(sin(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-6-0.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((-3.141592653589793d0),(0.000000000000000d0),(3.141592653589793d0),(6.283185307179586d0));
+    double ref = double4((-1.000000000000000d0),(1.000000000000000d0),(-1.000000000000000d0),(1.000000000000000d0));
+    RET[programIndex] = ok(cos(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-6-1.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((1.000000000000000d0),(-1.000000000000000d0),(-1.570796370506287d0),(1.570796370506287d0));
+    double ref = double4((0.5403023058681398d0),(0.5403023058681398d0),(-4.371139044595162d-08),(-4.371139044595162d-08));
+    RET[programIndex] = ok(cos(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-6-2.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((-9.42477796076938d0),(4.000000000000000d0),(10.000000000000000d0),(-10.000000000000000d0));
+    double ref = double4((-1.000000000000000d0),(-0.6536436208636119d0),(-0.8390715290764524d0),(-0.8390715290764524d0));
+    RET[programIndex] = ok(cos(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-6-3.ispc

@@ -0,0 +1,29 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { 
+    bool r = (abs(x - ref) < 1d-15) || abs((x-ref)/ref) < 1d-15;
+    if (any(r == false))
+        print("mismatch got %, expected %\n", x, ref);
+    return r;
+}
+
+
+export void f_v(uniform float RET[]) {
+    double v = double4((14.300000190734863d0),(-6.699999809265137d0),(-21.200000762939453d0),(9.000000000000000d0));
+    double ref = double4((-0.1621146247115303d0),(0.9143832254542971d0),(-0.7030295000381365d0),(-0.9111302618846769d0));
+    RET[programIndex] = ok(cos(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-7-0.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((-3.141592741012573d0),(0.000000000000000d0),(3.141592741012573d0),(6.283185482025146d0));
+    double ref = double4((-8.742277955963587d-08),(0.000000000000000d0),(8.742277955963587d-08),(1.7484555911927306d-07));
+    RET[programIndex] = ok(tan(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-7-1.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((1.000000000000000d0),(-1.000000000000000d0),(0),(0));
+    double ref = double4((1.557407724654902d0),(-1.557407724654902d0),(0),(0));
+    RET[programIndex] = ok(tan(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-7-2.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((-9.424777984619141d0),(4.000000000000000d0),(10.000000000000000d0),(-10.000000000000000d0));
+    double ref = double4((-2.3849760909612074d-08),(1.1578212823495775d0),(0.6483608274590867d0),(-0.6483608274590867d0));
+    RET[programIndex] = ok(tan(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-7-3.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((14.300000190734863d0),(-6.699999809265137d0),(-21.200000762939453d0),(9.000000000000000d0));
+    double ref = double4((-6.086877942749462d0),(-0.442757188607329d0),(1.0115659250410816d0),(-0.4523156594418099d0));
+    RET[programIndex] = ok(tan(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-8-0.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((-3.141592741012573d0),(0.000000000000000d0),(3.141592741012573d0),(6.283185482025146d0));
+    double ref = double4((0.04321391448589156d0),(1.000000000000000d0),(23.140694655803028d0),(535.4917491531108d0));
+    RET[programIndex] = ok(exp(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-8-1.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((1.000000000000000d0),(-1.000000000000000d0),(-1.570796370506287d0),(1.570796370506287d0));
+    double ref = double4((2.718281828459045d0),(0.36787944117144233d0),(0.2078795672640568d0),(4.810477591238011d0));
+    RET[programIndex] = ok(exp(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-8-2.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((-9.424777984619141d0),(4.000000000000000d0),(10.000000000000000d0),(-10.000000000000000d0));
+    double ref = double4((8.069951564564043d-05),(54.598150033144236d0),(22026.465794806718d0),(4.5399929762484854d-05));
+    RET[programIndex] = ok(exp(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-8-3.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((14.300000190734863d0),(-6.699999809265137d0),(-21.200000762939453d0),(9.000000000000000d0));
+    double ref = double4((1623346.2946371625d0),(0.001230912137451317d0),(6.208070673019769d-10),(8103.083927575384d0));
+    RET[programIndex] = ok(exp(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-9-0.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((3.141602741012573d),(0.000010000000000d),(3.141602741012573d),(6.283195482025146d));
+    double ref = double4((1.144733096770642d0),(-11.512925464970229d0),(1.144733096770642d0),(1.8378786857850002d0));
+    RET[programIndex] = ok(log(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-9-1.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((1.000010000000000d0),(1.000010000000000d0),(1.570806370506287d0),(1.570806370506287d0));
+    double ref = double4((9.999950000398841d-06),(9.999950000398841d-06),(0.4515890992942722d0),(0.4515890992942722d0));
+    RET[programIndex] = ok(log(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-9-2.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((9.424787984619140d0),(4.000010000000000d0),(10.000010000000000d0),(10.000010000000000d0));
+    double ref = double4((2.2433432380804366d0),(1.3862968611167654d0),(2.3025860929935456d0),(2.3025860929935456d0));
+    RET[programIndex] = ok(log(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[]) { RET[programIndex] = 1.; }

tests/transcendentals-9-3.ispc

@@ -0,0 +1,23 @@
+static double double4(uniform double a, uniform double b, uniform double c, 
+                    uniform double d) {
+    double ret = 0;
+    for (uniform int i = 0; i < programCount; i += 4) {
+        ret = insert(ret, i + 0, a);
+        ret = insert(ret, i + 1, b);
+        ret = insert(ret, i + 2, c);
+        ret = insert(ret, i + 3, d);
+    }
+    return ret;
+}
+
+export uniform int width() { return programCount; }
+
+
+bool ok(double x, double ref) { return (abs(x - ref) < 1d-16) || abs((x-ref)/ref) < 1d-15; }
+
+export void f_v(uniform float RET[]) {
+    double v = double4((14.300010190734863d0),(6.700009809265136d0),(21.200010762939453d0),(9.000010000000000d0));
+    double ref = double4((2.6602602499044092d0),(1.902108990465272d0),(3.0540016893636612d0),(2.197225688446713d0));
+    RET[programIndex] = ok(log(v), ref) ? 1. : 0.;
+}
+export void result(uniform float RET[4]) { RET[programIndex] = 1.; }