< prev index next >

test/jdk/jdk/incubator/vector/FloatMaxVectorTests.java

Print this page
@@ -63,11 +63,10 @@
          return VectorShape.S_Max_BIT;
      }
  
      private static final int Max = 256;  // juts so we can do N/Max
  
-     private static final float CONST_SHIFT = Float.SIZE / 2;
  
      static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / Max);
  
      interface FUnOp {
          float apply(float a);

@@ -264,10 +263,59 @@
              int idx = i + j;
              Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
          }
      }
  
+     static void assertcompressArraysEquals(float[] r, float[] a, boolean[] m, int vector_len) {
+         int i = 0, j = 0, k = 0;
+         try {
+             for (; i < a.length; i += vector_len) {
+                 k = 0;
+                 for (j = 0; j < vector_len; j++) {
+                     if (m[(i + j) % SPECIES.length()]) {
+                         Assert.assertEquals(r[i + k], a[i + j]);
+                         k++;
+                     }
+                 }
+                 for (; k < vector_len; k++) {
+                     Assert.assertEquals(r[i + k], (float)0);
+                 }
+             }
+         } catch (AssertionError e) {
+             int idx = i + k;
+             if (m[(i + j) % SPECIES.length()]) {
+                 Assert.assertEquals(r[idx], a[i + j], "at index #" + idx);
+             } else {
+                 Assert.assertEquals(r[idx], (float)0, "at index #" + idx);
+             }
+         }
+     }
+ 
+     static void assertexpandArraysEquals(float[] r, float[] a, boolean[] m, int vector_len) {
+         int i = 0, j = 0, k = 0;
+         try {
+             for (; i < a.length; i += vector_len) {
+                 k = 0;
+                 for (j = 0; j < vector_len; j++) {
+                     if (m[(i + j) % SPECIES.length()]) {
+                         Assert.assertEquals(r[i + j], a[i + k]);
+                         k++;
+                     } else {
+                         Assert.assertEquals(r[i + j], (float)0);
+                     }
+                 }
+             }
+         } catch (AssertionError e) {
+             int idx = i + j;
+             if (m[idx % SPECIES.length()]) {
+                 Assert.assertEquals(r[idx], a[i + k], "at index #" + idx);
+             } else {
+                 Assert.assertEquals(r[idx], (float)0, "at index #" + idx);
+             }
+         }
+     }
+ 
      static void assertSelectFromArraysEquals(float[] r, float[] a, float[] order, int vector_len) {
          int i = 0, j = 0;
          try {
              for (; i < a.length; i += vector_len) {
                  for (j = 0; j < vector_len; j++) {

@@ -1027,11 +1075,10 @@
          } catch (AssertionError e) {
              Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
          }
      }
  
- 
      static int bits(float e) {
          return  Float.floatToIntBits(e);
      }
  
      static final List<IntFunction<float[]>> FLOAT_GENERATORS = List.of(

@@ -1211,11 +1258,10 @@
                          return new Object[] {fa, fs, fm};
                  }))).
                  toArray(Object[][]::new);
      }
  
- 
      static final List<IntFunction<float[]>> FLOAT_COMPARE_GENERATORS = List.of(
              withToString("float[i]", (int s) -> {
                  return fill(s * BUFFER_REPS,
                              i -> (float)i);
              }),

@@ -1332,11 +1378,10 @@
      static final IntFunction<long[]> lfr = (vl) -> {
          int length = BUFFER_REPS * vl;
          return new long[length];
      };
  
- 
      static boolean eq(float a, float b) {
          return a == b;
      }
  
      static boolean neq(float a, float b) {

@@ -1357,11 +1402,10 @@
  
      static boolean ge(float a, float b) {
          return a >= b;
      }
  
- 
      static float firstNonZero(float a, float b) {
          return Float.compare(a, (float) 0) != 0 ? a : b;
      }
  
      @Test

@@ -1474,10 +1518,11 @@
              }
          }
  
          assertArraysEquals(r, a, b, FloatMaxVectorTests::ADD);
      }
+ 
      static float add(float a, float b) {
          return (float)(a + b);
      }
  
      @Test(dataProvider = "floatBinaryOpProvider")

@@ -1530,10 +1575,11 @@
              av.add(bv, vmask).intoArray(r, i);
          }
  
          assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::add);
      }
+ 
      static float SUB(float a, float b) {
          return (float)(a - b);
      }
  
      @Test(dataProvider = "floatBinaryOpProvider")

@@ -1550,10 +1596,11 @@
              }
          }
  
          assertArraysEquals(r, a, b, FloatMaxVectorTests::SUB);
      }
+ 
      static float sub(float a, float b) {
          return (float)(a - b);
      }
  
      @Test(dataProvider = "floatBinaryOpProvider")

