1 /*
   2  * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @modules jdk.incubator.vector
  27  * @run testng/othervm -ea -esa -Xbatch Int512VectorTests
  28  */
  29 
  30 // -- This file was mechanically generated: Do not edit! -- //
  31 
  32 import jdk.incubator.vector.VectorShape;
  33 import jdk.incubator.vector.VectorSpecies;
  34 import jdk.incubator.vector.VectorShuffle;
  35 import jdk.incubator.vector.VectorMask;
  36 import jdk.incubator.vector.VectorOperators;
  37 import jdk.incubator.vector.Vector;
  38 
  39 import jdk.incubator.vector.IntVector;
  40 
  41 import org.testng.Assert;
  42 import org.testng.annotations.DataProvider;
  43 import org.testng.annotations.Test;
  44 
  45 import java.lang.Integer;
  46 import java.util.List;
  47 import java.util.Arrays;
  48 import java.util.function.BiFunction;
  49 import java.util.function.IntFunction;
  50 import java.util.stream.Collectors;
  51 import java.util.stream.Stream;
  52 
  53 @Test
  54 public class Int512VectorTests extends AbstractVectorTest {
  55 
  56     static final VectorSpecies<Integer> SPECIES =
  57                 IntVector.SPECIES_512;
  58 
  59     static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
  60 
  61 
  62     static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 512);
  63 
  64     static final int BUFFER_SIZE = Integer.getInteger("jdk.incubator.vector.test.buffer-size", BUFFER_REPS * (512 / 8));
  65 
  66     interface FUnOp {
  67         int apply(int a);
  68     }
  69 
  70     static void assertArraysEquals(int[] a, int[] r, FUnOp f) {
  71         int i = 0;
  72         try {
  73             for (; i < a.length; i++) {
  74                 Assert.assertEquals(r[i], f.apply(a[i]));
  75             }
  76         } catch (AssertionError e) {
  77             Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
  78         }
  79     }
  80 
  81     interface FUnArrayOp {
  82         int[] apply(int a);
  83     }
  84 
  85     static void assertArraysEquals(int[] a, int[] r, FUnArrayOp f) {
  86         int i = 0;
  87         try {
  88             for (; i < a.length; i += SPECIES.length()) {
  89                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
  90                   f.apply(a[i]));
  91             }
  92         } catch (AssertionError e) {
  93             int[] ref = f.apply(a[i]);
  94             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
  95             Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
  96               + ", res: " + Arrays.toString(res)
  97               + "), at index #" + i);
  98         }
  99     }
 100 
 101     static void assertArraysEquals(int[] a, int[] r, boolean[] mask, FUnOp f) {
 102         int i = 0;
 103         try {
 104             for (; i < a.length; i++) {
 105                 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
 106             }
 107         } catch (AssertionError e) {
 108             Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i], "at index #" + i + ", input = " + a[i] + ", mask = " + mask[i % SPECIES.length()]);
 109         }
 110     }
 111 
 112     interface FReductionOp {
 113         int apply(int[] a, int idx);
 114     }
 115 
 116     interface FReductionAllOp {
 117         int apply(int[] a);
 118     }
 119 
 120     static void assertReductionArraysEquals(int[] a, int[] b, int c,
 121                                             FReductionOp f, FReductionAllOp fa) {
 122         int i = 0;
 123         try {
 124             Assert.assertEquals(c, fa.apply(a));
 125             for (; i < a.length; i += SPECIES.length()) {
 126                 Assert.assertEquals(b[i], f.apply(a, i));
 127             }
 128         } catch (AssertionError e) {
 129             Assert.assertEquals(c, fa.apply(a), "Final result is incorrect!");
 130             Assert.assertEquals(b[i], f.apply(a, i), "at index #" + i);
 131         }
 132     }
 133 
 134     interface FReductionMaskedOp {
 135         int apply(int[] a, int idx, boolean[] mask);
 136     }
 137 
 138     interface FReductionAllMaskedOp {
 139         int apply(int[] a, boolean[] mask);
 140     }
 141 
 142     static void assertReductionArraysEqualsMasked(int[] a, int[] b, int c, boolean[] mask,
 143                                             FReductionMaskedOp f, FReductionAllMaskedOp fa) {
 144         int i = 0;
 145         try {
 146             Assert.assertEquals(c, fa.apply(a, mask));
 147             for (; i < a.length; i += SPECIES.length()) {
 148                 Assert.assertEquals(b[i], f.apply(a, i, mask));
 149             }
 150         } catch (AssertionError e) {
 151             Assert.assertEquals(c, fa.apply(a, mask), "Final result is incorrect!");
 152             Assert.assertEquals(b[i], f.apply(a, i, mask), "at index #" + i);
 153         }
 154     }
 155 
 156     interface FBoolReductionOp {
 157         boolean apply(boolean[] a, int idx);
 158     }
 159 
 160     static void assertReductionBoolArraysEquals(boolean[] a, boolean[] b, FBoolReductionOp f) {
 161         int i = 0;
 162         try {
 163             for (; i < a.length; i += SPECIES.length()) {
 164                 Assert.assertEquals(b[i], f.apply(a, i));
 165             }
 166         } catch (AssertionError e) {
 167             Assert.assertEquals(b[i], f.apply(a, i), "at index #" + i);
 168         }
 169     }
 170 
 171     static void assertInsertArraysEquals(int[] a, int[] b, int element, int index) {
 172         int i = 0;
 173         try {
 174             for (; i < a.length; i += 1) {
 175                 if(i%SPECIES.length() == index) {
 176                     Assert.assertEquals(b[i], element);
 177                 } else {
 178                     Assert.assertEquals(b[i], a[i]);
 179                 }
 180             }
 181         } catch (AssertionError e) {
 182             if (i%SPECIES.length() == index) {
 183                 Assert.assertEquals(b[i], element, "at index #" + i);
 184             } else {
 185                 Assert.assertEquals(b[i], a[i], "at index #" + i);
 186             }
 187         }
 188     }
 189 
 190     static void assertRearrangeArraysEquals(int[] a, int[] r, int[] order, int vector_len) {
 191         int i = 0, j = 0;
 192         try {
 193             for (; i < a.length; i += vector_len) {
 194                 for (j = 0; j < vector_len; j++) {
 195                     Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 196                 }
 197             }
 198         } catch (AssertionError e) {
 199             int idx = i + j;
 200             Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
 201         }
 202     }
 203 
 204     static void assertBroadcastArraysEquals(int[]a, int[]r) {
 205         int i = 0;
 206         for (; i < a.length; i += SPECIES.length()) {
 207             int idx = i;
 208             for (int j = idx; j < (idx + SPECIES.length()); j++)
 209                 a[j]=a[idx];
 210         }
 211 
 212         try {
 213             for (i = 0; i < a.length; i++) {
 214                 Assert.assertEquals(r[i], a[i]);
 215             }
 216         } catch (AssertionError e) {
 217             Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
 218         }
 219     }
 220 
 221     interface FBinOp {
 222         int apply(int a, int b);
 223     }
 224 
 225     interface FBinMaskOp {
 226         int apply(int a, int b, boolean m);
 227 
 228         static FBinMaskOp lift(FBinOp f) {
 229             return (a, b, m) -> m ? f.apply(a, b) : a;
 230         }
 231     }
 232 
 233     static void assertArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
 234         int i = 0;
 235         try {
 236             for (; i < a.length; i++) {
 237                 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
 238             }
 239         } catch (AssertionError e) {
 240             Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
 241         }
 242     }
 243 
 244     static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
 245         assertArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
 246     }
 247 
 248     static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
 249         int i = 0;
 250         try {
 251             for (; i < a.length; i++) {
 252                 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
 253             }
 254         } catch (AssertionError err) {
 255             Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", mask = " + mask[i % SPECIES.length()]);
 256         }
 257     }
 258 
 259     static void assertShiftArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
 260         int i = 0;
 261         int j = 0;
 262         try {
 263             for (; j < a.length; j += SPECIES.length()) {
 264                 for (i = 0; i < SPECIES.length(); i++) {
 265                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
 266                 }
 267             }
 268         } catch (AssertionError e) {
 269             Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
 270         }
 271     }
 272 
 273     static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
 274         assertShiftArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
 275     }
 276 
 277     static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
 278         int i = 0;
 279         int j = 0;
 280         try {
 281             for (; j < a.length; j += SPECIES.length()) {
 282                 for (i = 0; i < SPECIES.length(); i++) {
 283                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
 284                 }
 285             }
 286         } catch (AssertionError err) {
 287             Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", input2 = " + b[j] + ", mask = " + mask[i]);
 288         }
 289     }
 290 
 291     interface FTernOp {
 292         int apply(int a, int b, int c);
 293     }
 294 
 295     interface FTernMaskOp {
 296         int apply(int a, int b, int c, boolean m);
 297 
 298         static FTernMaskOp lift(FTernOp f) {
 299             return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
 300         }
 301     }
 302 
 303     static void assertArraysEquals(int[] a, int[] b, int[] c, int[] r, FTernOp f) {
 304         int i = 0;
 305         try {
 306             for (; i < a.length; i++) {
 307                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
 308             }
 309         } catch (AssertionError e) {
 310             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 311         }
 312     }
 313 
 314     static void assertArraysEquals(int[] a, int[] b, int[] c, int[] r, boolean[] mask, FTernOp f) {
 315         assertArraysEquals(a, b, c, r, mask, FTernMaskOp.lift(f));
 316     }
 317 
 318     static void assertArraysEquals(int[] a, int[] b, int[] c, int[] r, boolean[] mask, FTernMaskOp f) {
 319         int i = 0;
 320         try {
 321             for (; i < a.length; i++) {
 322                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
 323             }
 324         } catch (AssertionError err) {
 325             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
 326               + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 327         }
 328     }
 329 
 330 
 331     interface FBinArrayOp {
 332         int apply(int[] a, int b);
 333     }
 334 
 335     static void assertArraysEquals(int[] a, int[] r, FBinArrayOp f) {
 336         int i = 0;
 337         try {
 338             for (; i < a.length; i++) {
 339                 Assert.assertEquals(r[i], f.apply(a, i));
 340             }
 341         } catch (AssertionError e) {
 342             Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
 343         }
 344     }
 345 
 346     interface FGatherScatterOp {
 347         int[] apply(int[] a, int ix, int[] b, int iy);
 348     }
 349 
 350     static void assertArraysEquals(int[] a, int[] b, int[] r, FGatherScatterOp f) {
 351         int i = 0;
 352         try {
 353             for (; i < a.length; i += SPECIES.length()) {
 354                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 355                   f.apply(a, i, b, i));
 356             }
 357         } catch (AssertionError e) {
 358             int[] ref = f.apply(a, i, b, i);
 359             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 360             Assert.assertEquals(res, ref,
 361               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 362               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 363               + ", b: "
 364               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 365               + " at index #" + i);
 366         }
 367     }
 368 
 369     interface FGatherMaskedOp {
 370         int[] apply(int[] a, int ix, boolean[] mask, int[] b, int iy);
 371     }
 372 
 373     interface FScatterMaskedOp {
 374         int[] apply(int[] r, int[] a, int ix, boolean[] mask, int[] b, int iy);
 375     }
 376 
 377     static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FGatherMaskedOp f) {
 378         int i = 0;
 379         try {
 380             for (; i < a.length; i += SPECIES.length()) {
 381                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 382                   f.apply(a, i, mask, b, i));
 383             }
 384         } catch (AssertionError e) {
 385             int[] ref = f.apply(a, i, mask, b, i);
 386             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 387             Assert.assertEquals(ref, res,
 388               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 389               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 390               + ", b: "
 391               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 392               + ", mask: "
 393               + Arrays.toString(mask)
 394               + " at index #" + i);
 395         }
 396     }
 397 
 398     static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FScatterMaskedOp f) {
 399         int i = 0;
 400         try {
 401             for (; i < a.length; i += SPECIES.length()) {
 402                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 403                   f.apply(r, a, i, mask, b, i));
 404             }
 405         } catch (AssertionError e) {
 406             int[] ref = f.apply(r, a, i, mask, b, i);
 407             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 408             Assert.assertEquals(ref, res,
 409               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 410               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 411               + ", b: "
 412               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 413               + ", r: "
 414               + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
 415               + ", mask: "
 416               + Arrays.toString(mask)
 417               + " at index #" + i);
 418         }
 419     }
 420 
 421     interface FLaneOp {
 422         int[] apply(int[] a, int origin, int idx);
 423     }
 424 
 425     static void assertArraysEquals(int[] a, int[] r, int origin, FLaneOp f) {
 426         int i = 0;
 427         try {
 428             for (; i < a.length; i += SPECIES.length()) {
 429                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 430                   f.apply(a, origin, i));
 431             }
 432         } catch (AssertionError e) {
 433             int[] ref = f.apply(a, origin, i);
 434             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 435             Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
 436               + ", res: " + Arrays.toString(res)
 437               + "), at index #" + i);
 438         }
 439     }
 440 
 441     interface FLaneBop {
 442         int[] apply(int[] a, int[] b, int origin, int idx);
 443     }
 444 
 445     static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, FLaneBop f) {
 446         int i = 0;
 447         try {
 448             for (; i < a.length; i += SPECIES.length()) {
 449                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 450                   f.apply(a, b, origin, i));
 451             }
 452         } catch (AssertionError e) {
 453             int[] ref = f.apply(a, b, origin, i);
 454             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 455             Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
 456               + ", res: " + Arrays.toString(res)
 457               + "), at index #" + i
 458               + ", at origin #" + origin);
 459         }
 460     }
 461 
 462     interface FLaneMaskedBop {
 463         int[] apply(int[] a, int[] b, int origin, boolean[] mask, int idx);
 464     }
 465 
 466     static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, boolean[] mask, FLaneMaskedBop f) {
 467         int i = 0;
 468         try {
 469             for (; i < a.length; i += SPECIES.length()) {
 470                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 471                   f.apply(a, b, origin, mask, i));
 472             }
 473         } catch (AssertionError e) {
 474             int[] ref = f.apply(a, b, origin, mask, i);
 475             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 476             Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
 477               + ", res: " + Arrays.toString(res)
 478               + "), at index #" + i
 479               + ", at origin #" + origin);
 480         }
 481     }
 482 
 483     interface FLanePartBop {
 484         int[] apply(int[] a, int[] b, int origin, int part, int idx);
 485     }
 486 
 487     static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, int part, FLanePartBop f) {
 488         int i = 0;
 489         try {
 490             for (; i < a.length; i += SPECIES.length()) {
 491                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 492                   f.apply(a, b, origin, part, i));
 493             }
 494         } catch (AssertionError e) {
 495             int[] ref = f.apply(a, b, origin, part, i);
 496             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 497             Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
 498               + ", res: " + Arrays.toString(res)
 499               + "), at index #" + i
 500               + ", at origin #" + origin
 501               + ", with part #" + part);
 502         }
 503     }
 504 
 505     interface FLanePartMaskedBop {
 506         int[] apply(int[] a, int[] b, int origin, int part, boolean[] mask, int idx);
 507     }
 508 
 509     static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
 510         int i = 0;
 511         try {
 512             for (; i < a.length; i += SPECIES.length()) {
 513                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 514                   f.apply(a, b, origin, part, mask, i));
 515             }
 516         } catch (AssertionError e) {
 517             int[] ref = f.apply(a, b, origin, part, mask, i);
 518             int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 519             Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
 520               + ", res: " + Arrays.toString(res)
 521               + "), at index #" + i
 522               + ", at origin #" + origin
 523               + ", with part #" + part);
 524         }
 525     }
 526 
 527     static int bits(int e) {
 528         return  e;
 529     }
 530 
 531     static final List<IntFunction<int[]>> INT_GENERATORS = List.of(
 532             withToString("int[-i * 5]", (int s) -> {
 533                 return fill(s * BUFFER_REPS,
 534                             i -> (int)(-i * 5));
 535             }),
 536             withToString("int[i * 5]", (int s) -> {
 537                 return fill(s * BUFFER_REPS,
 538                             i -> (int)(i * 5));
 539             }),
 540             withToString("int[i + 1]", (int s) -> {
 541                 return fill(s * BUFFER_REPS,
 542                             i -> (((int)(i + 1) == 0) ? 1 : (int)(i + 1)));
 543             }),
 544             withToString("int[cornerCaseValue(i)]", (int s) -> {
 545                 return fill(s * BUFFER_REPS,
 546                             i -> cornerCaseValue(i));
 547             })
 548     );
 549 
 550     // Create combinations of pairs
 551     // @@@ Might be sensitive to order e.g. div by 0
 552     static final List<List<IntFunction<int[]>>> INT_GENERATOR_PAIRS =
 553         Stream.of(INT_GENERATORS.get(0)).
 554                 flatMap(fa -> INT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
 555                 collect(Collectors.toList());
 556 
 557     @DataProvider
 558     public Object[][] boolUnaryOpProvider() {
 559         return BOOL_ARRAY_GENERATORS.stream().
 560                 map(f -> new Object[]{f}).
 561                 toArray(Object[][]::new);
 562     }
 563 
 564     static final List<List<IntFunction<int[]>>> INT_GENERATOR_TRIPLES =
 565         INT_GENERATOR_PAIRS.stream().
 566                 flatMap(pair -> INT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
 567                 collect(Collectors.toList());
 568 
 569     @DataProvider
 570     public Object[][] intBinaryOpProvider() {
 571         return INT_GENERATOR_PAIRS.stream().map(List::toArray).
 572                 toArray(Object[][]::new);
 573     }
 574 
 575     @DataProvider
 576     public Object[][] intIndexedOpProvider() {
 577         return INT_GENERATOR_PAIRS.stream().map(List::toArray).
 578                 toArray(Object[][]::new);
 579     }
 580 
 581     @DataProvider
 582     public Object[][] intBinaryOpMaskProvider() {
 583         return BOOLEAN_MASK_GENERATORS.stream().
 584                 flatMap(fm -> INT_GENERATOR_PAIRS.stream().map(lfa -> {
 585                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
 586                 })).
 587                 toArray(Object[][]::new);
 588     }
 589 
 590     @DataProvider
 591     public Object[][] intTernaryOpProvider() {
 592         return INT_GENERATOR_TRIPLES.stream().map(List::toArray).
 593                 toArray(Object[][]::new);
 594     }
 595 
 596     @DataProvider
 597     public Object[][] intTernaryOpMaskProvider() {
 598         return BOOLEAN_MASK_GENERATORS.stream().
 599                 flatMap(fm -> INT_GENERATOR_TRIPLES.stream().map(lfa -> {
 600                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
 601                 })).
 602                 toArray(Object[][]::new);
 603     }
 604 
 605     @DataProvider
 606     public Object[][] intUnaryOpProvider() {
 607         return INT_GENERATORS.stream().
 608                 map(f -> new Object[]{f}).
 609                 toArray(Object[][]::new);
 610     }
 611 
 612     @DataProvider
 613     public Object[][] intUnaryOpMaskProvider() {
 614         return BOOLEAN_MASK_GENERATORS.stream().
 615                 flatMap(fm -> INT_GENERATORS.stream().map(fa -> {
 616                     return new Object[] {fa, fm};
 617                 })).
 618                 toArray(Object[][]::new);
 619     }
 620 
 621     @DataProvider
 622     public Object[][] intUnaryOpShuffleProvider() {
 623         return INT_SHUFFLE_GENERATORS.stream().
 624                 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
 625                     return new Object[] {fa, fs};
 626                 })).
 627                 toArray(Object[][]::new);
 628     }
 629 
 630     @DataProvider
 631     public Object[][] intUnaryOpIndexProvider() {
 632         return INT_INDEX_GENERATORS.stream().
 633                 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
 634                     return new Object[] {fa, fs};
 635                 })).
 636                 toArray(Object[][]::new);
 637     }
 638 
 639     @DataProvider
 640     public Object[][] intUnaryMaskedOpIndexProvider() {
 641         return BOOLEAN_MASK_GENERATORS.stream().
 642           flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
 643             INT_GENERATORS.stream().map(fa -> {
 644                     return new Object[] {fa, fm, fs};
 645             }))).
 646             toArray(Object[][]::new);
 647     }
 648 
 649     @DataProvider
 650     public Object[][] scatterMaskedOpIndexProvider() {
 651         return BOOLEAN_MASK_GENERATORS.stream().
 652           flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
 653             INT_GENERATORS.stream().flatMap(fn ->
 654               INT_GENERATORS.stream().map(fa -> {
 655                     return new Object[] {fa, fn, fm, fs};
 656             })))).
 657             toArray(Object[][]::new);
 658     }
 659 
 660     static final List<IntFunction<int[]>> INT_COMPARE_GENERATORS = List.of(
 661             withToString("int[i]", (int s) -> {
 662                 return fill(s * BUFFER_REPS,
 663                             i -> (int)i);
 664             }),
 665             withToString("int[i + 1]", (int s) -> {
 666                 return fill(s * BUFFER_REPS,
 667                             i -> (int)(i + 1));
 668             }),
 669             withToString("int[i - 2]", (int s) -> {
 670                 return fill(s * BUFFER_REPS,
 671                             i -> (int)(i - 2));
 672             }),
 673             withToString("int[zigZag(i)]", (int s) -> {
 674                 return fill(s * BUFFER_REPS,
 675                             i -> i%3 == 0 ? (int)i : (i%3 == 1 ? (int)(i + 1) : (int)(i - 2)));
 676             }),
 677             withToString("int[cornerCaseValue(i)]", (int s) -> {
 678                 return fill(s * BUFFER_REPS,
 679                             i -> cornerCaseValue(i));
 680             })
 681     );
 682 
 683     static final List<List<IntFunction<int[]>>> INT_TEST_GENERATOR_ARGS =
 684         INT_COMPARE_GENERATORS.stream().
 685                 map(fa -> List.of(fa)).
 686                 collect(Collectors.toList());
 687 
 688     @DataProvider
 689     public Object[][] intTestOpProvider() {
 690         return INT_TEST_GENERATOR_ARGS.stream().map(List::toArray).
 691                 toArray(Object[][]::new);
 692     }
 693 
 694     static final List<List<IntFunction<int[]>>> INT_COMPARE_GENERATOR_PAIRS =
 695         INT_COMPARE_GENERATORS.stream().
 696                 flatMap(fa -> INT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
 697                 collect(Collectors.toList());
 698 
 699     @DataProvider
 700     public Object[][] intCompareOpProvider() {
 701         return INT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
 702                 toArray(Object[][]::new);
 703     }
 704 
 705     interface ToIntF {
 706         int apply(int i);
 707     }
 708 
 709     static int[] fill(int s , ToIntF f) {
 710         return fill(new int[s], f);
 711     }
 712 
 713     static int[] fill(int[] a, ToIntF f) {
 714         for (int i = 0; i < a.length; i++) {
 715             a[i] = f.apply(i);
 716         }
 717         return a;
 718     }
 719 
 720     static int cornerCaseValue(int i) {
 721         switch(i % 5) {
 722             case 0:
 723                 return Integer.MAX_VALUE;
 724             case 1:
 725                 return Integer.MIN_VALUE;
 726             case 2:
 727                 return Integer.MIN_VALUE;
 728             case 3:
 729                 return Integer.MAX_VALUE;
 730             default:
 731                 return (int)0;
 732         }
 733     }
 734    static int get(int[] a, int i) {
 735        return (int) a[i];
 736    }
 737 
 738    static final IntFunction<int[]> fr = (vl) -> {
 739         int length = BUFFER_REPS * vl;
 740         return new int[length];
 741     };
 742 
 743     static final IntFunction<boolean[]> fmr = (vl) -> {
 744         int length = BUFFER_REPS * vl;
 745         return new boolean[length];
 746     };
 747 
 748     static void replaceZero(int[] a, int v) {
 749         for (int i = 0; i < a.length; i++) {
 750             if (a[i] == 0) {
 751                 a[i] = v;
 752             }
 753         }
 754     }
 755 
 756     static void replaceZero(int[] a, boolean[] mask, int v) {
 757         for (int i = 0; i < a.length; i++) {
 758             if (mask[i % mask.length] && a[i] == 0) {
 759                 a[i] = v;
 760             }
 761         }
 762     }
 763 
 764     @Test
 765     static void smokeTest1() {
 766         IntVector three = IntVector.broadcast(SPECIES, (byte)-3);
 767         IntVector three2 = (IntVector) SPECIES.broadcast(-3);
 768         assert(three.eq(three2).allTrue());
 769         IntVector three3 = three2.broadcast(1).broadcast(-3);
 770         assert(three.eq(three3).allTrue());
 771         int scale = 2;
 772         Class<?> ETYPE = int.class;
 773         if (ETYPE == double.class || ETYPE == long.class)
 774             scale = 1000000;
 775         else if (ETYPE == byte.class && SPECIES.length() >= 64)
 776             scale = 1;
 777         IntVector higher = three.addIndex(scale);
 778         VectorMask<Integer> m = three.compare(VectorOperators.LE, higher);
 779         assert(m.allTrue());
 780         m = higher.min((int)-1).test(VectorOperators.IS_NEGATIVE);
 781         assert(m.allTrue());
 782         int max = higher.reduceLanes(VectorOperators.MAX);
 783         assert(max == -3 + scale * (SPECIES.length()-1));
 784     }
 785 
 786     private static int[]
 787     bothToArray(IntVector a, IntVector b) {
 788         int[] r = new int[a.length() + b.length()];
 789         a.intoArray(r, 0);
 790         b.intoArray(r, a.length());
 791         return r;
 792     }
 793 
 794     @Test
 795     static void smokeTest2() {
 796         // Do some zipping and shuffling.
 797         IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
 798         IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
 799         Assert.assertEquals(io, io2);
 800         IntVector a = io.add((int)1); //[1,2]
 801         IntVector b = a.neg();  //[-1,-2]
 802         int[] abValues = bothToArray(a,b); //[1,2,-1,-2]
 803         VectorShuffle<Integer> zip0 = VectorShuffle.makeZip(SPECIES, 0);
 804         VectorShuffle<Integer> zip1 = VectorShuffle.makeZip(SPECIES, 1);
 805         IntVector zab0 = a.rearrange(zip0,b); //[1,-1]
 806         IntVector zab1 = a.rearrange(zip1,b); //[2,-2]
 807         int[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
 808         // manually zip
 809         int[] manual = new int[zabValues.length];
 810         for (int i = 0; i < manual.length; i += 2) {
 811             manual[i+0] = abValues[i/2];
 812             manual[i+1] = abValues[a.length() + i/2];
 813         }
 814         Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
 815         VectorShuffle<Integer> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
 816         VectorShuffle<Integer> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
 817         IntVector uab0 = zab0.rearrange(unz0,zab1);
 818         IntVector uab1 = zab0.rearrange(unz1,zab1);
 819         int[] abValues1 = bothToArray(uab0, uab1);
 820         Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
 821     }
 822 
 823     static void iotaShuffle() {
 824         IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
 825         IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
 826         Assert.assertEquals(io, io2);
 827     }
 828 
 829     @Test
 830     // Test all shuffle related operations.
 831     static void shuffleTest() {
 832         // To test backend instructions, make sure that C2 is used.
 833         for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
 834             iotaShuffle();
 835         }
 836     }
 837 
 838     @Test
 839     void viewAsIntegeralLanesTest() {
 840         Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
 841         Assert.assertEquals(asIntegral.species(), SPECIES);
 842     }
 843 
 844     @Test
 845     void viewAsFloatingLanesTest() {
 846         Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
 847         VectorSpecies<?> asFloatingSpecies = asFloating.species();
 848         Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType());
 849         Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape());
 850         Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length());
 851         Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES);
 852     }
 853 
 854     @Test
 855     // Test div by 0.
 856     static void bitwiseDivByZeroSmokeTest() {
 857         try {
 858             IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
 859             IntVector b = (IntVector) SPECIES.broadcast(0);
 860             a.div(b);
 861             Assert.fail();
 862         } catch (ArithmeticException e) {
 863         }
 864 
 865         try {
 866             IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
 867             IntVector b = (IntVector) SPECIES.broadcast(0);
 868             VectorMask<Integer> m = a.lt((int) 1);
 869             a.div(b, m);
 870             Assert.fail();
 871         } catch (ArithmeticException e) {
 872         }
 873     }
 874     static int ADD(int a, int b) {
 875         return (int)(a + b);
 876     }
 877 
 878     @Test(dataProvider = "intBinaryOpProvider")
 879     static void ADDInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
 880         int[] a = fa.apply(SPECIES.length());
 881         int[] b = fb.apply(SPECIES.length());
 882         int[] r = fr.apply(SPECIES.length());
 883 
 884         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 885             for (int i = 0; i < a.length; i += SPECIES.length()) {
 886                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 887                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 888                 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
 889             }
 890         }
 891 
 892         assertArraysEquals(a, b, r, Int512VectorTests::ADD);
 893     }
 894     static int add(int a, int b) {
 895         return (int)(a + b);
 896     }
 897 
 898     @Test(dataProvider = "intBinaryOpProvider")
 899     static void addInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
 900         int[] a = fa.apply(SPECIES.length());
 901         int[] b = fb.apply(SPECIES.length());
 902         int[] r = fr.apply(SPECIES.length());
 903 
 904         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 905             for (int i = 0; i < a.length; i += SPECIES.length()) {
 906                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 907                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 908                 av.add(bv).intoArray(r, i);
 909             }
 910         }
 911 
 912         assertArraysEquals(a, b, r, Int512VectorTests::add);
 913     }
 914 
 915     @Test(dataProvider = "intBinaryOpMaskProvider")
 916     static void ADDInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
 917                                           IntFunction<boolean[]> fm) {
 918         int[] a = fa.apply(SPECIES.length());
 919         int[] b = fb.apply(SPECIES.length());
 920         int[] r = fr.apply(SPECIES.length());
 921         boolean[] mask = fm.apply(SPECIES.length());
 922         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
 923 
 924         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 925             for (int i = 0; i < a.length; i += SPECIES.length()) {
 926                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 927                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 928                 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
 929             }
 930         }
 931 
 932         assertArraysEquals(a, b, r, mask, Int512VectorTests::ADD);
 933     }
 934 
 935     @Test(dataProvider = "intBinaryOpMaskProvider")
 936     static void addInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
 937                                           IntFunction<boolean[]> fm) {
 938         int[] a = fa.apply(SPECIES.length());
 939         int[] b = fb.apply(SPECIES.length());
 940         int[] r = fr.apply(SPECIES.length());
 941         boolean[] mask = fm.apply(SPECIES.length());
 942         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
 943 
 944         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 945             for (int i = 0; i < a.length; i += SPECIES.length()) {
 946                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 947                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 948                 av.add(bv, vmask).intoArray(r, i);
 949             }
 950         }
 951 
 952         assertArraysEquals(a, b, r, mask, Int512VectorTests::add);
 953     }
 954     static int SUB(int a, int b) {
 955         return (int)(a - b);
 956     }
 957 
 958     @Test(dataProvider = "intBinaryOpProvider")
 959     static void SUBInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
 960         int[] a = fa.apply(SPECIES.length());
 961         int[] b = fb.apply(SPECIES.length());
 962         int[] r = fr.apply(SPECIES.length());
 963 
 964         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 965             for (int i = 0; i < a.length; i += SPECIES.length()) {
 966                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 967                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 968                 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
 969             }
 970         }
 971 
 972         assertArraysEquals(a, b, r, Int512VectorTests::SUB);
 973     }
 974     static int sub(int a, int b) {
 975         return (int)(a - b);
 976     }
 977 
 978     @Test(dataProvider = "intBinaryOpProvider")
 979     static void subInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
 980         int[] a = fa.apply(SPECIES.length());
 981         int[] b = fb.apply(SPECIES.length());
 982         int[] r = fr.apply(SPECIES.length());
 983 
 984         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 985             for (int i = 0; i < a.length; i += SPECIES.length()) {
 986                 IntVector av = IntVector.fromArray(SPECIES, a, i);
 987                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
 988                 av.sub(bv).intoArray(r, i);
 989             }
 990         }
 991 
 992         assertArraysEquals(a, b, r, Int512VectorTests::sub);
 993     }
 994 
 995     @Test(dataProvider = "intBinaryOpMaskProvider")
 996     static void SUBInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
 997                                           IntFunction<boolean[]> fm) {
 998         int[] a = fa.apply(SPECIES.length());
 999         int[] b = fb.apply(SPECIES.length());
1000         int[] r = fr.apply(SPECIES.length());
1001         boolean[] mask = fm.apply(SPECIES.length());
1002         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1003 
1004         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1005             for (int i = 0; i < a.length; i += SPECIES.length()) {
1006                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1007                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1008                 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1009             }
1010         }
1011 
1012         assertArraysEquals(a, b, r, mask, Int512VectorTests::SUB);
1013     }
1014 
1015     @Test(dataProvider = "intBinaryOpMaskProvider")
1016     static void subInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1017                                           IntFunction<boolean[]> fm) {
1018         int[] a = fa.apply(SPECIES.length());
1019         int[] b = fb.apply(SPECIES.length());
1020         int[] r = fr.apply(SPECIES.length());
1021         boolean[] mask = fm.apply(SPECIES.length());
1022         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1023 
1024         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1025             for (int i = 0; i < a.length; i += SPECIES.length()) {
1026                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1027                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1028                 av.sub(bv, vmask).intoArray(r, i);
1029             }
1030         }
1031 
1032         assertArraysEquals(a, b, r, mask, Int512VectorTests::sub);
1033     }
1034     static int MUL(int a, int b) {
1035         return (int)(a * b);
1036     }
1037 
1038     @Test(dataProvider = "intBinaryOpProvider")
1039     static void MULInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1040         int[] a = fa.apply(SPECIES.length());
1041         int[] b = fb.apply(SPECIES.length());
1042         int[] r = fr.apply(SPECIES.length());
1043 
1044         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1045             for (int i = 0; i < a.length; i += SPECIES.length()) {
1046                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1047                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1048                 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1049             }
1050         }
1051 
1052         assertArraysEquals(a, b, r, Int512VectorTests::MUL);
1053     }
1054     static int mul(int a, int b) {
1055         return (int)(a * b);
1056     }
1057 
1058     @Test(dataProvider = "intBinaryOpProvider")
1059     static void mulInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1060         int[] a = fa.apply(SPECIES.length());
1061         int[] b = fb.apply(SPECIES.length());
1062         int[] r = fr.apply(SPECIES.length());
1063 
1064         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1065             for (int i = 0; i < a.length; i += SPECIES.length()) {
1066                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1067                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1068                 av.mul(bv).intoArray(r, i);
1069             }
1070         }
1071 
1072         assertArraysEquals(a, b, r, Int512VectorTests::mul);
1073     }
1074 
1075     @Test(dataProvider = "intBinaryOpMaskProvider")
1076     static void MULInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1077                                           IntFunction<boolean[]> fm) {
1078         int[] a = fa.apply(SPECIES.length());
1079         int[] b = fb.apply(SPECIES.length());
1080         int[] r = fr.apply(SPECIES.length());
1081         boolean[] mask = fm.apply(SPECIES.length());
1082         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1083 
1084         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1085             for (int i = 0; i < a.length; i += SPECIES.length()) {
1086                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1087                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1088                 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1089             }
1090         }
1091 
1092         assertArraysEquals(a, b, r, mask, Int512VectorTests::MUL);
1093     }
1094 
1095     @Test(dataProvider = "intBinaryOpMaskProvider")
1096     static void mulInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1097                                           IntFunction<boolean[]> fm) {
1098         int[] a = fa.apply(SPECIES.length());
1099         int[] b = fb.apply(SPECIES.length());
1100         int[] r = fr.apply(SPECIES.length());
1101         boolean[] mask = fm.apply(SPECIES.length());
1102         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1103 
1104         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1105             for (int i = 0; i < a.length; i += SPECIES.length()) {
1106                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1107                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1108                 av.mul(bv, vmask).intoArray(r, i);
1109             }
1110         }
1111 
1112         assertArraysEquals(a, b, r, mask, Int512VectorTests::mul);
1113     }
1114 
1115 
1116 
1117     static int DIV(int a, int b) {
1118         return (int)(a / b);
1119     }
1120 
1121     @Test(dataProvider = "intBinaryOpProvider")
1122     static void DIVInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1123         int[] a = fa.apply(SPECIES.length());
1124         int[] b = fb.apply(SPECIES.length());
1125         int[] r = fr.apply(SPECIES.length());
1126 
1127         replaceZero(b, (int) 1);
1128 
1129         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1130             for (int i = 0; i < a.length; i += SPECIES.length()) {
1131                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1132                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1133                 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1134             }
1135         }
1136 
1137         assertArraysEquals(a, b, r, Int512VectorTests::DIV);
1138     }
1139     static int div(int a, int b) {
1140         return (int)(a / b);
1141     }
1142 
1143     @Test(dataProvider = "intBinaryOpProvider")
1144     static void divInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1145         int[] a = fa.apply(SPECIES.length());
1146         int[] b = fb.apply(SPECIES.length());
1147         int[] r = fr.apply(SPECIES.length());
1148 
1149         replaceZero(b, (int) 1);
1150 
1151         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1152             for (int i = 0; i < a.length; i += SPECIES.length()) {
1153                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1154                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1155                 av.div(bv).intoArray(r, i);
1156             }
1157         }
1158 
1159         assertArraysEquals(a, b, r, Int512VectorTests::div);
1160     }
1161 
1162 
1163 
1164     @Test(dataProvider = "intBinaryOpMaskProvider")
1165     static void DIVInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1166                                           IntFunction<boolean[]> fm) {
1167         int[] a = fa.apply(SPECIES.length());
1168         int[] b = fb.apply(SPECIES.length());
1169         int[] r = fr.apply(SPECIES.length());
1170         boolean[] mask = fm.apply(SPECIES.length());
1171         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1172 
1173         replaceZero(b, mask, (int) 1);
1174 
1175         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1176             for (int i = 0; i < a.length; i += SPECIES.length()) {
1177                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1178                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1179                 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1180             }
1181         }
1182 
1183         assertArraysEquals(a, b, r, mask, Int512VectorTests::DIV);
1184     }
1185 
1186     @Test(dataProvider = "intBinaryOpMaskProvider")
1187     static void divInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1188                                           IntFunction<boolean[]> fm) {
1189         int[] a = fa.apply(SPECIES.length());
1190         int[] b = fb.apply(SPECIES.length());
1191         int[] r = fr.apply(SPECIES.length());
1192         boolean[] mask = fm.apply(SPECIES.length());
1193         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1194 
1195         replaceZero(b, mask, (int) 1);
1196 
1197         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1198             for (int i = 0; i < a.length; i += SPECIES.length()) {
1199                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1200                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1201                 av.div(bv, vmask).intoArray(r, i);
1202             }
1203         }
1204 
1205         assertArraysEquals(a, b, r, mask, Int512VectorTests::div);
1206     }
1207 
1208     static int FIRST_NONZERO(int a, int b) {
1209         return (int)((a)!=0?a:b);
1210     }
1211 
1212     @Test(dataProvider = "intBinaryOpProvider")
1213     static void FIRST_NONZEROInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1214         int[] a = fa.apply(SPECIES.length());
1215         int[] b = fb.apply(SPECIES.length());
1216         int[] r = fr.apply(SPECIES.length());
1217 
1218         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1219             for (int i = 0; i < a.length; i += SPECIES.length()) {
1220                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1221                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1222                 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1223             }
1224         }
1225 
1226         assertArraysEquals(a, b, r, Int512VectorTests::FIRST_NONZERO);
1227     }
1228 
1229     @Test(dataProvider = "intBinaryOpMaskProvider")
1230     static void FIRST_NONZEROInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1231                                           IntFunction<boolean[]> fm) {
1232         int[] a = fa.apply(SPECIES.length());
1233         int[] b = fb.apply(SPECIES.length());
1234         int[] r = fr.apply(SPECIES.length());
1235         boolean[] mask = fm.apply(SPECIES.length());
1236         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1237 
1238         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1239             for (int i = 0; i < a.length; i += SPECIES.length()) {
1240                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1241                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1242                 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1243             }
1244         }
1245 
1246         assertArraysEquals(a, b, r, mask, Int512VectorTests::FIRST_NONZERO);
1247     }
1248 
1249     static int AND(int a, int b) {
1250         return (int)(a & b);
1251     }
1252 
1253     @Test(dataProvider = "intBinaryOpProvider")
1254     static void ANDInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1255         int[] a = fa.apply(SPECIES.length());
1256         int[] b = fb.apply(SPECIES.length());
1257         int[] r = fr.apply(SPECIES.length());
1258 
1259         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1260             for (int i = 0; i < a.length; i += SPECIES.length()) {
1261                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1262                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1263                 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1264             }
1265         }
1266 
1267         assertArraysEquals(a, b, r, Int512VectorTests::AND);
1268     }
1269     static int and(int a, int b) {
1270         return (int)(a & b);
1271     }
1272 
1273     @Test(dataProvider = "intBinaryOpProvider")
1274     static void andInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1275         int[] a = fa.apply(SPECIES.length());
1276         int[] b = fb.apply(SPECIES.length());
1277         int[] r = fr.apply(SPECIES.length());
1278 
1279         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1280             for (int i = 0; i < a.length; i += SPECIES.length()) {
1281                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1282                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1283                 av.and(bv).intoArray(r, i);
1284             }
1285         }
1286 
1287         assertArraysEquals(a, b, r, Int512VectorTests::and);
1288     }
1289 
1290 
1291 
1292     @Test(dataProvider = "intBinaryOpMaskProvider")
1293     static void ANDInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1294                                           IntFunction<boolean[]> fm) {
1295         int[] a = fa.apply(SPECIES.length());
1296         int[] b = fb.apply(SPECIES.length());
1297         int[] r = fr.apply(SPECIES.length());
1298         boolean[] mask = fm.apply(SPECIES.length());
1299         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1300 
1301         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1302             for (int i = 0; i < a.length; i += SPECIES.length()) {
1303                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1304                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1305                 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1306             }
1307         }
1308 
1309         assertArraysEquals(a, b, r, mask, Int512VectorTests::AND);
1310     }
1311 
1312 
1313     static int AND_NOT(int a, int b) {
1314         return (int)(a & ~b);
1315     }
1316 
1317     @Test(dataProvider = "intBinaryOpProvider")
1318     static void AND_NOTInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1319         int[] a = fa.apply(SPECIES.length());
1320         int[] b = fb.apply(SPECIES.length());
1321         int[] r = fr.apply(SPECIES.length());
1322 
1323         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1324             for (int i = 0; i < a.length; i += SPECIES.length()) {
1325                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1326                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1327                 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
1328             }
1329         }
1330 
1331         assertArraysEquals(a, b, r, Int512VectorTests::AND_NOT);
1332     }
1333 
1334 
1335 
1336     @Test(dataProvider = "intBinaryOpMaskProvider")
1337     static void AND_NOTInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1338                                           IntFunction<boolean[]> fm) {
1339         int[] a = fa.apply(SPECIES.length());
1340         int[] b = fb.apply(SPECIES.length());
1341         int[] r = fr.apply(SPECIES.length());
1342         boolean[] mask = fm.apply(SPECIES.length());
1343         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1344 
1345         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1346             for (int i = 0; i < a.length; i += SPECIES.length()) {
1347                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1348                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1349                 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
1350             }
1351         }
1352 
1353         assertArraysEquals(a, b, r, mask, Int512VectorTests::AND_NOT);
1354     }
1355 
1356 
1357     static int OR(int a, int b) {
1358         return (int)(a | b);
1359     }
1360 
1361     @Test(dataProvider = "intBinaryOpProvider")
1362     static void ORInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1363         int[] a = fa.apply(SPECIES.length());
1364         int[] b = fb.apply(SPECIES.length());
1365         int[] r = fr.apply(SPECIES.length());
1366 
1367         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1368             for (int i = 0; i < a.length; i += SPECIES.length()) {
1369                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1370                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1371                 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
1372             }
1373         }
1374 
1375         assertArraysEquals(a, b, r, Int512VectorTests::OR);
1376     }
1377 
1378 
1379 
1380     @Test(dataProvider = "intBinaryOpMaskProvider")
1381     static void ORInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1382                                           IntFunction<boolean[]> fm) {
1383         int[] a = fa.apply(SPECIES.length());
1384         int[] b = fb.apply(SPECIES.length());
1385         int[] r = fr.apply(SPECIES.length());
1386         boolean[] mask = fm.apply(SPECIES.length());
1387         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1388 
1389         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1390             for (int i = 0; i < a.length; i += SPECIES.length()) {
1391                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1392                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1393                 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
1394             }
1395         }
1396 
1397         assertArraysEquals(a, b, r, mask, Int512VectorTests::OR);
1398     }
1399 
1400 
1401     static int XOR(int a, int b) {
1402         return (int)(a ^ b);
1403     }
1404 
1405     @Test(dataProvider = "intBinaryOpProvider")
1406     static void XORInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1407         int[] a = fa.apply(SPECIES.length());
1408         int[] b = fb.apply(SPECIES.length());
1409         int[] r = fr.apply(SPECIES.length());
1410 
1411         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1412             for (int i = 0; i < a.length; i += SPECIES.length()) {
1413                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1414                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1415                 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
1416             }
1417         }
1418 
1419         assertArraysEquals(a, b, r, Int512VectorTests::XOR);
1420     }
1421 
1422 
1423 
1424     @Test(dataProvider = "intBinaryOpMaskProvider")
1425     static void XORInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1426                                           IntFunction<boolean[]> fm) {
1427         int[] a = fa.apply(SPECIES.length());
1428         int[] b = fb.apply(SPECIES.length());
1429         int[] r = fr.apply(SPECIES.length());
1430         boolean[] mask = fm.apply(SPECIES.length());
1431         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1432 
1433         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1434             for (int i = 0; i < a.length; i += SPECIES.length()) {
1435                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1436                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1437                 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
1438             }
1439         }
1440 
1441         assertArraysEquals(a, b, r, mask, Int512VectorTests::XOR);
1442     }
1443 
1444 
1445     static int LSHL(int a, int b) {
1446         return (int)((a << b));
1447     }
1448 
1449     @Test(dataProvider = "intBinaryOpProvider")
1450     static void LSHLInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1451         int[] a = fa.apply(SPECIES.length());
1452         int[] b = fb.apply(SPECIES.length());
1453         int[] r = fr.apply(SPECIES.length());
1454 
1455         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1456             for (int i = 0; i < a.length; i += SPECIES.length()) {
1457                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1458                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1459                 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
1460             }
1461         }
1462 
1463         assertArraysEquals(a, b, r, Int512VectorTests::LSHL);
1464     }
1465 
1466 
1467 
1468     @Test(dataProvider = "intBinaryOpMaskProvider")
1469     static void LSHLInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1470                                           IntFunction<boolean[]> fm) {
1471         int[] a = fa.apply(SPECIES.length());
1472         int[] b = fb.apply(SPECIES.length());
1473         int[] r = fr.apply(SPECIES.length());
1474         boolean[] mask = fm.apply(SPECIES.length());
1475         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1476 
1477         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1478             for (int i = 0; i < a.length; i += SPECIES.length()) {
1479                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1480                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1481                 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
1482             }
1483         }
1484 
1485         assertArraysEquals(a, b, r, mask, Int512VectorTests::LSHL);
1486     }
1487 
1488 
1489 
1490 
1491 
1492 
1493     static int ASHR(int a, int b) {
1494         return (int)((a >> b));
1495     }
1496 
1497     @Test(dataProvider = "intBinaryOpProvider")
1498     static void ASHRInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1499         int[] a = fa.apply(SPECIES.length());
1500         int[] b = fb.apply(SPECIES.length());
1501         int[] r = fr.apply(SPECIES.length());
1502 
1503         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1504             for (int i = 0; i < a.length; i += SPECIES.length()) {
1505                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1506                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1507                 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
1508             }
1509         }
1510 
1511         assertArraysEquals(a, b, r, Int512VectorTests::ASHR);
1512     }
1513 
1514 
1515 
1516     @Test(dataProvider = "intBinaryOpMaskProvider")
1517     static void ASHRInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1518                                           IntFunction<boolean[]> fm) {
1519         int[] a = fa.apply(SPECIES.length());
1520         int[] b = fb.apply(SPECIES.length());
1521         int[] r = fr.apply(SPECIES.length());
1522         boolean[] mask = fm.apply(SPECIES.length());
1523         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1524 
1525         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1526             for (int i = 0; i < a.length; i += SPECIES.length()) {
1527                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1528                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1529                 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
1530             }
1531         }
1532 
1533         assertArraysEquals(a, b, r, mask, Int512VectorTests::ASHR);
1534     }
1535 
1536 
1537 
1538 
1539 
1540 
1541     static int LSHR(int a, int b) {
1542         return (int)((a >>> b));
1543     }
1544 
1545     @Test(dataProvider = "intBinaryOpProvider")
1546     static void LSHRInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1547         int[] a = fa.apply(SPECIES.length());
1548         int[] b = fb.apply(SPECIES.length());
1549         int[] r = fr.apply(SPECIES.length());
1550 
1551         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1552             for (int i = 0; i < a.length; i += SPECIES.length()) {
1553                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1554                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1555                 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
1556             }
1557         }
1558 
1559         assertArraysEquals(a, b, r, Int512VectorTests::LSHR);
1560     }
1561 
1562 
1563 
1564     @Test(dataProvider = "intBinaryOpMaskProvider")
1565     static void LSHRInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1566                                           IntFunction<boolean[]> fm) {
1567         int[] a = fa.apply(SPECIES.length());
1568         int[] b = fb.apply(SPECIES.length());
1569         int[] r = fr.apply(SPECIES.length());
1570         boolean[] mask = fm.apply(SPECIES.length());
1571         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1572 
1573         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1574             for (int i = 0; i < a.length; i += SPECIES.length()) {
1575                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1576                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1577                 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
1578             }
1579         }
1580 
1581         assertArraysEquals(a, b, r, mask, Int512VectorTests::LSHR);
1582     }
1583 
1584 
1585 
1586 
1587 
1588 
1589     static int LSHL_unary(int a, int b) {
1590         return (int)((a << b));
1591     }
1592 
1593     @Test(dataProvider = "intBinaryOpProvider")
1594     static void LSHLInt512VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1595         int[] a = fa.apply(SPECIES.length());
1596         int[] b = fb.apply(SPECIES.length());
1597         int[] r = fr.apply(SPECIES.length());
1598 
1599         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1600             for (int i = 0; i < a.length; i += SPECIES.length()) {
1601                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1602                 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
1603             }
1604         }
1605 
1606         assertShiftArraysEquals(a, b, r, Int512VectorTests::LSHL_unary);
1607     }
1608 
1609 
1610 
1611     @Test(dataProvider = "intBinaryOpMaskProvider")
1612     static void LSHLInt512VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
1613                                           IntFunction<boolean[]> fm) {
1614         int[] a = fa.apply(SPECIES.length());
1615         int[] b = fb.apply(SPECIES.length());
1616         int[] r = fr.apply(SPECIES.length());
1617         boolean[] mask = fm.apply(SPECIES.length());
1618         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1619 
1620         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1621             for (int i = 0; i < a.length; i += SPECIES.length()) {
1622                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1623                 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
1624             }
1625         }
1626 
1627         assertShiftArraysEquals(a, b, r, mask, Int512VectorTests::LSHL_unary);
1628     }
1629 
1630 
1631 
1632 
1633 
1634 
1635     static int LSHR_unary(int a, int b) {
1636         return (int)((a >>> b));
1637     }
1638 
1639     @Test(dataProvider = "intBinaryOpProvider")
1640     static void LSHRInt512VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1641         int[] a = fa.apply(SPECIES.length());
1642         int[] b = fb.apply(SPECIES.length());
1643         int[] r = fr.apply(SPECIES.length());
1644 
1645         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1646             for (int i = 0; i < a.length; i += SPECIES.length()) {
1647                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1648                 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
1649             }
1650         }
1651 
1652         assertShiftArraysEquals(a, b, r, Int512VectorTests::LSHR_unary);
1653     }
1654 
1655 
1656 
1657     @Test(dataProvider = "intBinaryOpMaskProvider")
1658     static void LSHRInt512VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
1659                                           IntFunction<boolean[]> fm) {
1660         int[] a = fa.apply(SPECIES.length());
1661         int[] b = fb.apply(SPECIES.length());
1662         int[] r = fr.apply(SPECIES.length());
1663         boolean[] mask = fm.apply(SPECIES.length());
1664         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1665 
1666         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1667             for (int i = 0; i < a.length; i += SPECIES.length()) {
1668                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1669                 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
1670             }
1671         }
1672 
1673         assertShiftArraysEquals(a, b, r, mask, Int512VectorTests::LSHR_unary);
1674     }
1675 
1676 
1677 
1678 
1679 
1680 
1681     static int ASHR_unary(int a, int b) {
1682         return (int)((a >> b));
1683     }
1684 
1685     @Test(dataProvider = "intBinaryOpProvider")
1686     static void ASHRInt512VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1687         int[] a = fa.apply(SPECIES.length());
1688         int[] b = fb.apply(SPECIES.length());
1689         int[] r = fr.apply(SPECIES.length());
1690 
1691         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1692             for (int i = 0; i < a.length; i += SPECIES.length()) {
1693                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1694                 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
1695             }
1696         }
1697 
1698         assertShiftArraysEquals(a, b, r, Int512VectorTests::ASHR_unary);
1699     }
1700 
1701 
1702 
1703     @Test(dataProvider = "intBinaryOpMaskProvider")
1704     static void ASHRInt512VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
1705                                           IntFunction<boolean[]> fm) {
1706         int[] a = fa.apply(SPECIES.length());
1707         int[] b = fb.apply(SPECIES.length());
1708         int[] r = fr.apply(SPECIES.length());
1709         boolean[] mask = fm.apply(SPECIES.length());
1710         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1711 
1712         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1713             for (int i = 0; i < a.length; i += SPECIES.length()) {
1714                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1715                 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
1716             }
1717         }
1718 
1719         assertShiftArraysEquals(a, b, r, mask, Int512VectorTests::ASHR_unary);
1720     }
1721 
1722 
1723 
1724 
1725 
1726     static int MIN(int a, int b) {
1727         return (int)(Math.min(a, b));
1728     }
1729 
1730     @Test(dataProvider = "intBinaryOpProvider")
1731     static void MINInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1732         int[] a = fa.apply(SPECIES.length());
1733         int[] b = fb.apply(SPECIES.length());
1734         int[] r = fr.apply(SPECIES.length());
1735 
1736         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1737             for (int i = 0; i < a.length; i += SPECIES.length()) {
1738                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1739                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1740                 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
1741             }
1742         }
1743 
1744         assertArraysEquals(a, b, r, Int512VectorTests::MIN);
1745     }
1746     static int min(int a, int b) {
1747         return (int)(Math.min(a, b));
1748     }
1749 
1750     @Test(dataProvider = "intBinaryOpProvider")
1751     static void minInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1752         int[] a = fa.apply(SPECIES.length());
1753         int[] b = fb.apply(SPECIES.length());
1754         int[] r = fr.apply(SPECIES.length());
1755 
1756         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1757             for (int i = 0; i < a.length; i += SPECIES.length()) {
1758                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1759                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1760                 av.min(bv).intoArray(r, i);
1761             }
1762         }
1763 
1764         assertArraysEquals(a, b, r, Int512VectorTests::min);
1765     }
1766     static int MAX(int a, int b) {
1767         return (int)(Math.max(a, b));
1768     }
1769 
1770     @Test(dataProvider = "intBinaryOpProvider")
1771     static void MAXInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1772         int[] a = fa.apply(SPECIES.length());
1773         int[] b = fb.apply(SPECIES.length());
1774         int[] r = fr.apply(SPECIES.length());
1775 
1776         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1777             for (int i = 0; i < a.length; i += SPECIES.length()) {
1778                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1779                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1780                 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
1781             }
1782         }
1783 
1784         assertArraysEquals(a, b, r, Int512VectorTests::MAX);
1785     }
1786     static int max(int a, int b) {
1787         return (int)(Math.max(a, b));
1788     }
1789 
1790     @Test(dataProvider = "intBinaryOpProvider")
1791     static void maxInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1792         int[] a = fa.apply(SPECIES.length());
1793         int[] b = fb.apply(SPECIES.length());
1794         int[] r = fr.apply(SPECIES.length());
1795 
1796         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1797             for (int i = 0; i < a.length; i += SPECIES.length()) {
1798                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1799                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1800                 av.max(bv).intoArray(r, i);
1801             }
1802         }
1803 
1804         assertArraysEquals(a, b, r, Int512VectorTests::max);
1805     }
1806 
1807     static int AND(int[] a, int idx) {
1808         int res = -1;
1809         for (int i = idx; i < (idx + SPECIES.length()); i++) {
1810             res &= a[i];
1811         }
1812 
1813         return res;
1814     }
1815 
1816     static int AND(int[] a) {
1817         int res = -1;
1818         for (int i = 0; i < a.length; i += SPECIES.length()) {
1819             int tmp = -1;
1820             for (int j = 0; j < SPECIES.length(); j++) {
1821                 tmp &= a[i + j];
1822             }
1823             res &= tmp;
1824         }
1825 
1826         return res;
1827     }
1828 
1829 
1830     @Test(dataProvider = "intUnaryOpProvider")
1831     static void ANDInt512VectorTests(IntFunction<int[]> fa) {
1832         int[] a = fa.apply(SPECIES.length());
1833         int[] r = fr.apply(SPECIES.length());
1834         int ra = -1;
1835 
1836         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1837             for (int i = 0; i < a.length; i += SPECIES.length()) {
1838                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1839                 r[i] = av.reduceLanes(VectorOperators.AND);
1840             }
1841         }
1842 
1843         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1844             ra = -1;
1845             for (int i = 0; i < a.length; i += SPECIES.length()) {
1846                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1847                 ra &= av.reduceLanes(VectorOperators.AND);
1848             }
1849         }
1850 
1851         assertReductionArraysEquals(a, r, ra, Int512VectorTests::AND, Int512VectorTests::AND);
1852     }
1853 
1854 
1855     static int ANDMasked(int[] a, int idx, boolean[] mask) {
1856         int res = -1;
1857         for (int i = idx; i < (idx + SPECIES.length()); i++) {
1858             if(mask[i % SPECIES.length()])
1859                 res &= a[i];
1860         }
1861 
1862         return res;
1863     }
1864 
1865     static int ANDMasked(int[] a, boolean[] mask) {
1866         int res = -1;
1867         for (int i = 0; i < a.length; i += SPECIES.length()) {
1868             int tmp = -1;
1869             for (int j = 0; j < SPECIES.length(); j++) {
1870                 if(mask[(i + j) % SPECIES.length()])
1871                     tmp &= a[i + j];
1872             }
1873             res &= tmp;
1874         }
1875 
1876         return res;
1877     }
1878 
1879 
1880     @Test(dataProvider = "intUnaryOpMaskProvider")
1881     static void ANDInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
1882         int[] a = fa.apply(SPECIES.length());
1883         int[] r = fr.apply(SPECIES.length());
1884         boolean[] mask = fm.apply(SPECIES.length());
1885         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1886         int ra = -1;
1887 
1888         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1889             for (int i = 0; i < a.length; i += SPECIES.length()) {
1890                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1891                 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
1892             }
1893         }
1894 
1895         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1896             ra = -1;
1897             for (int i = 0; i < a.length; i += SPECIES.length()) {
1898                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1899                 ra &= av.reduceLanes(VectorOperators.AND, vmask);
1900             }
1901         }
1902 
1903         assertReductionArraysEqualsMasked(a, r, ra, mask, Int512VectorTests::ANDMasked, Int512VectorTests::ANDMasked);
1904     }
1905 
1906 
1907     static int OR(int[] a, int idx) {
1908         int res = 0;
1909         for (int i = idx; i < (idx + SPECIES.length()); i++) {
1910             res |= a[i];
1911         }
1912 
1913         return res;
1914     }
1915 
1916     static int OR(int[] a) {
1917         int res = 0;
1918         for (int i = 0; i < a.length; i += SPECIES.length()) {
1919             int tmp = 0;
1920             for (int j = 0; j < SPECIES.length(); j++) {
1921                 tmp |= a[i + j];
1922             }
1923             res |= tmp;
1924         }
1925 
1926         return res;
1927     }
1928 
1929 
1930     @Test(dataProvider = "intUnaryOpProvider")
1931     static void ORInt512VectorTests(IntFunction<int[]> fa) {
1932         int[] a = fa.apply(SPECIES.length());
1933         int[] r = fr.apply(SPECIES.length());
1934         int ra = 0;
1935 
1936         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1937             for (int i = 0; i < a.length; i += SPECIES.length()) {
1938                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1939                 r[i] = av.reduceLanes(VectorOperators.OR);
1940             }
1941         }
1942 
1943         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1944             ra = 0;
1945             for (int i = 0; i < a.length; i += SPECIES.length()) {
1946                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1947                 ra |= av.reduceLanes(VectorOperators.OR);
1948             }
1949         }
1950 
1951         assertReductionArraysEquals(a, r, ra, Int512VectorTests::OR, Int512VectorTests::OR);
1952     }
1953 
1954 
1955     static int ORMasked(int[] a, int idx, boolean[] mask) {
1956         int res = 0;
1957         for (int i = idx; i < (idx + SPECIES.length()); i++) {
1958             if(mask[i % SPECIES.length()])
1959                 res |= a[i];
1960         }
1961 
1962         return res;
1963     }
1964 
1965     static int ORMasked(int[] a, boolean[] mask) {
1966         int res = 0;
1967         for (int i = 0; i < a.length; i += SPECIES.length()) {
1968             int tmp = 0;
1969             for (int j = 0; j < SPECIES.length(); j++) {
1970                 if(mask[(i + j) % SPECIES.length()])
1971                     tmp |= a[i + j];
1972             }
1973             res |= tmp;
1974         }
1975 
1976         return res;
1977     }
1978 
1979 
1980     @Test(dataProvider = "intUnaryOpMaskProvider")
1981     static void ORInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
1982         int[] a = fa.apply(SPECIES.length());
1983         int[] r = fr.apply(SPECIES.length());
1984         boolean[] mask = fm.apply(SPECIES.length());
1985         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1986         int ra = 0;
1987 
1988         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1989             for (int i = 0; i < a.length; i += SPECIES.length()) {
1990                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1991                 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
1992             }
1993         }
1994 
1995         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1996             ra = 0;
1997             for (int i = 0; i < a.length; i += SPECIES.length()) {
1998                 IntVector av = IntVector.fromArray(SPECIES, a, i);
1999                 ra |= av.reduceLanes(VectorOperators.OR, vmask);
2000             }
2001         }
2002 
2003         assertReductionArraysEqualsMasked(a, r, ra, mask, Int512VectorTests::ORMasked, Int512VectorTests::ORMasked);
2004     }
2005 
2006 
2007     static int XOR(int[] a, int idx) {
2008         int res = 0;
2009         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2010             res ^= a[i];
2011         }
2012 
2013         return res;
2014     }
2015 
2016     static int XOR(int[] a) {
2017         int res = 0;
2018         for (int i = 0; i < a.length; i += SPECIES.length()) {
2019             int tmp = 0;
2020             for (int j = 0; j < SPECIES.length(); j++) {
2021                 tmp ^= a[i + j];
2022             }
2023             res ^= tmp;
2024         }
2025 
2026         return res;
2027     }
2028 
2029 
2030     @Test(dataProvider = "intUnaryOpProvider")
2031     static void XORInt512VectorTests(IntFunction<int[]> fa) {
2032         int[] a = fa.apply(SPECIES.length());
2033         int[] r = fr.apply(SPECIES.length());
2034         int ra = 0;
2035 
2036         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2037             for (int i = 0; i < a.length; i += SPECIES.length()) {
2038                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2039                 r[i] = av.reduceLanes(VectorOperators.XOR);
2040             }
2041         }
2042 
2043         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2044             ra = 0;
2045             for (int i = 0; i < a.length; i += SPECIES.length()) {
2046                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2047                 ra ^= av.reduceLanes(VectorOperators.XOR);
2048             }
2049         }
2050 
2051         assertReductionArraysEquals(a, r, ra, Int512VectorTests::XOR, Int512VectorTests::XOR);
2052     }
2053 
2054 
2055     static int XORMasked(int[] a, int idx, boolean[] mask) {
2056         int res = 0;
2057         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2058             if(mask[i % SPECIES.length()])
2059                 res ^= a[i];
2060         }
2061 
2062         return res;
2063     }
2064 
2065     static int XORMasked(int[] a, boolean[] mask) {
2066         int res = 0;
2067         for (int i = 0; i < a.length; i += SPECIES.length()) {
2068             int tmp = 0;
2069             for (int j = 0; j < SPECIES.length(); j++) {
2070                 if(mask[(i + j) % SPECIES.length()])
2071                     tmp ^= a[i + j];
2072             }
2073             res ^= tmp;
2074         }
2075 
2076         return res;
2077     }
2078 
2079 
2080     @Test(dataProvider = "intUnaryOpMaskProvider")
2081     static void XORInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2082         int[] a = fa.apply(SPECIES.length());
2083         int[] r = fr.apply(SPECIES.length());
2084         boolean[] mask = fm.apply(SPECIES.length());
2085         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2086         int ra = 0;
2087 
2088         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2089             for (int i = 0; i < a.length; i += SPECIES.length()) {
2090                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2091                 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
2092             }
2093         }
2094 
2095         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2096             ra = 0;
2097             for (int i = 0; i < a.length; i += SPECIES.length()) {
2098                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2099                 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
2100             }
2101         }
2102 
2103         assertReductionArraysEqualsMasked(a, r, ra, mask, Int512VectorTests::XORMasked, Int512VectorTests::XORMasked);
2104     }
2105 
2106     static int ADD(int[] a, int idx) {
2107         int res = 0;
2108         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2109             res += a[i];
2110         }
2111 
2112         return res;
2113     }
2114 
2115     static int ADD(int[] a) {
2116         int res = 0;
2117         for (int i = 0; i < a.length; i += SPECIES.length()) {
2118             int tmp = 0;
2119             for (int j = 0; j < SPECIES.length(); j++) {
2120                 tmp += a[i + j];
2121             }
2122             res += tmp;
2123         }
2124 
2125         return res;
2126     }
2127     @Test(dataProvider = "intUnaryOpProvider")
2128     static void ADDInt512VectorTests(IntFunction<int[]> fa) {
2129         int[] a = fa.apply(SPECIES.length());
2130         int[] r = fr.apply(SPECIES.length());
2131         int ra = 0;
2132 
2133         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2134             for (int i = 0; i < a.length; i += SPECIES.length()) {
2135                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2136                 r[i] = av.reduceLanes(VectorOperators.ADD);
2137             }
2138         }
2139 
2140         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2141             ra = 0;
2142             for (int i = 0; i < a.length; i += SPECIES.length()) {
2143                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2144                 ra += av.reduceLanes(VectorOperators.ADD);
2145             }
2146         }
2147 
2148         assertReductionArraysEquals(a, r, ra, Int512VectorTests::ADD, Int512VectorTests::ADD);
2149     }
2150     static int ADDMasked(int[] a, int idx, boolean[] mask) {
2151         int res = 0;
2152         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2153             if(mask[i % SPECIES.length()])
2154                 res += a[i];
2155         }
2156 
2157         return res;
2158     }
2159 
2160     static int ADDMasked(int[] a, boolean[] mask) {
2161         int res = 0;
2162         for (int i = 0; i < a.length; i += SPECIES.length()) {
2163             int tmp = 0;
2164             for (int j = 0; j < SPECIES.length(); j++) {
2165                 if(mask[(i + j) % SPECIES.length()])
2166                     tmp += a[i + j];
2167             }
2168             res += tmp;
2169         }
2170 
2171         return res;
2172     }
2173     @Test(dataProvider = "intUnaryOpMaskProvider")
2174     static void ADDInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2175         int[] a = fa.apply(SPECIES.length());
2176         int[] r = fr.apply(SPECIES.length());
2177         boolean[] mask = fm.apply(SPECIES.length());
2178         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2179         int ra = 0;
2180 
2181         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2182             for (int i = 0; i < a.length; i += SPECIES.length()) {
2183                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2184                 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
2185             }
2186         }
2187 
2188         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2189             ra = 0;
2190             for (int i = 0; i < a.length; i += SPECIES.length()) {
2191                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2192                 ra += av.reduceLanes(VectorOperators.ADD, vmask);
2193             }
2194         }
2195 
2196         assertReductionArraysEqualsMasked(a, r, ra, mask, Int512VectorTests::ADDMasked, Int512VectorTests::ADDMasked);
2197     }
2198     static int MUL(int[] a, int idx) {
2199         int res = 1;
2200         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2201             res *= a[i];
2202         }
2203 
2204         return res;
2205     }
2206 
2207     static int MUL(int[] a) {
2208         int res = 1;
2209         for (int i = 0; i < a.length; i += SPECIES.length()) {
2210             int tmp = 1;
2211             for (int j = 0; j < SPECIES.length(); j++) {
2212                 tmp *= a[i + j];
2213             }
2214             res *= tmp;
2215         }
2216 
2217         return res;
2218     }
2219     @Test(dataProvider = "intUnaryOpProvider")
2220     static void MULInt512VectorTests(IntFunction<int[]> fa) {
2221         int[] a = fa.apply(SPECIES.length());
2222         int[] r = fr.apply(SPECIES.length());
2223         int ra = 1;
2224 
2225         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2226             for (int i = 0; i < a.length; i += SPECIES.length()) {
2227                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2228                 r[i] = av.reduceLanes(VectorOperators.MUL);
2229             }
2230         }
2231 
2232         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2233             ra = 1;
2234             for (int i = 0; i < a.length; i += SPECIES.length()) {
2235                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2236                 ra *= av.reduceLanes(VectorOperators.MUL);
2237             }
2238         }
2239 
2240         assertReductionArraysEquals(a, r, ra, Int512VectorTests::MUL, Int512VectorTests::MUL);
2241     }
2242     static int MULMasked(int[] a, int idx, boolean[] mask) {
2243         int res = 1;
2244         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2245             if(mask[i % SPECIES.length()])
2246                 res *= a[i];
2247         }
2248 
2249         return res;
2250     }
2251 
2252     static int MULMasked(int[] a, boolean[] mask) {
2253         int res = 1;
2254         for (int i = 0; i < a.length; i += SPECIES.length()) {
2255             int tmp = 1;
2256             for (int j = 0; j < SPECIES.length(); j++) {
2257                 if(mask[(i + j) % SPECIES.length()])
2258                     tmp *= a[i + j];
2259             }
2260             res *= tmp;
2261         }
2262 
2263         return res;
2264     }
2265     @Test(dataProvider = "intUnaryOpMaskProvider")
2266     static void MULInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2267         int[] a = fa.apply(SPECIES.length());
2268         int[] r = fr.apply(SPECIES.length());
2269         boolean[] mask = fm.apply(SPECIES.length());
2270         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2271         int ra = 1;
2272 
2273         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2274             for (int i = 0; i < a.length; i += SPECIES.length()) {
2275                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2276                 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
2277             }
2278         }
2279 
2280         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2281             ra = 1;
2282             for (int i = 0; i < a.length; i += SPECIES.length()) {
2283                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2284                 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
2285             }
2286         }
2287 
2288         assertReductionArraysEqualsMasked(a, r, ra, mask, Int512VectorTests::MULMasked, Int512VectorTests::MULMasked);
2289     }
2290     static int MIN(int[] a, int idx) {
2291         int res = Integer.MAX_VALUE;
2292         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2293             res = (int)Math.min(res, a[i]);
2294         }
2295 
2296         return res;
2297     }
2298 
2299     static int MIN(int[] a) {
2300         int res = Integer.MAX_VALUE;
2301         for (int i = 0; i < a.length; i++) {
2302             res = (int)Math.min(res, a[i]);
2303         }
2304 
2305         return res;
2306     }
2307     @Test(dataProvider = "intUnaryOpProvider")
2308     static void MINInt512VectorTests(IntFunction<int[]> fa) {
2309         int[] a = fa.apply(SPECIES.length());
2310         int[] r = fr.apply(SPECIES.length());
2311         int ra = Integer.MAX_VALUE;
2312 
2313         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2314             for (int i = 0; i < a.length; i += SPECIES.length()) {
2315                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2316                 r[i] = av.reduceLanes(VectorOperators.MIN);
2317             }
2318         }
2319 
2320         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2321             ra = Integer.MAX_VALUE;
2322             for (int i = 0; i < a.length; i += SPECIES.length()) {
2323                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2324                 ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN));
2325             }
2326         }
2327 
2328         assertReductionArraysEquals(a, r, ra, Int512VectorTests::MIN, Int512VectorTests::MIN);
2329     }
2330     static int MINMasked(int[] a, int idx, boolean[] mask) {
2331         int res = Integer.MAX_VALUE;
2332         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2333             if(mask[i % SPECIES.length()])
2334                 res = (int)Math.min(res, a[i]);
2335         }
2336 
2337         return res;
2338     }
2339 
2340     static int MINMasked(int[] a, boolean[] mask) {
2341         int res = Integer.MAX_VALUE;
2342         for (int i = 0; i < a.length; i++) {
2343             if(mask[i % SPECIES.length()])
2344                 res = (int)Math.min(res, a[i]);
2345         }
2346 
2347         return res;
2348     }
2349     @Test(dataProvider = "intUnaryOpMaskProvider")
2350     static void MINInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2351         int[] a = fa.apply(SPECIES.length());
2352         int[] r = fr.apply(SPECIES.length());
2353         boolean[] mask = fm.apply(SPECIES.length());
2354         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2355         int ra = Integer.MAX_VALUE;
2356 
2357         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2358             for (int i = 0; i < a.length; i += SPECIES.length()) {
2359                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2360                 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
2361             }
2362         }
2363 
2364         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2365             ra = Integer.MAX_VALUE;
2366             for (int i = 0; i < a.length; i += SPECIES.length()) {
2367                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2368                 ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
2369             }
2370         }
2371 
2372         assertReductionArraysEqualsMasked(a, r, ra, mask, Int512VectorTests::MINMasked, Int512VectorTests::MINMasked);
2373     }
2374     static int MAX(int[] a, int idx) {
2375         int res = Integer.MIN_VALUE;
2376         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2377             res = (int)Math.max(res, a[i]);
2378         }
2379 
2380         return res;
2381     }
2382 
2383     static int MAX(int[] a) {
2384         int res = Integer.MIN_VALUE;
2385         for (int i = 0; i < a.length; i++) {
2386             res = (int)Math.max(res, a[i]);
2387         }
2388 
2389         return res;
2390     }
2391     @Test(dataProvider = "intUnaryOpProvider")
2392     static void MAXInt512VectorTests(IntFunction<int[]> fa) {
2393         int[] a = fa.apply(SPECIES.length());
2394         int[] r = fr.apply(SPECIES.length());
2395         int ra = Integer.MIN_VALUE;
2396 
2397         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2398             for (int i = 0; i < a.length; i += SPECIES.length()) {
2399                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2400                 r[i] = av.reduceLanes(VectorOperators.MAX);
2401             }
2402         }
2403 
2404         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2405             ra = Integer.MIN_VALUE;
2406             for (int i = 0; i < a.length; i += SPECIES.length()) {
2407                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2408                 ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX));
2409             }
2410         }
2411 
2412         assertReductionArraysEquals(a, r, ra, Int512VectorTests::MAX, Int512VectorTests::MAX);
2413     }
2414     static int MAXMasked(int[] a, int idx, boolean[] mask) {
2415         int res = Integer.MIN_VALUE;
2416         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2417             if(mask[i % SPECIES.length()])
2418                 res = (int)Math.max(res, a[i]);
2419         }
2420 
2421         return res;
2422     }
2423 
2424     static int MAXMasked(int[] a, boolean[] mask) {
2425         int res = Integer.MIN_VALUE;
2426         for (int i = 0; i < a.length; i++) {
2427             if(mask[i % SPECIES.length()])
2428                 res = (int)Math.max(res, a[i]);
2429         }
2430 
2431         return res;
2432     }
2433     @Test(dataProvider = "intUnaryOpMaskProvider")
2434     static void MAXInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2435         int[] a = fa.apply(SPECIES.length());
2436         int[] r = fr.apply(SPECIES.length());
2437         boolean[] mask = fm.apply(SPECIES.length());
2438         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2439         int ra = Integer.MIN_VALUE;
2440 
2441         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2442             for (int i = 0; i < a.length; i += SPECIES.length()) {
2443                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2444                 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
2445             }
2446         }
2447 
2448         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2449             ra = Integer.MIN_VALUE;
2450             for (int i = 0; i < a.length; i += SPECIES.length()) {
2451                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2452                 ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
2453             }
2454         }
2455 
2456         assertReductionArraysEqualsMasked(a, r, ra, mask, Int512VectorTests::MAXMasked, Int512VectorTests::MAXMasked);
2457     }
2458 
2459     static boolean anyTrue(boolean[] a, int idx) {
2460         boolean res = false;
2461         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2462             res |= a[i];
2463         }
2464 
2465         return res;
2466     }
2467 
2468 
2469     @Test(dataProvider = "boolUnaryOpProvider")
2470     static void anyTrueInt512VectorTests(IntFunction<boolean[]> fm) {
2471         boolean[] mask = fm.apply(SPECIES.length());
2472         boolean[] r = fmr.apply(SPECIES.length());
2473 
2474         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2475             for (int i = 0; i < mask.length; i += SPECIES.length()) {
2476                 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
2477                 r[i] = vmask.anyTrue();
2478             }
2479         }
2480 
2481         assertReductionBoolArraysEquals(mask, r, Int512VectorTests::anyTrue);
2482     }
2483 
2484 
2485     static boolean allTrue(boolean[] a, int idx) {
2486         boolean res = true;
2487         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2488             res &= a[i];
2489         }
2490 
2491         return res;
2492     }
2493 
2494 
2495     @Test(dataProvider = "boolUnaryOpProvider")
2496     static void allTrueInt512VectorTests(IntFunction<boolean[]> fm) {
2497         boolean[] mask = fm.apply(SPECIES.length());
2498         boolean[] r = fmr.apply(SPECIES.length());
2499 
2500         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2501             for (int i = 0; i < mask.length; i += SPECIES.length()) {
2502                 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
2503                 r[i] = vmask.allTrue();
2504             }
2505         }
2506 
2507         assertReductionBoolArraysEquals(mask, r, Int512VectorTests::allTrue);
2508     }
2509 
2510 
2511     @Test(dataProvider = "intUnaryOpProvider")
2512     static void withInt512VectorTests(IntFunction<int []> fa) {
2513         int[] a = fa.apply(SPECIES.length());
2514         int[] r = fr.apply(SPECIES.length());
2515 
2516         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2517             for (int i = 0; i < a.length; i += SPECIES.length()) {
2518                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2519                 av.withLane(0, (int)4).intoArray(r, i);
2520             }
2521         }
2522 
2523         assertInsertArraysEquals(a, r, (int)4, 0);
2524     }
2525     static boolean testIS_DEFAULT(int a) {
2526         return bits(a)==0;
2527     }
2528 
2529     @Test(dataProvider = "intTestOpProvider")
2530     static void IS_DEFAULTInt512VectorTests(IntFunction<int[]> fa) {
2531         int[] a = fa.apply(SPECIES.length());
2532 
2533         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2534             for (int i = 0; i < a.length; i += SPECIES.length()) {
2535                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2536                 VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT);
2537 
2538                 // Check results as part of computation.
2539                 for (int j = 0; j < SPECIES.length(); j++) {
2540    
2541                  Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
2542                 }
2543             }
2544         }
2545     }
2546 
2547     static boolean testIS_NEGATIVE(int a) {
2548         return bits(a)<0;
2549     }
2550 
2551     @Test(dataProvider = "intTestOpProvider")
2552     static void IS_NEGATIVEInt512VectorTests(IntFunction<int[]> fa) {
2553         int[] a = fa.apply(SPECIES.length());
2554 
2555         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2556             for (int i = 0; i < a.length; i += SPECIES.length()) {
2557                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2558                 VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE);
2559 
2560                 // Check results as part of computation.
2561                 for (int j = 0; j < SPECIES.length(); j++) {
2562    
2563                  Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
2564                 }
2565             }
2566         }
2567     }
2568 
2569 
2570 
2571 
2572 
2573     @Test(dataProvider = "intCompareOpProvider")
2574     static void LTInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2575         int[] a = fa.apply(SPECIES.length());
2576         int[] b = fb.apply(SPECIES.length());
2577 
2578         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2579             for (int i = 0; i < a.length; i += SPECIES.length()) {
2580                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2581                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2582                 VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv);
2583 
2584                 // Check results as part of computation.
2585                 for (int j = 0; j < SPECIES.length(); j++) {
2586                     Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i + j]);
2587                 }
2588             }
2589         }
2590     }
2591 
2592 
2593     @Test(dataProvider = "intCompareOpProvider")
2594     static void ltInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2595         int[] a = fa.apply(SPECIES.length());
2596         int[] b = fb.apply(SPECIES.length());
2597 
2598         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2599             for (int i = 0; i < a.length; i += SPECIES.length()) {
2600                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2601                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2602                 VectorMask<Integer> mv = av.lt(bv);
2603 
2604                 // Check results as part of computation.
2605                 for (int j = 0; j < SPECIES.length(); j++) {
2606                     Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i + j]);
2607                 }
2608             }
2609         }
2610     }
2611 
2612 
2613     @Test(dataProvider = "intCompareOpProvider")
2614     static void GTInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2615         int[] a = fa.apply(SPECIES.length());
2616         int[] b = fb.apply(SPECIES.length());
2617 
2618         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2619             for (int i = 0; i < a.length; i += SPECIES.length()) {
2620                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2621                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2622                 VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv);
2623 
2624                 // Check results as part of computation.
2625                 for (int j = 0; j < SPECIES.length(); j++) {
2626                     Assert.assertEquals(mv.laneIsSet(j), a[i + j] > b[i + j]);
2627                 }
2628             }
2629         }
2630     }
2631 
2632 
2633     @Test(dataProvider = "intCompareOpProvider")
2634     static void EQInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2635         int[] a = fa.apply(SPECIES.length());
2636         int[] b = fb.apply(SPECIES.length());
2637 
2638         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2639             for (int i = 0; i < a.length; i += SPECIES.length()) {
2640                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2641                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2642                 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv);
2643 
2644                 // Check results as part of computation.
2645                 for (int j = 0; j < SPECIES.length(); j++) {
2646                     Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i + j]);
2647                 }
2648             }
2649         }
2650     }
2651 
2652 
2653     @Test(dataProvider = "intCompareOpProvider")
2654     static void eqInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2655         int[] a = fa.apply(SPECIES.length());
2656         int[] b = fb.apply(SPECIES.length());
2657 
2658         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2659             for (int i = 0; i < a.length; i += SPECIES.length()) {
2660                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2661                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2662                 VectorMask<Integer> mv = av.eq(bv);
2663 
2664                 // Check results as part of computation.
2665                 for (int j = 0; j < SPECIES.length(); j++) {
2666                     Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i + j]);
2667                 }
2668             }
2669         }
2670     }
2671 
2672 
2673     @Test(dataProvider = "intCompareOpProvider")
2674     static void NEInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2675         int[] a = fa.apply(SPECIES.length());
2676         int[] b = fb.apply(SPECIES.length());
2677 
2678         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2679             for (int i = 0; i < a.length; i += SPECIES.length()) {
2680                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2681                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2682                 VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv);
2683 
2684                 // Check results as part of computation.
2685                 for (int j = 0; j < SPECIES.length(); j++) {
2686                     Assert.assertEquals(mv.laneIsSet(j), a[i + j] != b[i + j]);
2687                 }
2688             }
2689         }
2690     }
2691 
2692 
2693     @Test(dataProvider = "intCompareOpProvider")
2694     static void LEInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2695         int[] a = fa.apply(SPECIES.length());
2696         int[] b = fb.apply(SPECIES.length());
2697 
2698         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2699             for (int i = 0; i < a.length; i += SPECIES.length()) {
2700                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2701                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2702                 VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv);
2703 
2704                 // Check results as part of computation.
2705                 for (int j = 0; j < SPECIES.length(); j++) {
2706                     Assert.assertEquals(mv.laneIsSet(j), a[i + j] <= b[i + j]);
2707                 }
2708             }
2709         }
2710     }
2711 
2712 
2713     @Test(dataProvider = "intCompareOpProvider")
2714     static void GEInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2715         int[] a = fa.apply(SPECIES.length());
2716         int[] b = fb.apply(SPECIES.length());
2717 
2718         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2719             for (int i = 0; i < a.length; i += SPECIES.length()) {
2720                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2721                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2722                 VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv);
2723 
2724                 // Check results as part of computation.
2725                 for (int j = 0; j < SPECIES.length(); j++) {
2726                     Assert.assertEquals(mv.laneIsSet(j), a[i + j] >= b[i + j]);
2727                 }
2728             }
2729         }
2730     }
2731 
2732 
2733     static int blend(int a, int b, boolean mask) {
2734         return mask ? b : a;
2735     }
2736 
2737     @Test(dataProvider = "intBinaryOpMaskProvider")
2738     static void blendInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
2739                                           IntFunction<boolean[]> fm) {
2740         int[] a = fa.apply(SPECIES.length());
2741         int[] b = fb.apply(SPECIES.length());
2742         int[] r = fr.apply(SPECIES.length());
2743         boolean[] mask = fm.apply(SPECIES.length());
2744         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2745 
2746         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2747             for (int i = 0; i < a.length; i += SPECIES.length()) {
2748                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2749                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2750                 av.blend(bv, vmask).intoArray(r, i);
2751             }
2752         }
2753 
2754         assertArraysEquals(a, b, r, mask, Int512VectorTests::blend);
2755     }
2756 
2757     @Test(dataProvider = "intUnaryOpShuffleProvider")
2758     static void RearrangeInt512VectorTests(IntFunction<int[]> fa,
2759                                            BiFunction<Integer,Integer,int[]> fs) {
2760         int[] a = fa.apply(SPECIES.length());
2761         int[] order = fs.apply(a.length, SPECIES.length());
2762         int[] r = fr.apply(SPECIES.length());
2763 
2764         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2765             for (int i = 0; i < a.length; i += SPECIES.length()) {
2766                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2767                 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
2768             }
2769         }
2770 
2771         assertRearrangeArraysEquals(a, r, order, SPECIES.length());
2772     }
2773 
2774 
2775 
2776 
2777     @Test(dataProvider = "intUnaryOpProvider")
2778     static void getInt512VectorTests(IntFunction<int[]> fa) {
2779         int[] a = fa.apply(SPECIES.length());
2780         int[] r = fr.apply(SPECIES.length());
2781 
2782         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2783             for (int i = 0; i < a.length; i += SPECIES.length()) {
2784                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2785                 int num_lanes = SPECIES.length();
2786                 // Manually unroll because full unroll happens after intrinsification.
2787                 // Unroll is needed because get intrinsic requires for index to be a known constant.
2788                 if (num_lanes == 1) {
2789                     r[i]=av.lane(0);
2790                 } else if (num_lanes == 2) {
2791                     r[i]=av.lane(0);
2792                     r[i+1]=av.lane(1);
2793                 } else if (num_lanes == 4) {
2794                     r[i]=av.lane(0);
2795                     r[i+1]=av.lane(1);
2796                     r[i+2]=av.lane(2);
2797                     r[i+3]=av.lane(3);
2798                 } else if (num_lanes == 8) {
2799                     r[i]=av.lane(0);
2800                     r[i+1]=av.lane(1);
2801                     r[i+2]=av.lane(2);
2802                     r[i+3]=av.lane(3);
2803                     r[i+4]=av.lane(4);
2804                     r[i+5]=av.lane(5);
2805                     r[i+6]=av.lane(6);
2806                     r[i+7]=av.lane(7);
2807                 } else if (num_lanes == 16) {
2808                     r[i]=av.lane(0);
2809                     r[i+1]=av.lane(1);
2810                     r[i+2]=av.lane(2);
2811                     r[i+3]=av.lane(3);
2812                     r[i+4]=av.lane(4);
2813                     r[i+5]=av.lane(5);
2814                     r[i+6]=av.lane(6);
2815                     r[i+7]=av.lane(7);
2816                     r[i+8]=av.lane(8);
2817                     r[i+9]=av.lane(9);
2818                     r[i+10]=av.lane(10);
2819                     r[i+11]=av.lane(11);
2820                     r[i+12]=av.lane(12);
2821                     r[i+13]=av.lane(13);
2822                     r[i+14]=av.lane(14);
2823                     r[i+15]=av.lane(15);
2824                 } else if (num_lanes == 32) {
2825                     r[i]=av.lane(0);
2826                     r[i+1]=av.lane(1);
2827                     r[i+2]=av.lane(2);
2828                     r[i+3]=av.lane(3);
2829                     r[i+4]=av.lane(4);
2830                     r[i+5]=av.lane(5);
2831                     r[i+6]=av.lane(6);
2832                     r[i+7]=av.lane(7);
2833                     r[i+8]=av.lane(8);
2834                     r[i+9]=av.lane(9);
2835                     r[i+10]=av.lane(10);
2836                     r[i+11]=av.lane(11);
2837                     r[i+12]=av.lane(12);
2838                     r[i+13]=av.lane(13);
2839                     r[i+14]=av.lane(14);
2840                     r[i+15]=av.lane(15);
2841                     r[i+16]=av.lane(16);
2842                     r[i+17]=av.lane(17);
2843                     r[i+18]=av.lane(18);
2844                     r[i+19]=av.lane(19);
2845                     r[i+20]=av.lane(20);
2846                     r[i+21]=av.lane(21);
2847                     r[i+22]=av.lane(22);
2848                     r[i+23]=av.lane(23);
2849                     r[i+24]=av.lane(24);
2850                     r[i+25]=av.lane(25);
2851                     r[i+26]=av.lane(26);
2852                     r[i+27]=av.lane(27);
2853                     r[i+28]=av.lane(28);
2854                     r[i+29]=av.lane(29);
2855                     r[i+30]=av.lane(30);
2856                     r[i+31]=av.lane(31);
2857                 } else if (num_lanes == 64) {
2858                     r[i]=av.lane(0);
2859                     r[i+1]=av.lane(1);
2860                     r[i+2]=av.lane(2);
2861                     r[i+3]=av.lane(3);
2862                     r[i+4]=av.lane(4);
2863                     r[i+5]=av.lane(5);
2864                     r[i+6]=av.lane(6);
2865                     r[i+7]=av.lane(7);
2866                     r[i+8]=av.lane(8);
2867                     r[i+9]=av.lane(9);
2868                     r[i+10]=av.lane(10);
2869                     r[i+11]=av.lane(11);
2870                     r[i+12]=av.lane(12);
2871                     r[i+13]=av.lane(13);
2872                     r[i+14]=av.lane(14);
2873                     r[i+15]=av.lane(15);
2874                     r[i+16]=av.lane(16);
2875                     r[i+17]=av.lane(17);
2876                     r[i+18]=av.lane(18);
2877                     r[i+19]=av.lane(19);
2878                     r[i+20]=av.lane(20);
2879                     r[i+21]=av.lane(21);
2880                     r[i+22]=av.lane(22);
2881                     r[i+23]=av.lane(23);
2882                     r[i+24]=av.lane(24);
2883                     r[i+25]=av.lane(25);
2884                     r[i+26]=av.lane(26);
2885                     r[i+27]=av.lane(27);
2886                     r[i+28]=av.lane(28);
2887                     r[i+29]=av.lane(29);
2888                     r[i+30]=av.lane(30);
2889                     r[i+31]=av.lane(31);
2890                     r[i+32]=av.lane(32);
2891                     r[i+33]=av.lane(33);
2892                     r[i+34]=av.lane(34);
2893                     r[i+35]=av.lane(35);
2894                     r[i+36]=av.lane(36);
2895                     r[i+37]=av.lane(37);
2896                     r[i+38]=av.lane(38);
2897                     r[i+39]=av.lane(39);
2898                     r[i+40]=av.lane(40);
2899                     r[i+41]=av.lane(41);
2900                     r[i+42]=av.lane(42);
2901                     r[i+43]=av.lane(43);
2902                     r[i+44]=av.lane(44);
2903                     r[i+45]=av.lane(45);
2904                     r[i+46]=av.lane(46);
2905                     r[i+47]=av.lane(47);
2906                     r[i+48]=av.lane(48);
2907                     r[i+49]=av.lane(49);
2908                     r[i+50]=av.lane(50);
2909                     r[i+51]=av.lane(51);
2910                     r[i+52]=av.lane(52);
2911                     r[i+53]=av.lane(53);
2912                     r[i+54]=av.lane(54);
2913                     r[i+55]=av.lane(55);
2914                     r[i+56]=av.lane(56);
2915                     r[i+57]=av.lane(57);
2916                     r[i+58]=av.lane(58);
2917                     r[i+59]=av.lane(59);
2918                     r[i+60]=av.lane(60);
2919                     r[i+61]=av.lane(61);
2920                     r[i+62]=av.lane(62);
2921                     r[i+63]=av.lane(63);
2922                 } else {
2923                     for (int j = 0; j < SPECIES.length(); j++) {
2924                         r[i+j]=av.lane(j);
2925                     }
2926                 }
2927             }
2928         }
2929 
2930         assertArraysEquals(a, r, Int512VectorTests::get);
2931     }
2932 
2933     @Test(dataProvider = "intUnaryOpProvider")
2934     static void BroadcastInt512VectorTests(IntFunction<int[]> fa) {
2935         int[] a = fa.apply(SPECIES.length());
2936         int[] r = new int[a.length];
2937 
2938         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2939             for (int i = 0; i < a.length; i += SPECIES.length()) {
2940                 IntVector.broadcast(SPECIES, a[i]).intoArray(r, i);
2941             }
2942         }
2943 
2944         assertBroadcastArraysEquals(a, r);
2945     }
2946 
2947 
2948 
2949 
2950 
2951     @Test(dataProvider = "intUnaryOpProvider")
2952     static void ZeroInt512VectorTests(IntFunction<int[]> fa) {
2953         int[] a = fa.apply(SPECIES.length());
2954         int[] r = new int[a.length];
2955 
2956         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2957             for (int i = 0; i < a.length; i += SPECIES.length()) {
2958                 IntVector.zero(SPECIES).intoArray(a, i);
2959             }
2960         }
2961 
2962         Assert.assertEquals(a, r);
2963     }
2964 
2965 
2966 
2967 
2968     static int[] sliceUnary(int[] a, int origin, int idx) {
2969         int[] res = new int[SPECIES.length()];
2970         for (int i = 0; i < SPECIES.length(); i++){
2971             if(i+origin < SPECIES.length())
2972                 res[i] = a[idx+i+origin];
2973             else
2974                 res[i] = (int)0;
2975         }
2976         return res;
2977     }
2978 
2979     @Test(dataProvider = "intUnaryOpProvider")
2980     static void sliceUnaryInt512VectorTests(IntFunction<int[]> fa) {
2981         int[] a = fa.apply(SPECIES.length());
2982         int[] r = new int[a.length];
2983         int origin = (new java.util.Random()).nextInt(SPECIES.length());
2984         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2985             for (int i = 0; i < a.length; i += SPECIES.length()) {
2986                 IntVector av = IntVector.fromArray(SPECIES, a, i);
2987                 av.slice(origin).intoArray(r, i);
2988             }
2989         }
2990 
2991         assertArraysEquals(a, r, origin, Int512VectorTests::sliceUnary);
2992     }
2993     static int[] sliceBinary(int[] a, int[] b, int origin, int idx) {
2994         int[] res = new int[SPECIES.length()];
2995         for (int i = 0, j = 0; i < SPECIES.length(); i++){
2996             if(i+origin < SPECIES.length())
2997                 res[i] = a[idx+i+origin];
2998             else {
2999                 res[i] = b[idx+j];
3000                 j++;
3001             }
3002         }
3003         return res;
3004     }
3005 
3006     @Test(dataProvider = "intBinaryOpProvider")
3007     static void sliceBinaryInt512VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3008         int[] a = fa.apply(SPECIES.length());
3009         int[] b = fb.apply(SPECIES.length());
3010         int[] r = new int[a.length];
3011         int origin = (new java.util.Random()).nextInt(SPECIES.length());
3012         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3013             for (int i = 0; i < a.length; i += SPECIES.length()) {
3014                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3015                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3016                 av.slice(origin, bv).intoArray(r, i);
3017             }
3018         }
3019 
3020         assertArraysEquals(a, b, r, origin, Int512VectorTests::sliceBinary);
3021     }
3022     static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) {
3023         int[] res = new int[SPECIES.length()];
3024         for (int i = 0, j = 0; i < SPECIES.length(); i++){
3025             if(i+origin < SPECIES.length())
3026                 res[i] = mask[i] ? a[idx+i+origin] : (int)0;
3027             else {
3028                 res[i] = mask[i] ? b[idx+j] : (int)0;
3029                 j++;
3030             }
3031         }
3032         return res;
3033     }
3034 
3035     @Test(dataProvider = "intBinaryOpMaskProvider")
3036     static void sliceInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3037     IntFunction<boolean[]> fm) {
3038         int[] a = fa.apply(SPECIES.length());
3039         int[] b = fb.apply(SPECIES.length());
3040         boolean[] mask = fm.apply(SPECIES.length());
3041         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3042 
3043         int[] r = new int[a.length];
3044         int origin = (new java.util.Random()).nextInt(SPECIES.length());
3045         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3046             for (int i = 0; i < a.length; i += SPECIES.length()) {
3047                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3048                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3049                 av.slice(origin, bv, vmask).intoArray(r, i);
3050             }
3051         }
3052 
3053         assertArraysEquals(a, b, r, origin, mask, Int512VectorTests::slice);
3054     }
3055     static int[] unsliceUnary(int[] a, int origin, int idx) {
3056         int[] res = new int[SPECIES.length()];
3057         for (int i = 0, j = 0; i < SPECIES.length(); i++){
3058             if(i < origin)
3059                 res[i] = (int)0;
3060             else {
3061                 res[i] = a[idx+j];
3062                 j++;
3063             }
3064         }
3065         return res;
3066     }
3067 
3068     @Test(dataProvider = "intUnaryOpProvider")
3069     static void unsliceUnaryInt512VectorTests(IntFunction<int[]> fa) {
3070         int[] a = fa.apply(SPECIES.length());
3071         int[] r = new int[a.length];
3072         int origin = (new java.util.Random()).nextInt(SPECIES.length());
3073         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3074             for (int i = 0; i < a.length; i += SPECIES.length()) {
3075                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3076                 av.unslice(origin).intoArray(r, i);
3077             }
3078         }
3079 
3080         assertArraysEquals(a, r, origin, Int512VectorTests::unsliceUnary);
3081     }
3082     static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) {
3083         int[] res = new int[SPECIES.length()];
3084         for (int i = 0, j = 0; i < SPECIES.length(); i++){
3085             if (part == 0) {
3086                 if (i < origin)
3087                     res[i] = b[idx+i];
3088                 else {
3089                     res[i] = a[idx+j];
3090                     j++;
3091                 }
3092             } else if (part == 1) {
3093                 if (i < origin)
3094                     res[i] = a[idx+SPECIES.length()-origin+i];
3095                 else {
3096                     res[i] = b[idx+origin+j];
3097                     j++;
3098                 }
3099             }
3100         }
3101         return res;
3102     }
3103 
3104     @Test(dataProvider = "intBinaryOpProvider")
3105     static void unsliceBinaryInt512VectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3106         int[] a = fa.apply(SPECIES.length());
3107         int[] b = fb.apply(SPECIES.length());
3108         int[] r = new int[a.length];
3109         int origin = (new java.util.Random()).nextInt(SPECIES.length());
3110         int part = (new java.util.Random()).nextInt(2);
3111         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3112             for (int i = 0; i < a.length; i += SPECIES.length()) {
3113                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3114                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3115                 av.unslice(origin, bv, part).intoArray(r, i);
3116             }
3117         }
3118 
3119         assertArraysEquals(a, b, r, origin, part, Int512VectorTests::unsliceBinary);
3120     }
3121     static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) {
3122         int[] res = new int[SPECIES.length()];
3123         for (int i = 0, j = 0; i < SPECIES.length(); i++){
3124             if(i+origin < SPECIES.length())
3125                 res[i] = b[idx+i+origin];
3126             else {
3127                 res[i] = b[idx+j];
3128                 j++;
3129             }
3130         }
3131         for (int i = 0; i < SPECIES.length(); i++){
3132             res[i] = mask[i] ? a[idx+i] : res[i];
3133         }
3134         int[] res1 = new int[SPECIES.length()];
3135         if (part == 0) {
3136             for (int i = 0, j = 0; i < SPECIES.length(); i++){
3137                 if (i < origin)
3138                     res1[i] = b[idx+i];
3139                 else {
3140                    res1[i] = res[j];
3141                    j++;
3142                 }
3143             }
3144         } else if (part == 1) {
3145             for (int i = 0, j = 0; i < SPECIES.length(); i++){
3146                 if (i < origin)
3147                     res1[i] = res[SPECIES.length()-origin+i];
3148                 else {
3149                     res1[i] = b[idx+origin+j];
3150                     j++;
3151                 }
3152             }
3153         }
3154         return res1;
3155     }
3156 
3157     @Test(dataProvider = "intBinaryOpMaskProvider")
3158     static void unsliceInt512VectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3159     IntFunction<boolean[]> fm) {
3160         int[] a = fa.apply(SPECIES.length());
3161         int[] b = fb.apply(SPECIES.length());
3162         boolean[] mask = fm.apply(SPECIES.length());
3163         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3164         int[] r = new int[a.length];
3165         int origin = (new java.util.Random()).nextInt(SPECIES.length());
3166         int part = (new java.util.Random()).nextInt(2);
3167         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3168             for (int i = 0; i < a.length; i += SPECIES.length()) {
3169                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3170                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3171                 av.unslice(origin, bv, part, vmask).intoArray(r, i);
3172             }
3173         }
3174 
3175         assertArraysEquals(a, b, r, origin, part, mask, Int512VectorTests::unslice);
3176     }
3177 
3178 
3179 
3180 
3181 
3182 
3183 
3184 
3185 
3186 
3187 
3188 
3189 
3190 
3191 
3192 
3193 
3194 
3195 
3196 
3197 
3198 
3199     static int BITWISE_BLEND(int a, int b, int c) {
3200         return (int)((a&~(c))|(b&c));
3201     }
3202 
3203 
3204     @Test(dataProvider = "intTernaryOpProvider")
3205     static void BITWISE_BLENDInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
3206         int[] a = fa.apply(SPECIES.length());
3207         int[] b = fb.apply(SPECIES.length());
3208         int[] c = fc.apply(SPECIES.length());
3209         int[] r = fr.apply(SPECIES.length());
3210 
3211         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3212             for (int i = 0; i < a.length; i += SPECIES.length()) {
3213                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3214                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3215                 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3216                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
3217             }
3218         }
3219 
3220         assertArraysEquals(a, b, c, r, Int512VectorTests::BITWISE_BLEND);
3221     }
3222 
3223 
3224     @Test(dataProvider = "intTernaryOpMaskProvider")
3225     static void BITWISE_BLENDInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
3226                                           IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
3227         int[] a = fa.apply(SPECIES.length());
3228         int[] b = fb.apply(SPECIES.length());
3229         int[] c = fc.apply(SPECIES.length());
3230         int[] r = fr.apply(SPECIES.length());
3231         boolean[] mask = fm.apply(SPECIES.length());
3232         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3233 
3234         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3235             for (int i = 0; i < a.length; i += SPECIES.length()) {
3236                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3237                 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3238                 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3239                 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
3240             }
3241         }
3242 
3243         assertArraysEquals(a, b, c, r, mask, Int512VectorTests::BITWISE_BLEND);
3244     }
3245 
3246 
3247     static int NEG(int a) {
3248         return (int)(-((int)a));
3249     }
3250 
3251     @Test(dataProvider = "intUnaryOpProvider")
3252     static void NEGInt512VectorTests(IntFunction<int[]> fa) {
3253         int[] a = fa.apply(SPECIES.length());
3254         int[] r = fr.apply(SPECIES.length());
3255 
3256         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3257             for (int i = 0; i < a.length; i += SPECIES.length()) {
3258                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3259                 av.lanewise(VectorOperators.NEG).intoArray(r, i);
3260             }
3261         }
3262 
3263         assertArraysEquals(a, r, Int512VectorTests::NEG);
3264     }
3265 
3266     @Test(dataProvider = "intUnaryOpMaskProvider")
3267     static void NEGMaskedInt512VectorTests(IntFunction<int[]> fa,
3268                                                 IntFunction<boolean[]> fm) {
3269         int[] a = fa.apply(SPECIES.length());
3270         int[] r = fr.apply(SPECIES.length());
3271         boolean[] mask = fm.apply(SPECIES.length());
3272         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3273 
3274         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3275             for (int i = 0; i < a.length; i += SPECIES.length()) {
3276                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3277                 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
3278             }
3279         }
3280 
3281         assertArraysEquals(a, r, mask, Int512VectorTests::NEG);
3282     }
3283 
3284     static int ABS(int a) {
3285         return (int)(Math.abs((int)a));
3286     }
3287 
3288     static int abs(int a) {
3289         return (int)(Math.abs((int)a));
3290     }
3291 
3292     @Test(dataProvider = "intUnaryOpProvider")
3293     static void ABSInt512VectorTests(IntFunction<int[]> fa) {
3294         int[] a = fa.apply(SPECIES.length());
3295         int[] r = fr.apply(SPECIES.length());
3296 
3297         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3298             for (int i = 0; i < a.length; i += SPECIES.length()) {
3299                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3300                 av.lanewise(VectorOperators.ABS).intoArray(r, i);
3301             }
3302         }
3303 
3304         assertArraysEquals(a, r, Int512VectorTests::ABS);
3305     }
3306 
3307     @Test(dataProvider = "intUnaryOpProvider")
3308     static void absInt512VectorTests(IntFunction<int[]> fa) {
3309         int[] a = fa.apply(SPECIES.length());
3310         int[] r = fr.apply(SPECIES.length());
3311 
3312         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3313             for (int i = 0; i < a.length; i += SPECIES.length()) {
3314                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3315                 av.abs().intoArray(r, i);
3316             }
3317         }
3318 
3319         assertArraysEquals(a, r, Int512VectorTests::abs);
3320     }
3321 
3322     @Test(dataProvider = "intUnaryOpMaskProvider")
3323     static void ABSMaskedInt512VectorTests(IntFunction<int[]> fa,
3324                                                 IntFunction<boolean[]> fm) {
3325         int[] a = fa.apply(SPECIES.length());
3326         int[] r = fr.apply(SPECIES.length());
3327         boolean[] mask = fm.apply(SPECIES.length());
3328         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3329 
3330         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3331             for (int i = 0; i < a.length; i += SPECIES.length()) {
3332                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3333                 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
3334             }
3335         }
3336 
3337         assertArraysEquals(a, r, mask, Int512VectorTests::ABS);
3338     }
3339 
3340 
3341     static int NOT(int a) {
3342         return (int)(~((int)a));
3343     }
3344 
3345 
3346 
3347     @Test(dataProvider = "intUnaryOpProvider")
3348     static void NOTInt512VectorTests(IntFunction<int[]> fa) {
3349         int[] a = fa.apply(SPECIES.length());
3350         int[] r = fr.apply(SPECIES.length());
3351 
3352         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3353             for (int i = 0; i < a.length; i += SPECIES.length()) {
3354                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3355                 av.lanewise(VectorOperators.NOT).intoArray(r, i);
3356             }
3357         }
3358 
3359         assertArraysEquals(a, r, Int512VectorTests::NOT);
3360     }
3361 
3362 
3363 
3364     @Test(dataProvider = "intUnaryOpMaskProvider")
3365     static void NOTMaskedInt512VectorTests(IntFunction<int[]> fa,
3366                                                 IntFunction<boolean[]> fm) {
3367         int[] a = fa.apply(SPECIES.length());
3368         int[] r = fr.apply(SPECIES.length());
3369         boolean[] mask = fm.apply(SPECIES.length());
3370         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3371 
3372         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3373             for (int i = 0; i < a.length; i += SPECIES.length()) {
3374                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3375                 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
3376             }
3377         }
3378 
3379         assertArraysEquals(a, r, mask, Int512VectorTests::NOT);
3380     }
3381 
3382 
3383 
3384     static int ZOMO(int a) {
3385         return (int)((a==0?0:-1));
3386     }
3387 
3388 
3389 
3390     @Test(dataProvider = "intUnaryOpProvider")
3391     static void ZOMOInt512VectorTests(IntFunction<int[]> fa) {
3392         int[] a = fa.apply(SPECIES.length());
3393         int[] r = fr.apply(SPECIES.length());
3394 
3395         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3396             for (int i = 0; i < a.length; i += SPECIES.length()) {
3397                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3398                 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
3399             }
3400         }
3401 
3402         assertArraysEquals(a, r, Int512VectorTests::ZOMO);
3403     }
3404 
3405 
3406 
3407     @Test(dataProvider = "intUnaryOpMaskProvider")
3408     static void ZOMOMaskedInt512VectorTests(IntFunction<int[]> fa,
3409                                                 IntFunction<boolean[]> fm) {
3410         int[] a = fa.apply(SPECIES.length());
3411         int[] r = fr.apply(SPECIES.length());
3412         boolean[] mask = fm.apply(SPECIES.length());
3413         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3414 
3415         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3416             for (int i = 0; i < a.length; i += SPECIES.length()) {
3417                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3418                 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
3419             }
3420         }
3421 
3422         assertArraysEquals(a, r, mask, Int512VectorTests::ZOMO);
3423     }
3424 
3425 
3426 
3427 
3428     static int[] gather(int a[], int ix, int[] b, int iy) {
3429         int[] res = new int[SPECIES.length()];
3430         for (int i = 0; i < SPECIES.length(); i++) {
3431             int bi = iy + i;
3432             res[i] = a[b[bi] + ix];
3433         }
3434         return res;
3435     }
3436 
3437     @Test(dataProvider = "intUnaryOpIndexProvider")
3438     static void gatherInt512VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
3439         int[] a = fa.apply(SPECIES.length());
3440         int[] b    = fs.apply(a.length, SPECIES.length());
3441         int[] r = new int[a.length];
3442 
3443         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3444             for (int i = 0; i < a.length; i += SPECIES.length()) {
3445                 IntVector av = IntVector.fromArray(SPECIES, a, i, b, i);
3446                 av.intoArray(r, i);
3447             }
3448         }
3449 
3450         assertArraysEquals(a, b, r, Int512VectorTests::gather);
3451     }
3452     static int[] gatherMasked(int a[], int ix, boolean[] mask, int[] b, int iy) {
3453         int[] res = new int[SPECIES.length()];
3454         for (int i = 0; i < SPECIES.length(); i++) {
3455             int bi = iy + i;
3456             if (mask[i]) {
3457               res[i] = a[b[bi] + ix];
3458             }
3459         }
3460         return res;
3461     }
3462 
3463     @Test(dataProvider = "intUnaryMaskedOpIndexProvider")
3464     static void gatherMaskedInt512VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
3465         int[] a = fa.apply(SPECIES.length());
3466         int[] b    = fs.apply(a.length, SPECIES.length());
3467         int[] r = new int[a.length];
3468         boolean[] mask = fm.apply(SPECIES.length());
3469         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3470 
3471         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3472             for (int i = 0; i < a.length; i += SPECIES.length()) {
3473                 IntVector av = IntVector.fromArray(SPECIES, a, i, b, i, vmask);
3474                 av.intoArray(r, i);
3475             }
3476         }
3477 
3478         assertArraysEquals(a, b, r, mask, Int512VectorTests::gatherMasked);
3479     }
3480 
3481     static int[] scatter(int a[], int ix, int[] b, int iy) {
3482       int[] res = new int[SPECIES.length()];
3483       for (int i = 0; i < SPECIES.length(); i++) {
3484         int bi = iy + i;
3485         res[b[bi]] = a[i + ix];
3486       }
3487       return res;
3488     }
3489 
3490     @Test(dataProvider = "intUnaryOpIndexProvider")
3491     static void scatterInt512VectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
3492         int[] a = fa.apply(SPECIES.length());
3493         int[] b = fs.apply(a.length, SPECIES.length());
3494         int[] r = new int[a.length];
3495 
3496         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3497             for (int i = 0; i < a.length; i += SPECIES.length()) {
3498                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3499                 av.intoArray(r, i, b, i);
3500             }
3501         }
3502 
3503         assertArraysEquals(a, b, r, Int512VectorTests::scatter);
3504     }
3505 
3506     static int[] scatterMasked(int r[], int a[], int ix, boolean[] mask, int[] b, int iy) {
3507       // First, gather r.
3508       int[] oldVal = gather(r, ix, b, iy);
3509       int[] newVal = new int[SPECIES.length()];
3510 
3511       // Second, blending it with a.
3512       for (int i = 0; i < SPECIES.length(); i++) {
3513         newVal[i] = blend(oldVal[i], a[i+ix], mask[i]);
3514       }
3515 
3516       // Third, scatter: copy old value of r, and scatter it manually.
3517       int[] res = Arrays.copyOfRange(r, ix, ix+SPECIES.length());
3518       for (int i = 0; i < SPECIES.length(); i++) {
3519         int bi = iy + i;
3520         res[b[bi]] = newVal[i];
3521       }
3522 
3523       return res;
3524     }
3525 
3526     @Test(dataProvider = "scatterMaskedOpIndexProvider")
3527     static void scatterMaskedInt512VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
3528         int[] a = fa.apply(SPECIES.length());
3529         int[] b = fs.apply(a.length, SPECIES.length());
3530         int[] r = fb.apply(SPECIES.length());
3531         boolean[] mask = fm.apply(SPECIES.length());
3532         VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3533 
3534         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3535             for (int i = 0; i < a.length; i += SPECIES.length()) {
3536                 IntVector av = IntVector.fromArray(SPECIES, a, i);
3537                 av.intoArray(r, i, b, i, vmask);
3538             }
3539         }
3540 
3541         assertArraysEquals(a, b, r, mask, Int512VectorTests::scatterMasked);
3542     }
3543 
3544 }
3545