< prev index next >

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

Print this page
*** 63,11 ***
          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);
--- 63,10 ---

*** 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 ***
          } 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(
--- 1075,10 ---

*** 1211,11 ***
                          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);
              }),
--- 1258,10 ---

*** 1332,11 ***
      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) {
--- 1378,10 ---

*** 1357,11 ***
  
      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
--- 1402,10 ---

*** 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 ***
          }
  
          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());
--- 1772,10 ---

*** 1762,12 ***
          }
  
          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")
--- 1810,10 ---

*** 1805,18 ***
          }
  
          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());
--- 1851,10 ---

*** 1906,11 ***
          }
  
          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());
--- 1944,10 ---

*** 1921,12 ***
          }
  
          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());
--- 1958,10 ---

*** 1940,19 ***
          }
  
          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());
--- 1975,10 ---

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

*** 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 ***
          }
  
          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];
          }
--- 2142,10 ---

*** 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 ***
  
          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());
  
--- 2587,10 ---

*** 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 ***
                  }
              }
          }
      }
  
- 
      static boolean testIS_NAN(float a) {
          return Float.isNaN(a);
      }
  
      @Test(dataProvider = "floatTestOpProvider")
--- 2728,10 ---

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

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

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

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

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

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

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

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

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

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

*** 3157,11 ***
                  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());
--- 3116,10 ---

*** 3194,11 ***
                  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());
--- 3152,10 ---

*** 3231,11 ***
                  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());
--- 3188,10 ---

*** 3268,11 ***
                  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());
--- 3224,10 ---

*** 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 ***
          }
  
          assertBroadcastArraysEquals(r, a);
      }
  
- 
- 
- 
- 
      @Test(dataProvider = "floatUnaryOpProvider")
      static void ZeroFloatMaxVectorTests(IntFunction<float[]> fa) {
          float[] a = fa.apply(SPECIES.length());
          float[] r = new float[a.length];
  
--- 3509,10 ---

*** 3535,13 ***
          }
  
          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];
--- 3523,10 ---

*** 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 ***
          }
  
          assertArraysEqualsWithinOneUlp(r, a, FloatMaxVectorTests::SIN, FloatMaxVectorTests::strictSIN);
      }
  
- 
      static float EXP(float a) {
          return (float)(Math.exp((double)a));
      }
  
      static float strictEXP(float a) {
--- 3761,10 ---

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

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

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

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

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

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

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

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

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

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

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

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

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

*** 4107,11 ***
          }
  
          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) {
--- 4083,10 ---

*** 4134,11 ***
  
          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) {
--- 4109,10 ---

*** 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 ***
  
          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) {
--- 4161,10 ---

*** 4213,11 ***
  
          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());
--- 4187,10 ---

*** 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 ***
  
          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());
--- 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 ***
          }
  
          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());
--- 4261,10 ---

*** 4310,14 ***
          }
  
          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());
--- 4283,10 ---

*** 4344,11 ***
              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());
--- 4313,10 ---

*** 4383,13 ***
          }
  
          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());
--- 4351,10 ---

*** 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 ***
          }
  
          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());
--- 4381,10 ---

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

*** 4549,27 ***
          }
  
          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());
  
--- 4511,18 ---

*** 4596,12 ***
          }
  
          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());
--- 4549,10 ---

*** 4616,11 ***
          }
  
          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());
  
--- 4567,10 ---

*** 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 ***
          for (int ic = 0; ic < INVOC_COUNT; ic++) {
            Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
          }
      }
  }
- 
--- 5115,5 ---
< prev index next >