@@ -1606,10 +1653,11 @@
              av.sub(bv, vmask).intoArray(r, i);
          }
  
          assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::sub);
      }
+ 
      static float MUL(float a, float b) {
          return (float)(a * b);
      }
  
      @Test(dataProvider = "floatBinaryOpProvider")

@@ -1626,10 +1674,11 @@
              }
          }
  
          assertArraysEquals(r, a, b, FloatMaxVectorTests::MUL);
      }
+ 
      static float mul(float a, float b) {
          return (float)(a * b);
      }
  
      @Test(dataProvider = "floatBinaryOpProvider")

@@ -1703,10 +1752,11 @@
              }
          }
  
          assertArraysEquals(r, a, b, FloatMaxVectorTests::DIV);
      }
+ 
      static float div(float a, float b) {
          return (float)(a / b);
      }
  
      @Test(dataProvider = "floatBinaryOpProvider")

@@ -1722,12 +1772,10 @@
          }
  
          assertArraysEquals(r, a, b, FloatMaxVectorTests::div);
      }
  
- 
- 
      @Test(dataProvider = "floatBinaryOpMaskProvider")
      static void DIVFloatMaxVectorTestsMasked(IntFunction<float[]> fa, IntFunction<float[]> fb,
                                            IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());

@@ -1762,12 +1810,10 @@
          }
  
          assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::div);
      }
  
- 
- 
      static float FIRST_NONZERO(float a, float b) {
          return (float)(Double.doubleToLongBits(a)!=0?a:b);
      }
  
      @Test(dataProvider = "floatBinaryOpProvider")

@@ -1805,18 +1851,10 @@
          }
  
          assertArraysEquals(r, a, b, mask, FloatMaxVectorTests::FIRST_NONZERO);
      }
  
- 
- 
- 
- 
- 
- 
- 
- 
      @Test(dataProvider = "floatBinaryOpProvider")
      static void addFloatMaxVectorTestsBroadcastSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());

@@ -1906,11 +1944,10 @@
          }
  
          assertBroadcastArraysEquals(r, a, b, mask, FloatMaxVectorTests::mul);
      }
  
- 
      @Test(dataProvider = "floatBinaryOpProvider")
      static void divFloatMaxVectorTestsBroadcastSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());

@@ -1921,12 +1958,10 @@
          }
  
          assertBroadcastArraysEquals(r, a, b, FloatMaxVectorTests::div);
      }
  
- 
- 
      @Test(dataProvider = "floatBinaryOpMaskProvider")
      static void divFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb,
                                            IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());

@@ -1940,19 +1975,10 @@
          }
  
          assertBroadcastArraysEquals(r, a, b, mask, FloatMaxVectorTests::div);
      }
  
- 
- 
- 
- 
- 
- 
- 
- 
- 
      @Test(dataProvider = "floatBinaryOpProvider")
      static void ADDFloatMaxVectorTestsBroadcastLongSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());

@@ -1980,67 +2006,10 @@
          }
  
          assertBroadcastLongArraysEquals(r, a, b, mask, FloatMaxVectorTests::ADD);
      }
  
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
      static float MIN(float a, float b) {
          return (float)(Math.min(a, b));
      }
  
      @Test(dataProvider = "floatBinaryOpProvider")

@@ -2057,10 +2026,11 @@
              }
          }
  
          assertArraysEquals(r, a, b, FloatMaxVectorTests::MIN);
      }
+ 
      static float min(float a, float b) {
          return (float)(Math.min(a, b));
      }
  
      @Test(dataProvider = "floatBinaryOpProvider")

@@ -2075,10 +2045,11 @@
              av.min(bv).intoArray(r, i);
          }
  
          assertArraysEquals(r, a, b, FloatMaxVectorTests::min);
      }
+ 
      static float MAX(float a, float b) {
          return (float)(Math.max(a, b));
      }
  
      @Test(dataProvider = "floatBinaryOpProvider")

@@ -2095,10 +2066,11 @@
              }
          }
  
          assertArraysEquals(r, a, b, FloatMaxVectorTests::MAX);
      }
+ 
      static float max(float a, float b) {
          return (float)(Math.max(a, b));
      }
  
      @Test(dataProvider = "floatBinaryOpProvider")

@@ -2170,21 +2142,10 @@
          }
  
          assertBroadcastArraysEquals(r, a, b, FloatMaxVectorTests::max);
      }
  
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
      static float ADDReduce(float[] a, int idx) {
          float res = 0;
          for (int i = idx; i < (idx + SPECIES.length()); i++) {
              res += a[i];
          }

@@ -2198,10 +2159,11 @@
              res += ADDReduce(a, i);
          }
  
          return res;
      }
