Finish support for 64-bit types in stdlib. Fixes issue #14.

Add much more suppport for doubles and in64 types in the standard library, basically supporting everything for them that are supported for floats and int32s.  (The notable exceptions being the approximate rcp() and rsqrt() functions, which don't really have sensible analogs for doubles (or at least not built-in instructions).)

tests/double-abs-1.ispc

@@ -0,0 +1,11 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a = aFOO[programIndex]; 
+    RET[programIndex] = abs(-a);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1 + programIndex;
+}

tests/double-abs.ispc

@@ -0,0 +1,11 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a = aFOO[programIndex]; 
+    RET[programIndex] = abs(a);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1 + programIndex;
+}

tests/double-max-1.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a = aFOO[programIndex];
+    double b = -2. * a;
+    RET[programIndex] = max(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1 * (1 + programIndex);
+}

tests/double-max.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a = aFOO[programIndex];
+    double b = 2. * a;
+    RET[programIndex] = max(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2 * (1 + programIndex);
+}

tests/double-min-1.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a = aFOO[programIndex];
+    double b = -2. * a;
+    RET[programIndex] = min(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = -2 * (1 + programIndex);
+}

tests/double-min.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a = aFOO[programIndex];
+    double b = 2. * a;
+    RET[programIndex] = min(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1 + programIndex;
+}

tests/double-sqrt.ispc

@@ -0,0 +1,16 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a = aFOO[programIndex];
+    if (programIndex & 1) {
+        a *= a;
+        RET[programIndex] = sqrt(a);
+    }
+    else
+        RET[programIndex] = a;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1 + programIndex;
+}

tests/extract-1.ispc

@@ -0,0 +1,11 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a = programIndex;
+    RET[programIndex] = extract(a, 3); 
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 3;
+}

tests/frexp-double-1.ispc

@@ -0,0 +1,16 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a = (1<<programIndex) * 1.5;
+    if (programIndex & 1)
+        a = -a;
+    int exponent;
+    frexp(a, exponent);
+    RET[programIndex] = exponent;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1+programIndex;
+}

tests/frexp-double.ispc

@@ -0,0 +1,17 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a = (1<<programIndex) * 1.5;
+    if (programIndex & 1)
+        a = -a;
+    int exponent;
+    RET[programIndex] = frexp(a, exponent);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 0.75;
+    if (programIndex & 1)
+        RET[programIndex] = -RET[programIndex];
+}

tests/frexp-float-1.ispc

@@ -0,0 +1,16 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = (1<<programIndex) * 1.5;
+    if (programIndex & 1)
+        a = -a;
+    int exponent;
+    frexp(a, exponent);
+    RET[programIndex] = exponent;
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1+programIndex;
+}

tests/frexp-float.ispc

@@ -0,0 +1,17 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = (1<<programIndex) * 1.5;
+    if (programIndex & 1)
+        a = -a;
+    int exponent;
+    RET[programIndex] = frexp(a, exponent);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 0.75;
+    if (programIndex & 1)
+        RET[programIndex] = -RET[programIndex];
+}

tests/insert-1.ispc

@@ -0,0 +1,13 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    int64 a;
+    for (uniform int i = 0; i < programCount; ++i)
+        a = insert(a, i, (int64)i);
+    RET[programIndex] = a; 
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = programIndex;
+}

tests/insert-2.ispc

@@ -0,0 +1,13 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a;
+    for (uniform int i = 0; i < programCount; ++i)
+        a = insert(a, i, (double)i+10);
+    RET[programIndex] = a; 
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = programIndex+10;
+}

tests/int64-max-1.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    int64 a = aFOO[programIndex];
+    int64 b = -2. * a;
+    RET[programIndex] = max(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1 * (1 + programIndex);
+}

tests/int64-max.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    int64 a = aFOO[programIndex];
+    int64 b = 2. * a;
+    RET[programIndex] = max(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2 * (1 + programIndex);
+}

tests/int64-min-1.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    int64 a = aFOO[programIndex];
+    int64 b = -2. * a;
+    RET[programIndex] = min(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = -2 * (1 + programIndex);
+}

tests/int64-min.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    int64 a = aFOO[programIndex];
+    int64 b = 2. * a;
+    RET[programIndex] = min(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1 + programIndex;
+}

tests/ldexp-double.ispc

@@ -0,0 +1,16 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    double a = 1 << (programIndex);
+    if (programIndex & 1)
+        a = -a;
+    RET[programIndex] = ldexp(a, 2);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = (1 << (programIndex + 2));
+    if (programIndex & 1)
+        RET[programIndex] = -RET[programIndex];
+}

tests/ldexp-float.ispc

@@ -0,0 +1,16 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    float a = 1 << (programIndex);
+    if (programIndex & 1)
+        a = -a;
+    RET[programIndex] = ldexp(a, 2);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = (1 << (programIndex + 2));
+    if (programIndex & 1)
+        RET[programIndex] = -RET[programIndex];
+}

tests/popcnt-4.ispc

