< prev index next >

test/jdk/jdk/incubator/vector/Float128VectorTests.java

Print this page
rev 55894 : 8222897: [vector] Renaming of shift, rotate operations. Few other api changes.
Summary: Renaming of shift, rotate operations. Few other api changes.
Reviewed-by: jrose, briangoetz

@@ -728,10 +728,22 @@
 
 
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
     static float max(float a, float b) {
         return (float)(Math.max(a, b));
     }
 
     @Test(dataProvider = "floatBinaryOpProvider")

@@ -774,20 +786,20 @@
 
 
 
 
 
-    static float addAll(float[] a, int idx) {
+    static float addLanes(float[] a, int idx) {
         float res = 0;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
             res += a[i];
         }
 
         return res;
     }
 
-    static float addAll(float[] a) {
+    static float addLanes(float[] a) {
         float res = 0;
         for (int i = 0; i < a.length; i += SPECIES.length()) {
             float tmp = 0;
             for (int j = 0; j < SPECIES.length(); j++) {
                 tmp += a[i + j];

@@ -796,42 +808,42 @@
         }
 
         return res;
     }
     @Test(dataProvider = "floatUnaryOpProvider")
-    static void addAllFloat128VectorTests(IntFunction<float[]> fa) {
+    static void addLanesFloat128VectorTests(IntFunction<float[]> fa) {
         float[] a = fa.apply(SPECIES.length());
         float[] r = fr.apply(SPECIES.length());
         float ra = 0;
 
         for (int ic = 0; ic < INVOC_COUNT; ic++) {
             for (int i = 0; i < a.length; i += SPECIES.length()) {
                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.addAll();
+                r[i] = av.addLanes();
             }
         }
 
         for (int ic = 0; ic < INVOC_COUNT; ic++) {
             ra = 0;
             for (int i = 0; i < a.length; i += SPECIES.length()) {
                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra += av.addAll();
+                ra += av.addLanes();
             }
         }
 
-        assertReductionArraysEquals(a, r, ra, Float128VectorTests::addAll, Float128VectorTests::addAll);
+        assertReductionArraysEquals(a, r, ra, Float128VectorTests::addLanes, Float128VectorTests::addLanes);
     }
-    static float mulAll(float[] a, int idx) {
+    static float mulLanes(float[] a, int idx) {
         float res = 1;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
             res *= a[i];
         }
 
         return res;
     }
 
-    static float mulAll(float[] a) {
+    static float mulLanes(float[] a) {
         float res = 1;
         for (int i = 0; i < a.length; i += SPECIES.length()) {
             float tmp = 1;
             for (int j = 0; j < SPECIES.length(); j++) {
                 tmp *= a[i + j];

@@ -840,111 +852,111 @@
         }
 
         return res;
     }
     @Test(dataProvider = "floatUnaryOpProvider")
-    static void mulAllFloat128VectorTests(IntFunction<float[]> fa) {
+    static void mulLanesFloat128VectorTests(IntFunction<float[]> fa) {
         float[] a = fa.apply(SPECIES.length());
         float[] r = fr.apply(SPECIES.length());
         float ra = 1;
 
         for (int ic = 0; ic < INVOC_COUNT; ic++) {
             for (int i = 0; i < a.length; i += SPECIES.length()) {
                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.mulAll();
+                r[i] = av.mulLanes();
             }
         }
 
         for (int ic = 0; ic < INVOC_COUNT; ic++) {
             ra = 1;
             for (int i = 0; i < a.length; i += SPECIES.length()) {
                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra *= av.mulAll();
+                ra *= av.mulLanes();
             }
         }
 
-        assertReductionArraysEquals(a, r, ra, Float128VectorTests::mulAll, Float128VectorTests::mulAll);
+        assertReductionArraysEquals(a, r, ra, Float128VectorTests::mulLanes, Float128VectorTests::mulLanes);
     }
-    static float minAll(float[] a, int idx) {
+    static float minLanes(float[] a, int idx) {
         float res = Float.POSITIVE_INFINITY;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
             res = (float)Math.min(res, a[i]);
         }
 
         return res;
     }
 
-    static float minAll(float[] a) {
+    static float minLanes(float[] a) {
         float res = Float.POSITIVE_INFINITY;
         for (int i = 0; i < a.length; i++) {
             res = (float)Math.min(res, a[i]);
         }
 
         return res;
     }
     @Test(dataProvider = "floatUnaryOpProvider")
-    static void minAllFloat128VectorTests(IntFunction<float[]> fa) {
+    static void minLanesFloat128VectorTests(IntFunction<float[]> fa) {
         float[] a = fa.apply(SPECIES.length());
         float[] r = fr.apply(SPECIES.length());
         float ra = Float.POSITIVE_INFINITY;
 
         for (int ic = 0; ic < INVOC_COUNT; ic++) {
             for (int i = 0; i < a.length; i += SPECIES.length()) {
                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.minAll();
+                r[i] = av.minLanes();
             }
         }
 
         for (int ic = 0; ic < INVOC_COUNT; ic++) {
             ra = Float.POSITIVE_INFINITY;
             for (int i = 0; i < a.length; i += SPECIES.length()) {
                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra = (float)Math.min(ra, av.minAll());
+                ra = (float)Math.min(ra, av.minLanes());
             }
         }
 
-        assertReductionArraysEquals(a, r, ra, Float128VectorTests::minAll, Float128VectorTests::minAll);
+        assertReductionArraysEquals(a, r, ra, Float128VectorTests::minLanes, Float128VectorTests::minLanes);
     }
-    static float maxAll(float[] a, int idx) {
+    static float maxLanes(float[] a, int idx) {
         float res = Float.NEGATIVE_INFINITY;
         for (int i = idx; i < (idx + SPECIES.length()); i++) {
             res = (float)Math.max(res, a[i]);
         }
 
         return res;
     }
 
-    static float maxAll(float[] a) {
+    static float maxLanes(float[] a) {
         float res = Float.NEGATIVE_INFINITY;
         for (int i = 0; i < a.length; i++) {
             res = (float)Math.max(res, a[i]);
         }
 
         return res;
     }
     @Test(dataProvider = "floatUnaryOpProvider")
-    static void maxAllFloat128VectorTests(IntFunction<float[]> fa) {
+    static void maxLanesFloat128VectorTests(IntFunction<float[]> fa) {
         float[] a = fa.apply(SPECIES.length());
         float[] r = fr.apply(SPECIES.length());
         float ra = Float.NEGATIVE_INFINITY;
 
         for (int ic = 0; ic < INVOC_COUNT; ic++) {
             for (int i = 0; i < a.length; i += SPECIES.length()) {
                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                r[i] = av.maxAll();
+                r[i] = av.maxLanes();
             }
         }
 
         for (int ic = 0; ic < INVOC_COUNT; ic++) {
             ra = Float.NEGATIVE_INFINITY;
             for (int i = 0; i < a.length; i += SPECIES.length()) {
                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
-                ra = (float)Math.max(ra, av.maxAll());
+                ra = (float)Math.max(ra, av.maxLanes());
             }
         }
 
-        assertReductionArraysEquals(a, r, ra, Float128VectorTests::maxAll, Float128VectorTests::maxAll);
+        assertReductionArraysEquals(a, r, ra, Float128VectorTests::maxLanes, Float128VectorTests::maxLanes);
     }
 
 
 
 
< prev index next >