+ 
      @Test(dataProvider = "floatUnaryOpProvider")
      static void ADDReduceFloatMaxVectorTests(IntFunction<float[]> fa) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
          float ra = 0;

@@ -2222,10 +2184,11 @@
          }
  
          assertReductionArraysEquals(r, ra, a,
                  FloatMaxVectorTests::ADDReduce, FloatMaxVectorTests::ADDReduceAll);
      }
+ 
      static float ADDReduceMasked(float[] a, int idx, boolean[] mask) {
          float res = 0;
          for (int i = idx; i < (idx + SPECIES.length()); i++) {
              if (mask[i % SPECIES.length()])
                  res += a[i];

@@ -2240,10 +2203,11 @@
              res += ADDReduceMasked(a, i, mask);
          }
  
          return res;
      }
+ 
      @Test(dataProvider = "floatUnaryOpMaskProvider")
      static void ADDReduceFloatMaxVectorTestsMasked(IntFunction<float[]> fa, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
          boolean[] mask = fm.apply(SPECIES.length());

@@ -2266,10 +2230,11 @@
          }
  
          assertReductionArraysEqualsMasked(r, ra, a, mask,
                  FloatMaxVectorTests::ADDReduceMasked, FloatMaxVectorTests::ADDReduceAllMasked);
      }
+ 
      static float MULReduce(float[] a, int idx) {
          float res = 1;
          for (int i = idx; i < (idx + SPECIES.length()); i++) {
              res *= a[i];
          }

@@ -2283,10 +2248,11 @@
              res *= MULReduce(a, i);
          }
  
          return res;
      }
+ 
      @Test(dataProvider = "floatUnaryOpProvider")
      static void MULReduceFloatMaxVectorTests(IntFunction<float[]> fa) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
          float ra = 1;

@@ -2307,10 +2273,11 @@
          }
  
          assertReductionArraysEquals(r, ra, a,
                  FloatMaxVectorTests::MULReduce, FloatMaxVectorTests::MULReduceAll);
      }
+ 
      static float MULReduceMasked(float[] a, int idx, boolean[] mask) {
          float res = 1;
          for (int i = idx; i < (idx + SPECIES.length()); i++) {
              if (mask[i % SPECIES.length()])
                  res *= a[i];

@@ -2325,10 +2292,11 @@
              res *= MULReduceMasked(a, i, mask);
          }
  
          return res;
      }
+ 
      @Test(dataProvider = "floatUnaryOpMaskProvider")
      static void MULReduceFloatMaxVectorTestsMasked(IntFunction<float[]> fa, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
          boolean[] mask = fm.apply(SPECIES.length());

@@ -2351,10 +2319,11 @@
          }
  
          assertReductionArraysEqualsMasked(r, ra, a, mask,
                  FloatMaxVectorTests::MULReduceMasked, FloatMaxVectorTests::MULReduceAllMasked);
      }
+ 
      static float MINReduce(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]);
          }

@@ -2368,10 +2337,11 @@
              res = (float) Math.min(res, MINReduce(a, i));
          }
  
          return res;
      }
+ 
      @Test(dataProvider = "floatUnaryOpProvider")
      static void MINReduceFloatMaxVectorTests(IntFunction<float[]> fa) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
          float ra = Float.POSITIVE_INFINITY;

@@ -2392,10 +2362,11 @@
          }
  
          assertReductionArraysEquals(r, ra, a,
                  FloatMaxVectorTests::MINReduce, FloatMaxVectorTests::MINReduceAll);
      }
+ 
      static float MINReduceMasked(float[] a, int idx, boolean[] mask) {
          float res = Float.POSITIVE_INFINITY;
          for (int i = idx; i < (idx + SPECIES.length()); i++) {
              if (mask[i % SPECIES.length()])
                  res = (float) Math.min(res, a[i]);

@@ -2410,10 +2381,11 @@
              res = (float) Math.min(res, MINReduceMasked(a, i, mask));
          }
  
          return res;
      }
+ 
      @Test(dataProvider = "floatUnaryOpMaskProvider")
      static void MINReduceFloatMaxVectorTestsMasked(IntFunction<float[]> fa, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
          boolean[] mask = fm.apply(SPECIES.length());

@@ -2436,10 +2408,11 @@
          }
  
          assertReductionArraysEqualsMasked(r, ra, a, mask,
                  FloatMaxVectorTests::MINReduceMasked, FloatMaxVectorTests::MINReduceAllMasked);
      }
+ 
      static float MAXReduce(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]);
          }

@@ -2453,10 +2426,11 @@
              res = (float) Math.max(res, MAXReduce(a, i));
          }
  
          return res;
      }