@@ -0,0 +1,20 @@
+
+export uniform int width() { return programCount; }
+
+
+export void f_f(uniform float RET[4], uniform float aFOO[]) {
+    int64 a = aFOO[programIndex];
+    a = (a < 3) ? 1 : 0;
+    if ((programIndex & 1) != 0)
+        a |= ((int64)1 << 36);
+    RET[programIndex] = popcnt(a);
+}
+
+export void result(uniform float RET[]) { 
+    RET[programIndex] = 0;
+    if (programIndex & 1)
+        ++RET[programIndex];
+    if (programIndex < 2)
+        ++RET[programIndex];
+}
+

tests/reduce-add-double-1.ispc

@@ -0,0 +1,22 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    double v = aFOO[programIndex];
+    uniform float m;
+    int iv = (int)v;
+    if (iv & 1)
+        m = reduce_add((double)iv);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { 
+    uniform int x = -1234;
+    if (programCount == 4) x = 4;
+    else if (programCount == 8) x = 16;
+    else if (programCount == 16) x = 64;
+    RET[programIndex] = x;
+}
+

tests/reduce-add-double-2.ispc

@@ -0,0 +1,21 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform float m;
+    int iv = (int)v;
+    m = reduce_add((double)iv);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { 
+    uniform int x = -1234;
+    if (programCount == 4) x = 10;
+    else if (programCount == 8) x = 36;
+    else if (programCount == 16) x = 124;
+    RET[programIndex] = x;
+}
+

tests/reduce-add-double.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    double v = aFOO[programIndex];
+    uniform float m;
+    if (v < 3)
+        m = reduce_add(-v);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = -3; }

tests/reduce-add-int64-1.ispc

@@ -0,0 +1,22 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform float m;
+    int64 iv = (int64)v;
+    if (iv & 1)
+        m = reduce_add(iv);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { 
+    uniform int x = -1234;
+    if (programCount == 4) x = 4;
+    else if (programCount == 8) x = 16;
+    else if (programCount == 16) x = 64;
+    RET[programIndex] = x;
+}
+

tests/reduce-add-int64.ispc

@@ -0,0 +1,21 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform float m;
+    int64 iv = (int)v;
+    m = reduce_add(iv);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { 
+    uniform int x = -1234;
+    if (programCount == 4) x = 10;
+    else if (programCount == 8) x = 36;
+    else if (programCount == 16) x = 136;
+    RET[programIndex] = x;
+}
+

tests/reduce-add-uint64-1.ispc

@@ -0,0 +1,21 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform float m;
+    unsigned int64 iv = (unsigned int)v;
+    if (iv & 1)
+        m = reduce_add(iv);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { 
+    uniform int x = -1234;
+    if (programCount == 4) x = 4;
+    else if (programCount == 8) x = 16;
+    else if (programCount == 16) x = 64;
+    RET[programIndex] = x;
+}

tests/reduce-add-uint64.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex & 0x3];
+    uniform float m;
+    unsigned int64 iv = (unsigned int)v;
+    m = reduce_add(iv);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 10 * programCount/4; }

tests/reduce-max-double.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    double v = aFOO[programIndex];
+    uniform float m;
+    if (v >= 3)
+        m = reduce_max(-v);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = -3; }

tests/reduce-max-int64.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform float m;
+    if (v >= 3)
+        m = reduce_max(-(int64)v);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = -3; }

tests/reduce-max-uint64.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform float m;
+    if (v < 3)
+        m = reduce_max((unsigned int64)v);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 2; }

tests/reduce-min-double.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    double v = aFOO[programIndex];
+    uniform float m;
+    if (v > 0 && v < 3)
+        m = reduce_min(-v);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = -2; }

tests/reduce-min-int.ispc

@@ -7,7 +7,7 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float v = aFOO[programIndex];
     uniform float m;
     if (v >= 0 && v < 2)
-        m = reduce_min(-v);
+        m = reduce_min(-(int)v);
     RET[programIndex] = m;
 }
 

tests/reduce-min-int64.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform float m;
+    if (v >= 0 && v < 2)
+        m = reduce_min(-(int64)v);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = -1; }

tests/reduce-min-uint64.ispc

@@ -0,0 +1,14 @@
+
+export uniform int width() { return programCount; }
+
+
+
+export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
+    float v = aFOO[programIndex];
+    uniform float m;
+    if (v >= 3)
+        m = reduce_min((unsigned int64)v);
+    RET[programIndex] = m;
+}
+
+export void result(uniform float RET[]) { RET[programIndex] = 3; }

tests/uint64-max-1.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    unsigned int64 a = aFOO[programIndex];
+    unsigned int64 b = 2;
+    RET[programIndex] = max(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = max(2, 1 + programIndex);
+}

tests/uint64-max.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    unsigned int64 a = aFOO[programIndex];
+    unsigned int64 b = 2. * a;
+    RET[programIndex] = max(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 2 * (1 + programIndex);
+}

tests/uint64-min-1.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    unsigned int64 a = aFOO[programIndex];
+    unsigned int64 b = 2 * a;
+    RET[programIndex] = min(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = (1 + programIndex);
+}

tests/uint64-min.ispc

@@ -0,0 +1,12 @@
+
+export uniform int width() { return programCount; }
+
+export void f_f(uniform float RET[], uniform float aFOO[]) {
+    unsigned int64 a = aFOO[programIndex];
+    unsigned int64 b = 2. * a;
+    RET[programIndex] = min(a,b);
+}
+
+export void result(uniform float RET[]) {
+    RET[programIndex] = 1 + programIndex;
+}