+ 
      @Test(dataProvider = "floatUnaryOpProvider")
      static void MAXReduceFloatMaxVectorTests(IntFunction<float[]> fa) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
          float ra = Float.NEGATIVE_INFINITY;

@@ -2477,10 +2451,11 @@
          }
  
          assertReductionArraysEquals(r, ra, a,
                  FloatMaxVectorTests::MAXReduce, FloatMaxVectorTests::MAXReduceAll);
      }
+ 
      static float MAXReduceMasked(float[] a, int idx, boolean[] mask) {
          float res = Float.NEGATIVE_INFINITY;
          for (int i = idx; i < (idx + SPECIES.length()); i++) {
              if (mask[i % SPECIES.length()])
                  res = (float) Math.max(res, a[i]);

@@ -2495,10 +2470,11 @@
              res = (float) Math.max(res, MAXReduceMasked(a, i, mask));
          }
  
          return res;
      }
+ 
      @Test(dataProvider = "floatUnaryOpMaskProvider")
      static void MAXReduceFloatMaxVectorTestsMasked(IntFunction<float[]> fa, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
          boolean[] mask = fm.apply(SPECIES.length());

@@ -2521,10 +2497,11 @@
          }
  
          assertReductionArraysEqualsMasked(r, ra, a, mask,
                  FloatMaxVectorTests::MAXReduceMasked, FloatMaxVectorTests::MAXReduceAllMasked);
      }
+ 
      static float FIRST_NONZEROReduce(float[] a, int idx) {
          float res = (float) 0;
          for (int i = idx; i < (idx + SPECIES.length()); i++) {
              res = firstNonZero(res, a[i]);
          }

@@ -2538,10 +2515,11 @@
              res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
          }
  
          return res;
      }
+ 
      @Test(dataProvider = "floatUnaryOpProvider")
      static void FIRST_NONZEROReduceFloatMaxVectorTests(IntFunction<float[]> fa) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
          float ra = (float) 0;

@@ -2562,10 +2540,11 @@
          }
  
          assertReductionArraysEquals(r, ra, a,
                  FloatMaxVectorTests::FIRST_NONZEROReduce, FloatMaxVectorTests::FIRST_NONZEROReduceAll);
      }
+ 
      static float FIRST_NONZEROReduceMasked(float[] a, int idx, boolean[] mask) {
          float res = (float) 0;
          for (int i = idx; i < (idx + SPECIES.length()); i++) {
              if (mask[i % SPECIES.length()])
                  res = firstNonZero(res, a[i]);

@@ -2580,10 +2559,11 @@
              res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
          }
  
          return res;
      }
+ 
      @Test(dataProvider = "floatUnaryOpMaskProvider")
      static void FIRST_NONZEROReduceFloatMaxVectorTestsMasked(IntFunction<float[]> fa, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
          boolean[] mask = fm.apply(SPECIES.length());

@@ -2607,14 +2587,10 @@
  
          assertReductionArraysEqualsMasked(r, ra, a, mask,
                  FloatMaxVectorTests::FIRST_NONZEROReduceMasked, FloatMaxVectorTests::FIRST_NONZEROReduceAllMasked);
      }
  
- 
- 
- 
- 
      @Test(dataProvider = "floatUnaryOpProvider")
      static void withFloatMaxVectorTests(IntFunction<float []> fa) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
  

@@ -2628,10 +2604,11 @@
  
          for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
              assertInsertArraysEquals(r, a, (float)(65535+i), (j++ & (SPECIES.length()-1)), i , i + SPECIES.length());
          }
      }
+ 
      static boolean testIS_DEFAULT(float a) {
          return bits(a)==0;
      }
  
      @Test(dataProvider = "floatTestOpProvider")

@@ -2668,10 +2645,11 @@
                      Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
                  }
              }
          }
      }
+ 
      static boolean testIS_NEGATIVE(float a) {
          return bits(a)<0;
      }
  
      @Test(dataProvider = "floatTestOpProvider")

@@ -2750,11 +2728,10 @@
                  }
              }
          }
      }
  
- 
      static boolean testIS_NAN(float a) {
          return Float.isNaN(a);
      }
  
      @Test(dataProvider = "floatTestOpProvider")

@@ -2792,11 +2769,10 @@
                  }
              }
          }
      }
  
- 
      static boolean testIS_INFINITE(float a) {
          return Float.isInfinite(a);
      }
  
      @Test(dataProvider = "floatTestOpProvider")

@@ -2834,11 +2810,10 @@
                  }
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpProvider")
      static void LTFloatMaxVectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
  

@@ -2854,11 +2829,10 @@
                  }
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpProvider")
      static void ltFloatMaxVectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
  

@@ -2897,11 +2871,10 @@
                  }
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpProvider")
      static void GTFloatMaxVectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
  

@@ -2940,11 +2913,10 @@
                  }
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpProvider")
      static void EQFloatMaxVectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
  

@@ -2960,11 +2932,10 @@
                  }
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpProvider")
      static void eqFloatMaxVectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
  

@@ -3003,11 +2974,10 @@
                  }
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpProvider")
      static void NEFloatMaxVectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
  

@@ -3046,11 +3016,10 @@
                  }
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpProvider")
      static void LEFloatMaxVectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
  

@@ -3089,11 +3058,10 @@
                  }
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpProvider")
      static void GEFloatMaxVectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
  

@@ -3132,19 +3100,10 @@
                  }
              }
          }
      }
  
- 
- 
- 
- 
- 
- 
- 
- 
- 
      @Test(dataProvider = "floatCompareOpProvider")
      static void LTFloatMaxVectorTestsBroadcastSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
  

@@ -3157,11 +3116,10 @@
                  Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpMaskProvider")
      static void LTFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<float[]> fa,
                                  IntFunction<float[]> fb, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());

@@ -3194,11 +3152,10 @@
                  Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (float)((long)b[i]));
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpMaskProvider")
      static void LTFloatMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<float[]> fa,
                                  IntFunction<float[]> fb, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());

@@ -3231,11 +3188,10 @@
                  Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpMaskProvider")
      static void EQFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<float[]> fa,
                                  IntFunction<float[]> fb, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());

@@ -3268,11 +3224,10 @@
                  Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (float)((long)b[i]));
              }
          }
      }
  
- 
      @Test(dataProvider = "floatCompareOpMaskProvider")
      static void EQFloatMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<float[]> fa,
                                  IntFunction<float[]> fb, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());

@@ -3347,10 +3302,47 @@
              av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
          }
  
          assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
      }
+ 
+     @Test(dataProvider = "floatUnaryOpMaskProvider")
+     static void compressFloatMaxVectorTests(IntFunction<float[]> fa,
+                                                 IntFunction<boolean[]> fm) {
+         float[] a = fa.apply(SPECIES.length());
+         float[] r = fr.apply(SPECIES.length());
+         boolean[] mask = fm.apply(SPECIES.length());
+         VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 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);
+                 av.compress(vmask).intoArray(r, i);
+             }
+         }
+ 
+         assertcompressArraysEquals(r, a, mask, SPECIES.length());
+     }
+ 
+     @Test(dataProvider = "floatUnaryOpMaskProvider")
+     static void expandFloatMaxVectorTests(IntFunction<float[]> fa,
+                                                 IntFunction<boolean[]> fm) {
+         float[] a = fa.apply(SPECIES.length());
+         float[] r = fr.apply(SPECIES.length());
+         boolean[] mask = fm.apply(SPECIES.length());
+         VectorMask<Float> vmask = VectorMask.fromArray(SPECIES, mask, 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);
+                 av.expand(vmask).intoArray(r, i);
+             }
+         }
+ 
+         assertexpandArraysEquals(r, a, mask, SPECIES.length());
+     }
+ 
      @Test(dataProvider = "floatUnaryOpProvider")
      static void getFloatMaxVectorTests(IntFunction<float[]> fa) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
  

@@ -3517,14 +3509,10 @@
          }
  
          assertBroadcastArraysEquals(r, a);
      }
  
- 
- 
- 
- 
      @Test(dataProvider = "floatUnaryOpProvider")
      static void ZeroFloatMaxVectorTests(IntFunction<float[]> fa) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = new float[a.length];
  

@@ -3535,13 +3523,10 @@
          }
  
          Assert.assertEquals(a, r);
      }
  
- 
- 
- 
      static float[] sliceUnary(float[] a, int origin, int idx) {
          float[] res = new float[SPECIES.length()];
          for (int i = 0; i < SPECIES.length(); i++){
              if(i+origin < SPECIES.length())
                  res[i] = a[idx+i+origin];

@@ -3563,10 +3548,11 @@
              }
          }
  
          assertArraysEquals(r, a, origin, FloatMaxVectorTests::sliceUnary);
      }
+ 
      static float[] sliceBinary(float[] a, float[] b, int origin, int idx) {
          float[] res = new float[SPECIES.length()];
          for (int i = 0, j = 0; i < SPECIES.length(); i++){
              if(i+origin < SPECIES.length())
                  res[i] = a[idx+i+origin];

@@ -3592,10 +3578,11 @@
              }
          }
  
          assertArraysEquals(r, a, b, origin, FloatMaxVectorTests::sliceBinary);
      }
+ 
      static float[] slice(float[] a, float[] b, int origin, boolean[] mask, int idx) {
          float[] res = new float[SPECIES.length()];
          for (int i = 0, j = 0; i < SPECIES.length(); i++){
              if(i+origin < SPECIES.length())
                  res[i] = mask[i] ? a[idx+i+origin] : (float)0;

@@ -3625,10 +3612,11 @@
              }
          }
  
          assertArraysEquals(r, a, b, origin, mask, FloatMaxVectorTests::slice);
      }
+ 
      static float[] unsliceUnary(float[] a, int origin, int idx) {
          float[] res = new float[SPECIES.length()];
          for (int i = 0, j = 0; i < SPECIES.length(); i++){
              if(i < origin)
                  res[i] = (float)0;

@@ -3652,10 +3640,11 @@
              }
          }
  
          assertArraysEquals(r, a, origin, FloatMaxVectorTests::unsliceUnary);
      }
+ 
      static float[] unsliceBinary(float[] a, float[] b, int origin, int part, int idx) {
          float[] res = new float[SPECIES.length()];
          for (int i = 0, j = 0; i < SPECIES.length(); i++){
              if (part == 0) {
                  if (i < origin)

@@ -3691,10 +3680,11 @@
              }
          }
  
          assertArraysEquals(r, a, b, origin, part, FloatMaxVectorTests::unsliceBinary);
      }
+ 
      static float[] unslice(float[] a, float[] b, int origin, int part, boolean[] mask, int idx) {
          float[] res = new float[SPECIES.length()];
          for (int i = 0, j = 0; i < SPECIES.length(); i++){
              if(i+origin < SPECIES.length())
                  res[i] = b[idx+i+origin];

@@ -3771,11 +3761,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::SIN, FloatMaxVectorTests::strictSIN);
      }
  
- 
      static float EXP(float a) {
          return (float)(Math.exp((double)a));
      }
  
      static float strictEXP(float a) {

@@ -3795,11 +3784,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::EXP, FloatMaxVectorTests::strictEXP);
      }
  
- 
      static float LOG1P(float a) {
          return (float)(Math.log1p((double)a));
      }
  
      static float strictLOG1P(float a) {

@@ -3819,11 +3807,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::LOG1P, FloatMaxVectorTests::strictLOG1P);
      }
  
- 
      static float LOG(float a) {
          return (float)(Math.log((double)a));
      }
  
      static float strictLOG(float a) {

@@ -3843,11 +3830,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::LOG, FloatMaxVectorTests::strictLOG);
      }
  
- 
      static float LOG10(float a) {
          return (float)(Math.log10((double)a));
      }
  
      static float strictLOG10(float a) {

@@ -3867,11 +3853,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::LOG10, FloatMaxVectorTests::strictLOG10);
      }
  
- 
      static float EXPM1(float a) {
          return (float)(Math.expm1((double)a));
      }
  
      static float strictEXPM1(float a) {

@@ -3891,11 +3876,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::EXPM1, FloatMaxVectorTests::strictEXPM1);
      }
  
- 
      static float COS(float a) {
          return (float)(Math.cos((double)a));
      }
  
      static float strictCOS(float a) {

@@ -3915,11 +3899,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::COS, FloatMaxVectorTests::strictCOS);
      }
  
- 
      static float TAN(float a) {
          return (float)(Math.tan((double)a));
      }
  
      static float strictTAN(float a) {

@@ -3939,11 +3922,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::TAN, FloatMaxVectorTests::strictTAN);
      }
  
- 
      static float SINH(float a) {
          return (float)(Math.sinh((double)a));
      }
  
      static float strictSINH(float a) {

@@ -3963,11 +3945,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::SINH, FloatMaxVectorTests::strictSINH);
      }
  
- 
      static float COSH(float a) {
          return (float)(Math.cosh((double)a));
      }
  
      static float strictCOSH(float a) {

@@ -3987,11 +3968,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::COSH, FloatMaxVectorTests::strictCOSH);
      }
  
- 
      static float TANH(float a) {
          return (float)(Math.tanh((double)a));
      }
  
      static float strictTANH(float a) {

@@ -4011,11 +3991,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::TANH, FloatMaxVectorTests::strictTANH);
      }
  
- 
      static float ASIN(float a) {
          return (float)(Math.asin((double)a));
      }
  
      static float strictASIN(float a) {

@@ -4035,11 +4014,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::ASIN, FloatMaxVectorTests::strictASIN);
      }
  
- 
      static float ACOS(float a) {
          return (float)(Math.acos((double)a));
      }
  
      static float strictACOS(float a) {

@@ -4059,11 +4037,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::ACOS, FloatMaxVectorTests::strictACOS);
      }
  
- 
      static float ATAN(float a) {
          return (float)(Math.atan((double)a));
      }
  
      static float strictATAN(float a) {

@@ -4083,11 +4060,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::ATAN, FloatMaxVectorTests::strictATAN);
      }
  
- 
      static float CBRT(float a) {
          return (float)(Math.cbrt((double)a));
      }
  
      static float strictCBRT(float a) {

@@ -4107,11 +4083,10 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::CBRT, FloatMaxVectorTests::strictCBRT);
      }
  
- 
      static float HYPOT(float a, float b) {
          return (float)(Math.hypot((double)a, (double)b));
      }
  
      static float strictHYPOT(float a, float b) {

@@ -4134,11 +4109,10 @@
  
          assertArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::HYPOT, FloatMaxVectorTests::strictHYPOT);
      }
  
  
- 
      static float POW(float a, float b) {
          return (float)(Math.pow((double)a, (double)b));
      }
  
      static float strictPOW(float a, float b) {

@@ -4160,10 +4134,11 @@
          }
  
          assertArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::POW, FloatMaxVectorTests::strictPOW);
      }
  
+ 
      static float pow(float a, float b) {
          return (float)(Math.pow((double)a, (double)b));
      }
  
      static float strictpow(float a, float b) {

@@ -4186,11 +4161,10 @@
  
          assertArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::pow, FloatMaxVectorTests::strictpow);
      }
  
  
- 
      static float ATAN2(float a, float b) {
          return (float)(Math.atan2((double)a, (double)b));
      }
  
      static float strictATAN2(float a, float b) {

@@ -4213,11 +4187,10 @@
  
          assertArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::ATAN2, FloatMaxVectorTests::strictATAN2);
      }
  
  
- 
      @Test(dataProvider = "floatBinaryOpProvider")
      static void POWFloatMaxVectorTestsBroadcastSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());

@@ -4228,10 +4201,11 @@
          }
  
          assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::POW, FloatMaxVectorTests::strictPOW);
      }
  
+ 
      @Test(dataProvider = "floatBinaryOpProvider")
      static void powFloatMaxVectorTestsBroadcastSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());

@@ -4243,19 +4217,18 @@
  
          assertBroadcastArraysEqualsWithinOneUlp(r, a, b, FloatMaxVectorTests::pow, FloatMaxVectorTests::strictpow);
      }
  
  
- 
      static float FMA(float a, float b, float c) {
          return (float)(Math.fma(a, b, c));
      }
+ 
      static float fma(float a, float b, float c) {
          return (float)(Math.fma(a, b, c));
      }
  
- 
      @Test(dataProvider = "floatTernaryOpProvider")
      static void FMAFloatMaxVectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb, IntFunction<float[]> fc) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
          float[] c = fc.apply(SPECIES.length());

@@ -4270,10 +4243,11 @@
              }
          }
  
          assertArraysEquals(r, a, b, c, FloatMaxVectorTests::FMA);
      }
+ 
      @Test(dataProvider = "floatTernaryOpProvider")
      static void fmaFloatMaxVectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb, IntFunction<float[]> fc) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
          float[] c = fc.apply(SPECIES.length());

@@ -4287,11 +4261,10 @@
          }
  
          assertArraysEquals(r, a, b, c, FloatMaxVectorTests::fma);
      }
  
- 
      @Test(dataProvider = "floatTernaryOpMaskProvider")
      static void FMAFloatMaxVectorTestsMasked(IntFunction<float[]> fa, IntFunction<float[]> fb,
                                            IntFunction<float[]> fc, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());

@@ -4310,14 +4283,10 @@
          }
  
          assertArraysEquals(r, a, b, c, mask, FloatMaxVectorTests::FMA);
      }
  
- 
- 
- 
- 
      @Test(dataProvider = "floatTernaryOpProvider")
      static void FMAFloatMaxVectorTestsBroadcastSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb, IntFunction<float[]> fc) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
          float[] c = fc.apply(SPECIES.length());

@@ -4344,11 +4313,10 @@
              av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i);
          }
          assertAltBroadcastArraysEquals(r, a, b, c, FloatMaxVectorTests::FMA);
      }
  
- 
      @Test(dataProvider = "floatTernaryOpMaskProvider")
      static void FMAFloatMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb,
                                            IntFunction<float[]> fc, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());

@@ -4383,13 +4351,10 @@
          }
  
          assertAltBroadcastArraysEquals(r, a, b, c, mask, FloatMaxVectorTests::FMA);
      }
  
- 
- 
- 
      @Test(dataProvider = "floatTernaryOpProvider")
      static void FMAFloatMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb, IntFunction<float[]> fc) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
          float[] c = fc.apply(SPECIES.length());

@@ -4400,10 +4365,11 @@
              av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i);
          }
  
          assertDoubleBroadcastArraysEquals(r, a, b, c, FloatMaxVectorTests::FMA);
      }
+ 
      @Test(dataProvider = "floatTernaryOpProvider")
      static void fmaFloatMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb, IntFunction<float[]> fc) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
          float[] c = fc.apply(SPECIES.length());

@@ -4415,11 +4381,10 @@
          }
  
          assertDoubleBroadcastArraysEquals(r, a, b, c, FloatMaxVectorTests::fma);
      }
  
- 
      @Test(dataProvider = "floatTernaryOpMaskProvider")
      static void FMAFloatMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb,
                                            IntFunction<float[]> fc, IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());

@@ -4434,13 +4399,10 @@
          }
  
          assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FloatMaxVectorTests::FMA);
      }
  
- 
- 
- 
      static float NEG(float a) {
          return (float)(-((float)a));
      }
  
      static float neg(float a) {

@@ -4549,27 +4511,18 @@
          }
  
          assertArraysEquals(r, a, mask, FloatMaxVectorTests::ABS);
      }
  
- 
- 
- 
- 
- 
- 
- 
      static float SQRT(float a) {
          return (float)(Math.sqrt((double)a));
      }
  
      static float sqrt(float a) {
          return (float)(Math.sqrt((double)a));
      }
  
- 
- 
      @Test(dataProvider = "floatUnaryOpProvider")
      static void SQRTFloatMaxVectorTests(IntFunction<float[]> fa) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());
  

@@ -4596,12 +4549,10 @@
          }
  
          assertArraysEquals(r, a, FloatMaxVectorTests::sqrt);
      }
  
- 
- 
      @Test(dataProvider = "floatUnaryOpMaskProvider")
      static void SQRTMaskedFloatMaxVectorTests(IntFunction<float[]> fa,
                                                  IntFunction<boolean[]> fm) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = fr.apply(SPECIES.length());

@@ -4616,11 +4567,10 @@
          }
  
          assertArraysEquals(r, a, mask, FloatMaxVectorTests::SQRT);
      }
  
- 
      @Test(dataProvider = "floatCompareOpProvider")
      static void ltFloatMaxVectorTestsBroadcastSmokeTest(IntFunction<float[]> fa, IntFunction<float[]> fb) {
          float[] a = fa.apply(SPECIES.length());
          float[] b = fb.apply(SPECIES.length());
  

@@ -5018,10 +4968,27 @@
          }
  
          assertMaskReductionArraysEquals(r, a, FloatMaxVectorTests::maskFirstTrue);
      }
  
+     @Test(dataProvider = "maskProvider")
+     static void maskCompressFloatMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
+         int trueCount = 0;
+         boolean[] a = fa.apply(SPECIES.length());
+ 
+         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
+             for (int i = 0; i < a.length; i += SPECIES.length()) {
+                 var vmask = SPECIES.loadMask(a, i);
+                 trueCount = vmask.trueCount();
+                 var rmask = vmask.compress();
+                 for (int j = 0; j < SPECIES.length(); j++)  {
+                     Assert.assertEquals(rmask.laneIsSet(j), j < trueCount);
+                 }
+             }
+         }
+     }
+ 
  
      @DataProvider
      public static Object[][] offsetProvider() {
          return new Object[][]{
                  {0},

@@ -5044,10 +5011,24 @@
                  Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
              }
          }
      }
  
+     @Test(dataProvider = "offsetProvider")
+     static void indexInRangeLongFloatMaxVectorTestsSmokeTest(int offset) {
+         long limit = SPECIES.length() * BUFFER_REPS;
+         for (long i = 0; i < limit; i += SPECIES.length()) {
+             var actualMask = SPECIES.indexInRange(i + offset, limit);
+             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
+             assert(actualMask.equals(expectedMask));
+             for (int j = 0; j < SPECIES.length(); j++)  {
+                 long index = i + j + offset;
+                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
+             }
+         }
+     }
+ 
      @DataProvider
      public static Object[][] lengthProvider() {
          return new Object[][]{
                  {0},
                  {1},

@@ -5064,10 +5045,18 @@
          int actualLoopBound = SPECIES.loopBound(length);
          int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
          Assert.assertEquals(actualLoopBound, expectedLoopBound);
      }
  
+     @Test(dataProvider = "lengthProvider")
+     static void loopBoundLongFloatMaxVectorTestsSmokeTest(int _length) {
+         long length = _length;
+         long actualLoopBound = SPECIES.loopBound(length);
+         long expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
+         Assert.assertEquals(actualLoopBound, expectedLoopBound);
+     }
+ 
      @Test
      static void ElementSizeFloatMaxVectorTestsSmokeTest() {
          FloatVector av = FloatVector.zero(SPECIES);
          int elsize = av.elementSize();
          Assert.assertEquals(elsize, Float.SIZE);

@@ -5126,6 +5115,5 @@
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
            Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
          }
      }
  }
- 
< prev index next >