1 /*
   2  * Copyright (c) 2018, 2024, 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  * @key randomness
  27  *
  28  * @library /test/lib
  29  * @modules jdk.incubator.vector
  30  * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation Double256VectorTests
  31  */
  32 
  33 // -- This file was mechanically generated: Do not edit! -- //
  34 
  35 import jdk.incubator.vector.VectorShape;
  36 import jdk.incubator.vector.VectorSpecies;
  37 import jdk.incubator.vector.VectorShuffle;
  38 import jdk.incubator.vector.VectorMask;
  39 import jdk.incubator.vector.VectorOperators;
  40 import jdk.incubator.vector.Vector;
  41 
  42 import jdk.incubator.vector.DoubleVector;
  43 
  44 import org.testng.Assert;
  45 import org.testng.annotations.DataProvider;
  46 import org.testng.annotations.Test;
  47 
  48 import java.lang.Integer;
  49 import java.util.List;
  50 import java.util.Arrays;
  51 import java.util.function.BiFunction;
  52 import java.util.function.IntFunction;
  53 import java.util.Objects;
  54 import java.util.stream.Collectors;
  55 import java.util.stream.Stream;
  56 
  57 @Test
  58 public class Double256VectorTests extends AbstractVectorTest {
  59 
  60     static final VectorSpecies<Double> SPECIES =
  61                 DoubleVector.SPECIES_256;
  62 
  63     static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
  64 


  65 
  66     // for floating point addition reduction ops that may introduce rounding errors
  67     private static final double RELATIVE_ROUNDING_ERROR_FACTOR_ADD = (double)10.0;
  68 
  69     // for floating point multiplication reduction ops that may introduce rounding errors
  70     private static final double RELATIVE_ROUNDING_ERROR_FACTOR_MUL = (double)50.0;
  71 
  72     static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / 256);
  73 
  74     static void assertArraysStrictlyEquals(double[] r, double[] a) {
  75         for (int i = 0; i < a.length; i++) {
  76             long ir = Double.doubleToRawLongBits(r[i]);
  77             long ia = Double.doubleToRawLongBits(a[i]);
  78             if (ir != ia) {
  79                 Assert.fail(String.format("at index #%d, expected = %016X, actual = %016X", i, ia, ir));
  80             }
  81         }
  82     }
  83 
  84     interface FUnOp {
  85         double apply(double a);
  86     }
  87 
  88     static void assertArraysEquals(double[] r, double[] a, FUnOp f) {
  89         int i = 0;
  90         try {
  91             for (; i < a.length; i++) {
  92                 Assert.assertEquals(r[i], f.apply(a[i]));
  93             }
  94         } catch (AssertionError e) {
  95             Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
  96         }
  97     }
  98 
  99     interface FUnArrayOp {
 100         double[] apply(double a);
 101     }
 102 
 103     static void assertArraysEquals(double[] r, double[] a, FUnArrayOp f) {
 104         int i = 0;
 105         try {
 106             for (; i < a.length; i += SPECIES.length()) {
 107                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 108                   f.apply(a[i]));
 109             }
 110         } catch (AssertionError e) {
 111             double[] ref = f.apply(a[i]);
 112             double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 113             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 114               + ", res: " + Arrays.toString(res)
 115               + "), at index #" + i);
 116         }
 117     }
 118 
 119     static void assertArraysEquals(double[] r, double[] a, boolean[] mask, FUnOp f) {
 120         int i = 0;
 121         try {
 122             for (; i < a.length; i++) {
 123                 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
 124             }
 125         } catch (AssertionError e) {
 126             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()]);
 127         }
 128     }
 129 
 130     interface FReductionOp {
 131         double apply(double[] a, int idx);
 132     }
 133 
 134     interface FReductionAllOp {
 135         double apply(double[] a);
 136     }
 137 
 138     static void assertReductionArraysEquals(double[] r, double rc, double[] a,
 139                                             FReductionOp f, FReductionAllOp fa) {
 140         assertReductionArraysEquals(r, rc, a, f, fa, (double)0.0);
 141     }
 142 
 143     static void assertReductionArraysEquals(double[] r, double rc, double[] a,
 144                                             FReductionOp f, FReductionAllOp fa,
 145                                             double relativeErrorFactor) {
 146         int i = 0;
 147         try {
 148             Assert.assertEquals(rc, fa.apply(a), Math.ulp(rc) * relativeErrorFactor);
 149             for (; i < a.length; i += SPECIES.length()) {
 150                 Assert.assertEquals(r[i], f.apply(a, i), Math.ulp(r[i]) * relativeErrorFactor);
 151             }
 152         } catch (AssertionError e) {
 153             Assert.assertEquals(rc, fa.apply(a), Math.ulp(rc) * relativeErrorFactor, "Final result is incorrect!");
 154             Assert.assertEquals(r[i], f.apply(a, i), Math.ulp(r[i]) * relativeErrorFactor, "at index #" + i);
 155         }
 156     }
 157 
 158     interface FReductionMaskedOp {
 159         double apply(double[] a, int idx, boolean[] mask);
 160     }
 161 
 162     interface FReductionAllMaskedOp {
 163         double apply(double[] a, boolean[] mask);
 164     }
 165 
 166     static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
 167                                             FReductionMaskedOp f, FReductionAllMaskedOp fa) {
 168         assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (double)0.0);
 169     }
 170 
 171     static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
 172                                             FReductionMaskedOp f, FReductionAllMaskedOp fa,
 173                                             double relativeError) {
 174         int i = 0;
 175         try {
 176             Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
 177             for (; i < a.length; i += SPECIES.length()) {
 178                 Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
 179 relativeError));
 180             }
 181         } catch (AssertionError e) {
 182             Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
 183             Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
 184         }
 185     }
 186 
 187     interface FReductionOpLong {
 188         long apply(double[] a, int idx);
 189     }
 190 
 191     interface FReductionAllOpLong {
 192         long apply(double[] a);
 193     }
 194 
 195     static void assertReductionLongArraysEquals(long[] r, long rc, double[] a,
 196                                             FReductionOpLong f, FReductionAllOpLong fa) {
 197         int i = 0;
 198         try {
 199             Assert.assertEquals(rc, fa.apply(a));
 200             for (; i < a.length; i += SPECIES.length()) {
 201                 Assert.assertEquals(r[i], f.apply(a, i));
 202             }
 203         } catch (AssertionError e) {
 204             Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
 205             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 206         }
 207     }
 208 
 209     interface FReductionMaskedOpLong {
 210         long apply(double[] a, int idx, boolean[] mask);
 211     }
 212 
 213     interface FReductionAllMaskedOpLong {
 214         long apply(double[] a, boolean[] mask);
 215     }
 216 
 217     static void assertReductionLongArraysEqualsMasked(long[] r, long rc, double[] a, boolean[] mask,
 218                                             FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) {
 219         int i = 0;
 220         try {
 221             Assert.assertEquals(rc, fa.apply(a, mask));
 222             for (; i < a.length; i += SPECIES.length()) {
 223                 Assert.assertEquals(r[i], f.apply(a, i, mask));
 224             }
 225         } catch (AssertionError e) {
 226             Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
 227             Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
 228         }
 229     }
 230 
 231     interface FBoolReductionOp {
 232         boolean apply(boolean[] a, int idx);
 233     }
 234 
 235     static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
 236         int i = 0;
 237         try {
 238             for (; i < a.length; i += SPECIES.length()) {
 239                 Assert.assertEquals(r[i], f.apply(a, i));
 240             }
 241         } catch (AssertionError e) {
 242             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 243         }
 244     }
 245 
 246     interface FMaskReductionOp {
 247         int apply(boolean[] a, int idx);
 248     }
 249 
 250     static void assertMaskReductionArraysEquals(int[] r, boolean[] a, FMaskReductionOp f) {
 251         int i = 0;
 252         try {
 253             for (; i < a.length; i += SPECIES.length()) {
 254                 Assert.assertEquals(r[i], f.apply(a, i));
 255             }
 256         } catch (AssertionError e) {
 257             Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
 258         }
 259     }
 260 
 261     static void assertRearrangeArraysEquals(double[] r, double[] a, int[] order, int vector_len) {
 262         int i = 0, j = 0;
 263         try {
 264             for (; i < a.length; i += vector_len) {
 265                 for (j = 0; j < vector_len; j++) {
 266                     Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 267                 }
 268             }
 269         } catch (AssertionError e) {
 270             int idx = i + j;
 271             Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
 272         }
 273     }
 274 
 275     static void assertcompressArraysEquals(double[] r, double[] a, boolean[] m, int vector_len) {
 276         int i = 0, j = 0, k = 0;
 277         try {
 278             for (; i < a.length; i += vector_len) {
 279                 k = 0;
 280                 for (j = 0; j < vector_len; j++) {
 281                     if (m[(i + j) % SPECIES.length()]) {
 282                         Assert.assertEquals(r[i + k], a[i + j]);
 283                         k++;
 284                     }
 285                 }
 286                 for (; k < vector_len; k++) {
 287                     Assert.assertEquals(r[i + k], (double)0);
 288                 }
 289             }
 290         } catch (AssertionError e) {
 291             int idx = i + k;
 292             if (m[(i + j) % SPECIES.length()]) {
 293                 Assert.assertEquals(r[idx], a[i + j], "at index #" + idx);
 294             } else {
 295                 Assert.assertEquals(r[idx], (double)0, "at index #" + idx);
 296             }
 297         }
 298     }
 299 
 300     static void assertexpandArraysEquals(double[] r, double[] a, boolean[] m, int vector_len) {
 301         int i = 0, j = 0, k = 0;
 302         try {
 303             for (; i < a.length; i += vector_len) {
 304                 k = 0;
 305                 for (j = 0; j < vector_len; j++) {
 306                     if (m[(i + j) % SPECIES.length()]) {
 307                         Assert.assertEquals(r[i + j], a[i + k]);
 308                         k++;
 309                     } else {
 310                         Assert.assertEquals(r[i + j], (double)0);
 311                     }
 312                 }
 313             }
 314         } catch (AssertionError e) {
 315             int idx = i + j;
 316             if (m[idx % SPECIES.length()]) {
 317                 Assert.assertEquals(r[idx], a[i + k], "at index #" + idx);
 318             } else {
 319                 Assert.assertEquals(r[idx], (double)0, "at index #" + idx);
 320             }
 321         }
 322     }
 323 
 324     static void assertSelectFromTwoVectorEquals(double[] r, double[] order, double[] a, double[] b, int vector_len) {
 325         int i = 0, j = 0;
 326         boolean is_exceptional_idx = false;
 327         int idx = 0, wrapped_index = 0, oidx = 0;
 328         try {
 329             for (; i < a.length; i += vector_len) {
 330                 for (j = 0; j < vector_len; j++) {
 331                     idx = i + j;
 332                     wrapped_index = Math.floorMod((int)order[idx], 2 * vector_len);
 333                     is_exceptional_idx = wrapped_index >= vector_len;
 334                     oidx = is_exceptional_idx ? (wrapped_index - vector_len) : wrapped_index;
 335                     Assert.assertEquals(r[idx], (is_exceptional_idx ? b[i + oidx] : a[i + oidx]));
 336                 }
 337             }
 338         } catch (AssertionError e) {
 339             Assert.assertEquals(r[idx], (is_exceptional_idx ? b[i + oidx] : a[i + oidx]), "at index #" + idx + ", order = " + order[idx] + ", a = " + a[i + oidx] + ", b = " + b[i + oidx]);
 340         }
 341     }
 342 
 343     static void assertSelectFromArraysEquals(double[] r, double[] a, double[] order, int vector_len) {
 344         int i = 0, j = 0;
 345         try {
 346             for (; i < a.length; i += vector_len) {
 347                 for (j = 0; j < vector_len; j++) {
 348                     Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 349                 }
 350             }
 351         } catch (AssertionError e) {
 352             int idx = i + j;
 353             Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
 354         }
 355     }
 356 
 357     static void assertRearrangeArraysEquals(double[] r, double[] a, int[] order, boolean[] mask, int vector_len) {
 358         int i = 0, j = 0;
 359         try {
 360             for (; i < a.length; i += vector_len) {
 361                 for (j = 0; j < vector_len; j++) {
 362                     if (mask[j % SPECIES.length()])
 363                          Assert.assertEquals(r[i+j], a[i+order[i+j]]);
 364                     else
 365                          Assert.assertEquals(r[i+j], (double)0);
 366                 }
 367             }
 368         } catch (AssertionError e) {
 369             int idx = i + j;
 370             if (mask[j % SPECIES.length()])
 371                 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 372             else
 373                 Assert.assertEquals(r[i+j], (double)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 374         }
 375     }
 376 
 377     static void assertSelectFromArraysEquals(double[] r, double[] a, double[] order, boolean[] mask, int vector_len) {
 378         int i = 0, j = 0;
 379         try {
 380             for (; i < a.length; i += vector_len) {
 381                 for (j = 0; j < vector_len; j++) {
 382                     if (mask[j % SPECIES.length()])
 383                          Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
 384                     else
 385                          Assert.assertEquals(r[i+j], (double)0);
 386                 }
 387             }
 388         } catch (AssertionError e) {
 389             int idx = i + j;
 390             if (mask[j % SPECIES.length()])
 391                 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 392             else
 393                 Assert.assertEquals(r[i+j], (double)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
 394         }
 395     }
 396 
 397     static void assertBroadcastArraysEquals(double[] r, double[] a) {
 398         int i = 0;
 399         for (; i < a.length; i += SPECIES.length()) {
 400             int idx = i;
 401             for (int j = idx; j < (idx + SPECIES.length()); j++)
 402                 a[j]=a[idx];
 403         }
 404 
 405         try {
 406             for (i = 0; i < a.length; i++) {
 407                 Assert.assertEquals(r[i], a[i]);
 408             }
 409         } catch (AssertionError e) {
 410             Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
 411         }
 412     }
 413 
 414     interface FBinOp {
 415         double apply(double a, double b);
 416     }
 417 
 418     interface FBinMaskOp {
 419         double apply(double a, double b, boolean m);
 420 
 421         static FBinMaskOp lift(FBinOp f) {
 422             return (a, b, m) -> m ? f.apply(a, b) : a;
 423         }
 424     }
 425 
 426     static void assertArraysEqualsAssociative(double[] rl, double[] rr, double[] a, double[] b, double[] c, FBinOp f) {
 427         int i = 0;
 428         try {
 429             for (; i < a.length; i++) {
 430                 //Left associative
 431                 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i]), c[i]));
 432 
 433                 //Right associative
 434                 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i])));
 435 
 436                 //Results equal sanity check
 437                 Assert.assertEquals(rl[i], rr[i]);
 438             }
 439         } catch (AssertionError e) {
 440             Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i]), c[i]), "left associative test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 441             Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i])), "right associative test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 442             Assert.assertEquals(rl[i], rr[i], "Result checks not equal at index #" + i + "leftRes = " + rl[i] + ", rightRes = " + rr[i]);
 443         }
 444     }
 445 
 446    static void assertArraysEqualsAssociative(double[] rl, double[] rr, double[] a, double[] b, double[] c, boolean[] mask, FBinOp f) {
 447        assertArraysEqualsAssociative(rl, rr, a, b, c, mask, FBinMaskOp.lift(f));
 448    }
 449 
 450     static void assertArraysEqualsAssociative(double[] rl, double[] rr, double[] a, double[] b, double[] c, boolean[] mask, FBinMaskOp f) {
 451         int i = 0;
 452         boolean mask_bit = false;
 453         try {
 454             for (; i < a.length; i++) {
 455                 mask_bit = mask[i % SPECIES.length()];
 456                 //Left associative
 457                 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i], mask_bit), c[i], mask_bit));
 458 
 459                 //Right associative
 460                 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i], mask_bit), mask_bit));
 461 
 462                 //Results equal sanity check
 463                 Assert.assertEquals(rl[i], rr[i]);
 464             }
 465         } catch (AssertionError e) {
 466             Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i], mask_bit), c[i], mask_bit), "left associative masked test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i] + ", mask = " + mask_bit);
 467             Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i], mask_bit), mask_bit), "right associative masked test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i] + ", mask = " + mask_bit);
 468             Assert.assertEquals(rl[i], rr[i], "Result checks not equal at index #" + i + "leftRes = " + rl[i] + ", rightRes = " + rr[i]);
 469         }
 470     }
 471 
 472     static void assertArraysEquals(double[] r, double[] a, double[] b, FBinOp f) {
 473         int i = 0;
 474         try {
 475             for (; i < a.length; i++) {
 476                 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
 477             }
 478         } catch (AssertionError e) {
 479             Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
 480         }
 481     }
 482 
 483     static void assertArraysEquals(double[] r, double[] a, double b, FBinOp f) {
 484         int i = 0;
 485         try {
 486             for (; i < a.length; i++) {
 487                 Assert.assertEquals(r[i], f.apply(a[i], b));
 488             }
 489         } catch (AssertionError e) {
 490             Assert.assertEquals(r[i], f.apply(a[i], b), "(" + a[i] + ", " + b + ") at index #" + i);
 491         }
 492     }
 493 
 494     static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, FBinOp f) {
 495         int i = 0;
 496         try {
 497             for (; i < a.length; i++) {
 498                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
 499             }
 500         } catch (AssertionError e) {
 501             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
 502                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 503         }
 504     }
 505 
 506     static void assertBroadcastLongArraysEquals(double[] r, double[] a, double[] b, FBinOp f) {
 507         int i = 0;
 508         try {
 509             for (; i < a.length; i++) {
 510                 Assert.assertEquals(r[i], f.apply(a[i], (double)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
 511             }
 512         } catch (AssertionError e) {
 513             Assert.assertEquals(r[i], f.apply(a[i], (double)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
 514                                 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
 515         }
 516     }
 517 
 518     static void assertArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinOp f) {
 519         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 520     }
 521 
 522     static void assertArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinMaskOp f) {
 523         int i = 0;
 524         try {
 525             for (; i < a.length; i++) {
 526                 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
 527             }
 528         } catch (AssertionError err) {
 529             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()]);
 530         }
 531     }
 532 
 533     static void assertArraysEquals(double[] r, double[] a, double b, boolean[] mask, FBinOp f) {
 534         assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 535     }
 536 
 537     static void assertArraysEquals(double[] r, double[] a, double b, boolean[] mask, FBinMaskOp f) {
 538         int i = 0;
 539         try {
 540             for (; i < a.length; i++) {
 541                 Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]));
 542             }
 543         } catch (AssertionError err) {
 544             Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b + ", mask = " + mask[i % SPECIES.length()]);
 545         }
 546     }
 547 
 548     static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinOp f) {
 549         assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 550     }
 551 
 552     static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinMaskOp f) {
 553         int i = 0;
 554         try {
 555             for (; i < a.length; i++) {
 556                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 557             }
 558         } catch (AssertionError err) {
 559             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 560                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 561                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 562                                 mask[i % SPECIES.length()]);
 563         }
 564     }
 565 
 566     static void assertBroadcastLongArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinOp f) {
 567         assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 568     }
 569 
 570     static void assertBroadcastLongArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinMaskOp f) {
 571         int i = 0;
 572         try {
 573             for (; i < a.length; i++) {
 574                 Assert.assertEquals(r[i], f.apply(a[i], (double)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
 575             }
 576         } catch (AssertionError err) {
 577             Assert.assertEquals(r[i], f.apply(a[i], (double)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
 578                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 579                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 580                                 mask[i % SPECIES.length()]);
 581         }
 582     }
 583 
 584     static void assertShiftArraysEquals(double[] r, double[] a, double[] b, FBinOp f) {
 585         int i = 0;
 586         int j = 0;
 587         try {
 588             for (; j < a.length; j += SPECIES.length()) {
 589                 for (i = 0; i < SPECIES.length(); i++) {
 590                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
 591                 }
 592             }
 593         } catch (AssertionError e) {
 594             Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
 595         }
 596     }
 597 
 598     static void assertShiftArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinOp f) {
 599         assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
 600     }
 601 
 602     static void assertShiftArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinMaskOp f) {
 603         int i = 0;
 604         int j = 0;
 605         try {
 606             for (; j < a.length; j += SPECIES.length()) {
 607                 for (i = 0; i < SPECIES.length(); i++) {
 608                     Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
 609                 }
 610             }
 611         } catch (AssertionError err) {
 612             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]);
 613         }
 614     }
 615 
 616     interface FBinConstOp {
 617         double apply(double a);
 618     }
 619 
 620     interface FBinConstMaskOp {
 621         double apply(double a, boolean m);
 622 
 623         static FBinConstMaskOp lift(FBinConstOp f) {
 624             return (a, m) -> m ? f.apply(a) : a;
 625         }
 626     }
 627 
 628     static void assertShiftConstEquals(double[] r, double[] a, FBinConstOp f) {
 629         int i = 0;
 630         int j = 0;
 631         try {
 632             for (; j < a.length; j += SPECIES.length()) {
 633                 for (i = 0; i < SPECIES.length(); i++) {
 634                     Assert.assertEquals(r[i+j], f.apply(a[i+j]));
 635                 }
 636             }
 637         } catch (AssertionError e) {
 638             Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j);
 639         }
 640     }
 641 
 642     static void assertShiftConstEquals(double[] r, double[] a, boolean[] mask, FBinConstOp f) {
 643         assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
 644     }
 645 
 646     static void assertShiftConstEquals(double[] r, double[] a, boolean[] mask, FBinConstMaskOp f) {
 647         int i = 0;
 648         int j = 0;
 649         try {
 650             for (; j < a.length; j += SPECIES.length()) {
 651                 for (i = 0; i < SPECIES.length(); i++) {
 652                     Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]));
 653                 }
 654             }
 655         } catch (AssertionError err) {
 656             Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]);
 657         }
 658     }
 659 
 660     interface FTernOp {
 661         double apply(double a, double b, double c);
 662     }
 663 
 664     interface FTernMaskOp {
 665         double apply(double a, double b, double c, boolean m);
 666 
 667         static FTernMaskOp lift(FTernOp f) {
 668             return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
 669         }
 670     }
 671 
 672     static void assertArraysEquals(double[] r, double[] a, double[] b, double[] c, FTernOp f) {
 673         int i = 0;
 674         try {
 675             for (; i < a.length; i++) {
 676                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
 677             }
 678         } catch (AssertionError e) {
 679             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
 680         }
 681     }
 682 
 683     static void assertArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask, FTernOp f) {
 684         assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 685     }
 686 
 687     static void assertArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask, FTernMaskOp f) {
 688         int i = 0;
 689         try {
 690             for (; i < a.length; i++) {
 691                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
 692             }
 693         } catch (AssertionError err) {
 694             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
 695               + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 696         }
 697     }
 698 
 699     static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, FTernOp f) {
 700         int i = 0;
 701         try {
 702             for (; i < a.length; i++) {
 703                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
 704             }
 705         } catch (AssertionError e) {
 706             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
 707                                 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
 708                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 709         }
 710     }
 711 
 712     static void assertAltBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, FTernOp f) {
 713         int i = 0;
 714         try {
 715             for (; i < a.length; i++) {
 716                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
 717             }
 718         } catch (AssertionError e) {
 719             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
 720                                 i + ", input1 = " + a[i] + ", input2 = " +
 721                                 b[(i / SPECIES.length()) * SPECIES.length()] + ",  input3 = " + c[i]);
 722         }
 723     }
 724 
 725     static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
 726                                             FTernOp f) {
 727         assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 728     }
 729 
 730     static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
 731                                             FTernMaskOp f) {
 732         int i = 0;
 733         try {
 734             for (; i < a.length; i++) {
 735                 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 736                                     mask[i % SPECIES.length()]));
 737             }
 738         } catch (AssertionError err) {
 739             Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
 740                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
 741                                 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 742                                 mask[i % SPECIES.length()]);
 743         }
 744     }
 745 
 746     static void assertAltBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
 747                                             FTernOp f) {
 748         assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 749     }
 750 
 751     static void assertAltBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
 752                                             FTernMaskOp f) {
 753         int i = 0;
 754         try {
 755             for (; i < a.length; i++) {
 756                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 757                                     mask[i % SPECIES.length()]));
 758             }
 759         } catch (AssertionError err) {
 760             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
 761                                 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
 762                                 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 763                                 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
 764         }
 765     }
 766 
 767     static void assertDoubleBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, FTernOp f) {
 768         int i = 0;
 769         try {
 770             for (; i < a.length; i++) {
 771                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 772                                     c[(i / SPECIES.length()) * SPECIES.length()]));
 773             }
 774         } catch (AssertionError e) {
 775             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 776                                 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
 777                                 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
 778                                 c[(i / SPECIES.length()) * SPECIES.length()]);
 779         }
 780     }
 781 
 782     static void assertDoubleBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
 783                                                   FTernOp f) {
 784         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
 785     }
 786 
 787     static void assertDoubleBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
 788                                                   FTernMaskOp f) {
 789         int i = 0;
 790         try {
 791             for (; i < a.length; i++) {
 792                 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 793                                     c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
 794             }
 795         } catch (AssertionError err) {
 796             Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
 797                                 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
 798                                 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
 799                                 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
 800                                 mask[i % SPECIES.length()]);
 801         }
 802     }
 803 
 804 
 805     static boolean isWithin1Ulp(double actual, double expected) {
 806         if (Double.isNaN(expected) && !Double.isNaN(actual)) {
 807             return false;
 808         } else if (!Double.isNaN(expected) && Double.isNaN(actual)) {
 809             return false;
 810         }
 811 
 812         double low = Math.nextDown(expected);
 813         double high = Math.nextUp(expected);
 814 
 815         if (Double.compare(low, expected) > 0) {
 816             return false;
 817         }
 818 
 819         if (Double.compare(high, expected) < 0) {
 820             return false;
 821         }
 822 
 823         return true;
 824     }
 825 
 826     static void assertArraysEqualsWithinOneUlp(double[] r, double[] a, FUnOp mathf, FUnOp strictmathf) {
 827         int i = 0;
 828         try {
 829             // Check that result is within 1 ulp of strict math or equivalent to math implementation.
 830             for (; i < a.length; i++) {
 831                 Assert.assertTrue(Double.compare(r[i], mathf.apply(a[i])) == 0 ||
 832                                     isWithin1Ulp(r[i], strictmathf.apply(a[i])));
 833             }
 834         } catch (AssertionError e) {
 835             Assert.assertTrue(Double.compare(r[i], mathf.apply(a[i])) == 0, "at index #" + i + ", input = " + a[i] + ", actual = " + r[i] + ", expected = " + mathf.apply(a[i]));
 836             Assert.assertTrue(isWithin1Ulp(r[i], strictmathf.apply(a[i])), "at index #" + i + ", input = " + a[i] + ", actual = " + r[i] + ", expected (within 1 ulp) = " + strictmathf.apply(a[i]));
 837         }
 838     }
 839 
 840     static void assertArraysEqualsWithinOneUlp(double[] r, double[] a, double[] b, FBinOp mathf, FBinOp strictmathf) {
 841         int i = 0;
 842         try {
 843             // Check that result is within 1 ulp of strict math or equivalent to math implementation.
 844             for (; i < a.length; i++) {
 845                 Assert.assertTrue(Double.compare(r[i], mathf.apply(a[i], b[i])) == 0 ||
 846                                     isWithin1Ulp(r[i], strictmathf.apply(a[i], b[i])));
 847             }
 848         } catch (AssertionError e) {
 849             Assert.assertTrue(Double.compare(r[i], mathf.apply(a[i], b[i])) == 0, "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", actual = " + r[i] + ", expected = " + mathf.apply(a[i], b[i]));
 850             Assert.assertTrue(isWithin1Ulp(r[i], strictmathf.apply(a[i], b[i])), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", actual = " + r[i] + ", expected (within 1 ulp) = " + strictmathf.apply(a[i], b[i]));
 851         }
 852     }
 853 
 854     static void assertBroadcastArraysEqualsWithinOneUlp(double[] r, double[] a, double[] b,
 855                                                         FBinOp mathf, FBinOp strictmathf) {
 856         int i = 0;
 857         try {
 858             // Check that result is within 1 ulp of strict math or equivalent to math implementation.
 859             for (; i < a.length; i++) {
 860                 Assert.assertTrue(Double.compare(r[i],
 861                                   mathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])) == 0 ||
 862                                   isWithin1Ulp(r[i],
 863                                   strictmathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])));
 864             }
 865         } catch (AssertionError e) {
 866             Assert.assertTrue(Double.compare(r[i],
 867                               mathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])) == 0,
 868                               "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
 869                               b[(i / SPECIES.length()) * SPECIES.length()] + ", actual = " + r[i] +
 870                               ", expected = " + mathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
 871             Assert.assertTrue(isWithin1Ulp(r[i],
 872                               strictmathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])),
 873                              "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
 874                              b[(i / SPECIES.length()) * SPECIES.length()] + ", actual = " + r[i] +
 875                              ", expected (within 1 ulp) = " + strictmathf.apply(a[i],
 876                              b[(i / SPECIES.length()) * SPECIES.length()]));
 877         }
 878     }
 879 
 880     interface FGatherScatterOp {
 881         double[] apply(double[] a, int ix, int[] b, int iy);
 882     }
 883 
 884     static void assertArraysEquals(double[] r, double[] a, int[] b, FGatherScatterOp f) {
 885         int i = 0;
 886         try {
 887             for (; i < a.length; i += SPECIES.length()) {
 888                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 889                   f.apply(a, i, b, i));
 890             }
 891         } catch (AssertionError e) {
 892             double[] ref = f.apply(a, i, b, i);
 893             double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 894             Assert.assertEquals(res, ref,
 895               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 896               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 897               + ", b: "
 898               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 899               + " at index #" + i);
 900         }
 901     }
 902 
 903     interface FGatherMaskedOp {
 904         double[] apply(double[] a, int ix, boolean[] mask, int[] b, int iy);
 905     }
 906 
 907     interface FScatterMaskedOp {
 908         double[] apply(double[] r, double[] a, int ix, boolean[] mask, int[] b, int iy);
 909     }
 910 
 911     static void assertArraysEquals(double[] r, double[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
 912         int i = 0;
 913         try {
 914             for (; i < a.length; i += SPECIES.length()) {
 915                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 916                   f.apply(a, i, mask, b, i));
 917             }
 918         } catch (AssertionError e) {
 919             double[] ref = f.apply(a, i, mask, b, i);
 920             double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 921             Assert.assertEquals(res, ref,
 922               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 923               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 924               + ", b: "
 925               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 926               + ", mask: "
 927               + Arrays.toString(mask)
 928               + " at index #" + i);
 929         }
 930     }
 931 
 932     static void assertArraysEquals(double[] r, double[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
 933         int i = 0;
 934         try {
 935             for (; i < a.length; i += SPECIES.length()) {
 936                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 937                   f.apply(r, a, i, mask, b, i));
 938             }
 939         } catch (AssertionError e) {
 940             double[] ref = f.apply(r, a, i, mask, b, i);
 941             double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 942             Assert.assertEquals(res, ref,
 943               "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
 944               + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
 945               + ", b: "
 946               + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
 947               + ", r: "
 948               + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
 949               + ", mask: "
 950               + Arrays.toString(mask)
 951               + " at index #" + i);
 952         }
 953     }
 954 
 955     interface FLaneOp {
 956         double[] apply(double[] a, int origin, int idx);
 957     }
 958 
 959     static void assertArraysEquals(double[] r, double[] a, int origin, FLaneOp f) {
 960         int i = 0;
 961         try {
 962             for (; i < a.length; i += SPECIES.length()) {
 963                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 964                   f.apply(a, origin, i));
 965             }
 966         } catch (AssertionError e) {
 967             double[] ref = f.apply(a, origin, i);
 968             double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 969             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 970               + ", res: " + Arrays.toString(res)
 971               + "), at index #" + i);
 972         }
 973     }
 974 
 975     interface FLaneBop {
 976         double[] apply(double[] a, double[] b, int origin, int idx);
 977     }
 978 
 979     static void assertArraysEquals(double[] r, double[] a, double[] b, int origin, FLaneBop f) {
 980         int i = 0;
 981         try {
 982             for (; i < a.length; i += SPECIES.length()) {
 983                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
 984                   f.apply(a, b, origin, i));
 985             }
 986         } catch (AssertionError e) {
 987             double[] ref = f.apply(a, b, origin, i);
 988             double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
 989             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
 990               + ", res: " + Arrays.toString(res)
 991               + "), at index #" + i
 992               + ", at origin #" + origin);
 993         }
 994     }
 995 
 996     interface FLaneMaskedBop {
 997         double[] apply(double[] a, double[] b, int origin, boolean[] mask, int idx);
 998     }
 999 
1000     static void assertArraysEquals(double[] r, double[] a, double[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
1001         int i = 0;
1002         try {
1003             for (; i < a.length; i += SPECIES.length()) {
1004                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
1005                   f.apply(a, b, origin, mask, i));
1006             }
1007         } catch (AssertionError e) {
1008             double[] ref = f.apply(a, b, origin, mask, i);
1009             double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
1010             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
1011               + ", res: " + Arrays.toString(res)
1012               + "), at index #" + i
1013               + ", at origin #" + origin);
1014         }
1015     }
1016 
1017     interface FLanePartBop {
1018         double[] apply(double[] a, double[] b, int origin, int part, int idx);
1019     }
1020 
1021     static void assertArraysEquals(double[] r, double[] a, double[] b, int origin, int part, FLanePartBop f) {
1022         int i = 0;
1023         try {
1024             for (; i < a.length; i += SPECIES.length()) {
1025                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
1026                   f.apply(a, b, origin, part, i));
1027             }
1028         } catch (AssertionError e) {
1029             double[] ref = f.apply(a, b, origin, part, i);
1030             double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
1031             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
1032               + ", res: " + Arrays.toString(res)
1033               + "), at index #" + i
1034               + ", at origin #" + origin
1035               + ", with part #" + part);
1036         }
1037     }
1038 
1039     interface FLanePartMaskedBop {
1040         double[] apply(double[] a, double[] b, int origin, int part, boolean[] mask, int idx);
1041     }
1042 
1043     static void assertArraysEquals(double[] r, double[] a, double[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
1044         int i = 0;
1045         try {
1046             for (; i < a.length; i += SPECIES.length()) {
1047                 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
1048                   f.apply(a, b, origin, part, mask, i));
1049             }
1050         } catch (AssertionError e) {
1051             double[] ref = f.apply(a, b, origin, part, mask, i);
1052             double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
1053             Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
1054               + ", res: " + Arrays.toString(res)
1055               + "), at index #" + i
1056               + ", at origin #" + origin
1057               + ", with part #" + part);
1058         }
1059     }
1060 
1061     static int intCornerCaseValue(int i) {
1062         switch(i % 5) {
1063             case 0:
1064                 return Integer.MAX_VALUE;
1065             case 1:
1066                 return Integer.MIN_VALUE;
1067             case 2:
1068                 return Integer.MIN_VALUE;
1069             case 3:
1070                 return Integer.MAX_VALUE;
1071             default:
1072                 return (int)0;
1073         }
1074     }
1075 
1076     static final List<IntFunction<double[]>> INT_DOUBLE_GENERATORS = List.of(
1077             withToString("double[-i * 5]", (int s) -> {
1078                 return fill(s * BUFFER_REPS,
1079                             i -> (double)(-i * 5));
1080             }),
1081             withToString("double[i * 5]", (int s) -> {
1082                 return fill(s * BUFFER_REPS,
1083                             i -> (double)(i * 5));
1084             }),
1085             withToString("double[i + 1]", (int s) -> {
1086                 return fill(s * BUFFER_REPS,
1087                             i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1)));
1088             }),
1089             withToString("double[intCornerCaseValue(i)]", (int s) -> {
1090                 return fill(s * BUFFER_REPS,
1091                             i -> (double)intCornerCaseValue(i));
1092             })
1093     );
1094 
1095     static void assertArraysEquals(int[] r, double[] a, int offs) {
1096         int i = 0;
1097         try {
1098             for (; i < r.length; i++) {
1099                 Assert.assertEquals(r[i], (int)(a[i+offs]));
1100             }
1101         } catch (AssertionError e) {
1102             Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
1103         }
1104     }
1105 
1106     static long longCornerCaseValue(int i) {
1107         switch(i % 5) {
1108             case 0:
1109                 return Long.MAX_VALUE;
1110             case 1:
1111                 return Long.MIN_VALUE;
1112             case 2:
1113                 return Long.MIN_VALUE;
1114             case 3:
1115                 return Long.MAX_VALUE;
1116             default:
1117                 return (long)0;
1118         }
1119     }
1120 
1121     static final List<IntFunction<double[]>> LONG_DOUBLE_GENERATORS = List.of(
1122             withToString("double[-i * 5]", (int s) -> {
1123                 return fill(s * BUFFER_REPS,
1124                             i -> (double)(-i * 5));
1125             }),
1126             withToString("double[i * 5]", (int s) -> {
1127                 return fill(s * BUFFER_REPS,
1128                             i -> (double)(i * 5));
1129             }),
1130             withToString("double[i + 1]", (int s) -> {
1131                 return fill(s * BUFFER_REPS,
1132                             i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1)));
1133             }),
1134             withToString("double[cornerCaseValue(i)]", (int s) -> {
1135                 return fill(s * BUFFER_REPS,
1136                             i -> (double)longCornerCaseValue(i));
1137             })
1138     );
1139 
1140 
1141     static void assertArraysEquals(long[] r, double[] a, int offs) {
1142         int i = 0;
1143         try {
1144             for (; i < r.length; i++) {
1145                 Assert.assertEquals(r[i], (long)(a[i+offs]));
1146             }
1147         } catch (AssertionError e) {
1148             Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
1149         }
1150     }
1151 
1152     static long bits(double e) {
1153         return  Double.doubleToLongBits(e);
1154     }
1155 
1156     static final List<IntFunction<double[]>> DOUBLE_GENERATORS = List.of(
1157             withToString("double[-i * 5]", (int s) -> {
1158                 return fill(s * BUFFER_REPS,
1159                             i -> (double)(-i * 5));
1160             }),
1161             withToString("double[i * 5]", (int s) -> {
1162                 return fill(s * BUFFER_REPS,
1163                             i -> (double)(i * 5));
1164             }),
1165             withToString("double[i + 1]", (int s) -> {
1166                 return fill(s * BUFFER_REPS,
1167                             i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1)));
1168             }),
1169             withToString("double[0.01 + (i / (i + 1))]", (int s) -> {
1170                 return fill(s * BUFFER_REPS,
1171                             i -> (double)0.01 + ((double)i / (i + 1)));
1172             }),
1173             withToString("double[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
1174                 return fill(s * BUFFER_REPS,
1175                             i -> i % 17 == 0 ? cornerCaseValue(i) : (double)0.01 + ((double)i / (i + 1)));
1176             }),
1177             withToString("double[cornerCaseValue(i)]", (int s) -> {
1178                 return fill(s * BUFFER_REPS,
1179                             i -> cornerCaseValue(i));
1180             })
1181     );
1182 
1183     // Create combinations of pairs
1184     // @@@ Might be sensitive to order e.g. div by 0
1185     static final List<List<IntFunction<double[]>>> DOUBLE_GENERATOR_PAIRS =
1186         Stream.of(DOUBLE_GENERATORS.get(0)).
1187                 flatMap(fa -> DOUBLE_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
1188                 collect(Collectors.toList());
1189 
1190     @DataProvider
1191     public Object[][] boolUnaryOpProvider() {
1192         return BOOL_ARRAY_GENERATORS.stream().
1193                 map(f -> new Object[]{f}).
1194                 toArray(Object[][]::new);
1195     }
1196 
1197     static final List<List<IntFunction<double[]>>> DOUBLE_GENERATOR_TRIPLES =
1198         DOUBLE_GENERATOR_PAIRS.stream().
1199                 flatMap(pair -> DOUBLE_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1200                 collect(Collectors.toList());
1201 
1202     static final List<IntFunction<double[]>> SELECT_FROM_INDEX_GENERATORS = List.of(
1203             withToString("double[0..VECLEN*2)", (int s) -> {
1204                 return fill(s * BUFFER_REPS,
1205                             i -> (double)(RAND.nextInt()));
1206             })
1207     );
1208 
1209     static final List<List<IntFunction<double[]>>> DOUBLE_GENERATOR_SELECT_FROM_TRIPLES =
1210         DOUBLE_GENERATOR_PAIRS.stream().
1211                 flatMap(pair -> SELECT_FROM_INDEX_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1212                 collect(Collectors.toList());
1213 
1214     @DataProvider
1215     public Object[][] doubleBinaryOpProvider() {
1216         return DOUBLE_GENERATOR_PAIRS.stream().map(List::toArray).
1217                 toArray(Object[][]::new);
1218     }
1219 
1220     @DataProvider
1221     public Object[][] doubleIndexedOpProvider() {
1222         return DOUBLE_GENERATOR_PAIRS.stream().map(List::toArray).
1223                 toArray(Object[][]::new);
1224     }
1225 
1226     @DataProvider
1227     public Object[][] doubleBinaryOpMaskProvider() {
1228         return BOOLEAN_MASK_GENERATORS.stream().
1229                 flatMap(fm -> DOUBLE_GENERATOR_PAIRS.stream().map(lfa -> {
1230                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1231                 })).
1232                 toArray(Object[][]::new);
1233     }
1234 
1235     @DataProvider
1236     public Object[][] doubleTernaryOpProvider() {
1237         return DOUBLE_GENERATOR_TRIPLES.stream().map(List::toArray).
1238                 toArray(Object[][]::new);
1239     }
1240 
1241     @DataProvider
1242     public Object[][] doubleSelectFromTwoVectorOpProvider() {
1243         return DOUBLE_GENERATOR_SELECT_FROM_TRIPLES.stream().map(List::toArray).
1244                 toArray(Object[][]::new);
1245     }
1246 
1247     @DataProvider
1248     public Object[][] doubleTernaryOpMaskProvider() {
1249         return BOOLEAN_MASK_GENERATORS.stream().
1250                 flatMap(fm -> DOUBLE_GENERATOR_TRIPLES.stream().map(lfa -> {
1251                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1252                 })).
1253                 toArray(Object[][]::new);
1254     }
1255 
1256     @DataProvider
1257     public Object[][] doubleUnaryOpProvider() {
1258         return DOUBLE_GENERATORS.stream().
1259                 map(f -> new Object[]{f}).
1260                 toArray(Object[][]::new);
1261     }
1262 
1263     @DataProvider
1264     public Object[][] doubleUnaryOpMaskProvider() {
1265         return BOOLEAN_MASK_GENERATORS.stream().
1266                 flatMap(fm -> DOUBLE_GENERATORS.stream().map(fa -> {
1267                     return new Object[] {fa, fm};
1268                 })).
1269                 toArray(Object[][]::new);
1270     }
1271 
1272     @DataProvider
1273     public Object[][] doubletoIntUnaryOpProvider() {
1274         return INT_DOUBLE_GENERATORS.stream().
1275                 map(f -> new Object[]{f}).
1276                 toArray(Object[][]::new);
1277     }
1278 
1279     @DataProvider
1280     public Object[][] doubletoLongUnaryOpProvider() {
1281         return LONG_DOUBLE_GENERATORS.stream().
1282                 map(f -> new Object[]{f}).
1283                 toArray(Object[][]::new);
1284     }
1285 
1286     @DataProvider
1287     public Object[][] maskProvider() {
1288         return BOOLEAN_MASK_GENERATORS.stream().
1289                 map(f -> new Object[]{f}).
1290                 toArray(Object[][]::new);
1291     }
1292 
1293     @DataProvider
1294     public Object[][] maskCompareOpProvider() {
1295         return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1296                 toArray(Object[][]::new);
1297     }
1298 
1299     @DataProvider
1300     public Object[][] shuffleProvider() {
1301         return INT_SHUFFLE_GENERATORS.stream().
1302                 map(f -> new Object[]{f}).
1303                 toArray(Object[][]::new);
1304     }
1305 
1306     @DataProvider
1307     public Object[][] shuffleCompareOpProvider() {
1308         return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1309                 toArray(Object[][]::new);
1310     }
1311 
1312     @DataProvider
1313     public Object[][] doubleUnaryOpShuffleProvider() {
1314         return INT_SHUFFLE_GENERATORS.stream().
1315                 flatMap(fs -> DOUBLE_GENERATORS.stream().map(fa -> {
1316                     return new Object[] {fa, fs};
1317                 })).
1318                 toArray(Object[][]::new);
1319     }
1320 
1321     @DataProvider
1322     public Object[][] doubleUnaryOpShuffleMaskProvider() {
1323         return BOOLEAN_MASK_GENERATORS.stream().
1324                 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1325                     flatMap(fs -> DOUBLE_GENERATORS.stream().map(fa -> {
1326                         return new Object[] {fa, fs, fm};
1327                 }))).
1328                 toArray(Object[][]::new);
1329     }
1330 
1331     static final List<BiFunction<Integer,Integer,double[]>> DOUBLE_SHUFFLE_GENERATORS = List.of(
1332             withToStringBi("shuffle[random]", (Integer l, Integer m) -> {
1333                 double[] a = new double[l];
1334                 int upper = m;
1335                 for (int i = 0; i < 1; i++) {
1336                     a[i] = (double)RAND.nextInt(upper);
1337                 }
1338                 return a;
1339             })
1340     );
1341 
1342     @DataProvider
1343     public Object[][] doubleUnaryOpSelectFromProvider() {
1344         return DOUBLE_SHUFFLE_GENERATORS.stream().
1345                 flatMap(fs -> DOUBLE_GENERATORS.stream().map(fa -> {
1346                     return new Object[] {fa, fs};
1347                 })).
1348                 toArray(Object[][]::new);
1349     }
1350 
1351     @DataProvider
1352     public Object[][] doubleUnaryOpSelectFromMaskProvider() {
1353         return BOOLEAN_MASK_GENERATORS.stream().
1354                 flatMap(fm -> DOUBLE_SHUFFLE_GENERATORS.stream().
1355                     flatMap(fs -> DOUBLE_GENERATORS.stream().map(fa -> {
1356                         return new Object[] {fa, fs, fm};
1357                 }))).
1358                 toArray(Object[][]::new);
1359     }
1360 
1361     static final List<IntFunction<double[]>> DOUBLE_COMPARE_GENERATORS = List.of(
1362             withToString("double[i]", (int s) -> {
1363                 return fill(s * BUFFER_REPS,
1364                             i -> (double)i);
1365             }),
1366             withToString("double[i - length / 2]", (int s) -> {
1367                 return fill(s * BUFFER_REPS,
1368                             i -> (double)(i - (s * BUFFER_REPS / 2)));
1369             }),
1370             withToString("double[i + 1]", (int s) -> {
1371                 return fill(s * BUFFER_REPS,
1372                             i -> (double)(i + 1));
1373             }),
1374             withToString("double[i - 2]", (int s) -> {
1375                 return fill(s * BUFFER_REPS,
1376                             i -> (double)(i - 2));
1377             }),
1378             withToString("double[zigZag(i)]", (int s) -> {
1379                 return fill(s * BUFFER_REPS,
1380                             i -> i%3 == 0 ? (double)i : (i%3 == 1 ? (double)(i + 1) : (double)(i - 2)));
1381             }),
1382             withToString("double[cornerCaseValue(i)]", (int s) -> {
1383                 return fill(s * BUFFER_REPS,
1384                             i -> cornerCaseValue(i));
1385             })
1386     );
1387 
1388     static final List<List<IntFunction<double[]>>> DOUBLE_TEST_GENERATOR_ARGS =
1389         DOUBLE_COMPARE_GENERATORS.stream().
1390                 map(fa -> List.of(fa)).
1391                 collect(Collectors.toList());
1392 
1393     @DataProvider
1394     public Object[][] doubleTestOpProvider() {
1395         return DOUBLE_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1396                 toArray(Object[][]::new);
1397     }
1398 
1399     @DataProvider
1400     public Object[][] doubleTestOpMaskProvider() {
1401         return BOOLEAN_MASK_GENERATORS.stream().
1402                 flatMap(fm -> DOUBLE_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1403                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1404                 })).
1405                 toArray(Object[][]::new);
1406     }
1407 
1408     static final List<List<IntFunction<double[]>>> DOUBLE_COMPARE_GENERATOR_PAIRS =
1409         DOUBLE_COMPARE_GENERATORS.stream().
1410                 flatMap(fa -> DOUBLE_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1411                 collect(Collectors.toList());
1412 
1413     @DataProvider
1414     public Object[][] doubleCompareOpProvider() {
1415         return DOUBLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1416                 toArray(Object[][]::new);
1417     }
1418 
1419     @DataProvider
1420     public Object[][] doubleCompareOpMaskProvider() {
1421         return BOOLEAN_MASK_GENERATORS.stream().
1422                 flatMap(fm -> DOUBLE_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1423                     return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1424                 })).
1425                 toArray(Object[][]::new);
1426     }
1427 
1428     interface ToDoubleF {
1429         double apply(int i);
1430     }
1431 
1432     static double[] fill(int s , ToDoubleF f) {
1433         return fill(new double[s], f);
1434     }
1435 
1436     static double[] fill(double[] a, ToDoubleF f) {
1437         for (int i = 0; i < a.length; i++) {
1438             a[i] = f.apply(i);
1439         }
1440         return a;
1441     }
1442 
1443     static double cornerCaseValue(int i) {
1444         return switch(i % 8) {
1445             case 0  -> Double.MAX_VALUE;
1446             case 1  -> Double.MIN_VALUE;
1447             case 2  -> Double.NEGATIVE_INFINITY;
1448             case 3  -> Double.POSITIVE_INFINITY;
1449             case 4  -> Double.NaN;
1450             case 5  -> Double.longBitsToDouble(0x7FF123456789ABCDL);
1451             case 6  -> (double)0.0;
1452             default -> (double)-0.0;
1453         };
1454     }
1455 
1456     static final IntFunction<double[]> fr = (vl) -> {
1457         int length = BUFFER_REPS * vl;
1458         return new double[length];
1459     };
1460 
1461     static final IntFunction<boolean[]> fmr = (vl) -> {
1462         int length = BUFFER_REPS * vl;
1463         return new boolean[length];
1464     };
1465 
1466     static final IntFunction<long[]> lfr = (vl) -> {
1467         int length = BUFFER_REPS * vl;
1468         return new long[length];
1469     };
1470 
1471     static boolean eq(double a, double b) {
1472         return a == b;
1473     }
1474 
1475     static boolean neq(double a, double b) {
1476         return a != b;
1477     }
1478 
1479     static boolean lt(double a, double b) {
1480         return a < b;
1481     }
1482 
1483     static boolean le(double a, double b) {
1484         return a <= b;
1485     }
1486 
1487     static boolean gt(double a, double b) {
1488         return a > b;
1489     }
1490 
1491     static boolean ge(double a, double b) {
1492         return a >= b;
1493     }
1494 
1495     static double firstNonZero(double a, double b) {
1496         return Double.compare(a, (double) 0) != 0 ? a : b;
1497     }
1498 
1499     @Test
1500     static void smokeTest1() {
1501         DoubleVector three = DoubleVector.broadcast(SPECIES, (byte)-3);
1502         DoubleVector three2 = (DoubleVector) SPECIES.broadcast(-3);
1503         assert(three.eq(three2).allTrue());
1504         DoubleVector three3 = three2.broadcast(1).broadcast(-3);
1505         assert(three.eq(three3).allTrue());
1506         int scale = 2;
1507         Class<?> ETYPE = double.class;
1508         if (ETYPE == double.class || ETYPE == long.class)
1509             scale = 1000000;
1510         else if (ETYPE == byte.class && SPECIES.length() >= 64)
1511             scale = 1;
1512         DoubleVector higher = three.addIndex(scale);
1513         VectorMask<Double> m = three.compare(VectorOperators.LE, higher);
1514         assert(m.allTrue());
1515         m = higher.min((double)-1).test(VectorOperators.IS_NEGATIVE);
1516         assert(m.allTrue());
1517         m = higher.test(VectorOperators.IS_FINITE);
1518         assert(m.allTrue());
1519         double max = higher.reduceLanes(VectorOperators.MAX);
1520         assert(max == -3 + scale * (SPECIES.length()-1));
1521     }
1522 
1523     private static double[]
1524     bothToArray(DoubleVector a, DoubleVector b) {
1525         double[] r = new double[a.length() + b.length()];
1526         a.intoArray(r, 0);
1527         b.intoArray(r, a.length());
1528         return r;
1529     }
1530 
1531     @Test
1532     static void smokeTest2() {
1533         // Do some zipping and shuffling.
1534         DoubleVector io = (DoubleVector) SPECIES.broadcast(0).addIndex(1);
1535         DoubleVector io2 = (DoubleVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1536         Assert.assertEquals(io, io2);
1537         DoubleVector a = io.add((double)1); //[1,2]
1538         DoubleVector b = a.neg();  //[-1,-2]
1539         double[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1540         VectorShuffle<Double> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1541         VectorShuffle<Double> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1542         DoubleVector zab0 = a.rearrange(zip0,b); //[1,-1]
1543         DoubleVector zab1 = a.rearrange(zip1,b); //[2,-2]
1544         double[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1545         // manually zip
1546         double[] manual = new double[zabValues.length];
1547         for (int i = 0; i < manual.length; i += 2) {
1548             manual[i+0] = abValues[i/2];
1549             manual[i+1] = abValues[a.length() + i/2];
1550         }
1551         Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1552         VectorShuffle<Double> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1553         VectorShuffle<Double> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1554         DoubleVector uab0 = zab0.rearrange(unz0,zab1);
1555         DoubleVector uab1 = zab0.rearrange(unz1,zab1);
1556         double[] abValues1 = bothToArray(uab0, uab1);
1557         Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1558     }
1559 
1560     static void iotaShuffle() {
1561         DoubleVector io = (DoubleVector) SPECIES.broadcast(0).addIndex(1);
1562         DoubleVector io2 = (DoubleVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1563         Assert.assertEquals(io, io2);
1564     }
1565 
1566     @Test
1567     // Test all shuffle related operations.
1568     static void shuffleTest() {
1569         // To test backend instructions, make sure that C2 is used.
1570         for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1571             iotaShuffle();
1572         }
1573     }
1574 
1575     @Test
1576     void viewAsIntegeralLanesTest() {
1577         Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1578         VectorSpecies<?> asIntegralSpecies = asIntegral.species();
1579         Assert.assertNotEquals(asIntegralSpecies.elementType(), SPECIES.elementType());
1580         Assert.assertEquals(asIntegralSpecies.vectorShape(), SPECIES.vectorShape());
1581         Assert.assertEquals(asIntegralSpecies.length(), SPECIES.length());
1582         Assert.assertEquals(asIntegral.viewAsFloatingLanes().species(), SPECIES);
1583     }
1584 
1585     @Test
1586     void viewAsFloatingLanesTest() {
1587         Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
1588         Assert.assertEquals(asFloating.species(), SPECIES);
1589     }
1590 
1591     static double ADD(double a, double b) {
1592         return (double)(a + b);
1593     }
1594 
1595     @Test(dataProvider = "doubleBinaryOpProvider")
1596     static void ADDDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1597         double[] a = fa.apply(SPECIES.length());
1598         double[] b = fb.apply(SPECIES.length());
1599         double[] r = fr.apply(SPECIES.length());
1600 
1601         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1602             for (int i = 0; i < a.length; i += SPECIES.length()) {
1603                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1604                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1605                 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1606             }
1607         }
1608 
1609         assertArraysEquals(r, a, b, Double256VectorTests::ADD);
1610     }
1611 
1612     static double add(double a, double b) {
1613         return (double)(a + b);
1614     }
1615 
1616     @Test(dataProvider = "doubleBinaryOpProvider")
1617     static void addDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1618         double[] a = fa.apply(SPECIES.length());
1619         double[] b = fb.apply(SPECIES.length());
1620         double[] r = fr.apply(SPECIES.length());
1621 
1622         for (int i = 0; i < a.length; i += SPECIES.length()) {
1623             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1624             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1625             av.add(bv).intoArray(r, i);
1626         }
1627 
1628         assertArraysEquals(r, a, b, Double256VectorTests::add);
1629     }
1630 
1631     @Test(dataProvider = "doubleBinaryOpMaskProvider")
1632     static void ADDDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1633                                           IntFunction<boolean[]> fm) {
1634         double[] a = fa.apply(SPECIES.length());
1635         double[] b = fb.apply(SPECIES.length());
1636         double[] r = fr.apply(SPECIES.length());
1637         boolean[] mask = fm.apply(SPECIES.length());
1638         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1639 
1640         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1641             for (int i = 0; i < a.length; i += SPECIES.length()) {
1642                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1643                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1644                 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1645             }
1646         }
1647 
1648         assertArraysEquals(r, a, b, mask, Double256VectorTests::ADD);
1649     }
1650 
1651     @Test(dataProvider = "doubleBinaryOpMaskProvider")
1652     static void addDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1653                                           IntFunction<boolean[]> fm) {
1654         double[] a = fa.apply(SPECIES.length());
1655         double[] b = fb.apply(SPECIES.length());
1656         double[] r = fr.apply(SPECIES.length());
1657         boolean[] mask = fm.apply(SPECIES.length());
1658         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1659 
1660         for (int i = 0; i < a.length; i += SPECIES.length()) {
1661             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1662             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1663             av.add(bv, vmask).intoArray(r, i);
1664         }
1665 
1666         assertArraysEquals(r, a, b, mask, Double256VectorTests::add);
1667     }
1668 
1669     static double SUB(double a, double b) {
1670         return (double)(a - b);
1671     }
1672 
1673     @Test(dataProvider = "doubleBinaryOpProvider")
1674     static void SUBDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1675         double[] a = fa.apply(SPECIES.length());
1676         double[] b = fb.apply(SPECIES.length());
1677         double[] r = fr.apply(SPECIES.length());
1678 
1679         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1680             for (int i = 0; i < a.length; i += SPECIES.length()) {
1681                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1682                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1683                 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1684             }
1685         }
1686 
1687         assertArraysEquals(r, a, b, Double256VectorTests::SUB);
1688     }
1689 
1690     static double sub(double a, double b) {
1691         return (double)(a - b);
1692     }
1693 
1694     @Test(dataProvider = "doubleBinaryOpProvider")
1695     static void subDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1696         double[] a = fa.apply(SPECIES.length());
1697         double[] b = fb.apply(SPECIES.length());
1698         double[] r = fr.apply(SPECIES.length());
1699 
1700         for (int i = 0; i < a.length; i += SPECIES.length()) {
1701             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1702             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1703             av.sub(bv).intoArray(r, i);
1704         }
1705 
1706         assertArraysEquals(r, a, b, Double256VectorTests::sub);
1707     }
1708 
1709     @Test(dataProvider = "doubleBinaryOpMaskProvider")
1710     static void SUBDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1711                                           IntFunction<boolean[]> fm) {
1712         double[] a = fa.apply(SPECIES.length());
1713         double[] b = fb.apply(SPECIES.length());
1714         double[] r = fr.apply(SPECIES.length());
1715         boolean[] mask = fm.apply(SPECIES.length());
1716         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1717 
1718         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1719             for (int i = 0; i < a.length; i += SPECIES.length()) {
1720                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1721                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1722                 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1723             }
1724         }
1725 
1726         assertArraysEquals(r, a, b, mask, Double256VectorTests::SUB);
1727     }
1728 
1729     @Test(dataProvider = "doubleBinaryOpMaskProvider")
1730     static void subDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1731                                           IntFunction<boolean[]> fm) {
1732         double[] a = fa.apply(SPECIES.length());
1733         double[] b = fb.apply(SPECIES.length());
1734         double[] r = fr.apply(SPECIES.length());
1735         boolean[] mask = fm.apply(SPECIES.length());
1736         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1737 
1738         for (int i = 0; i < a.length; i += SPECIES.length()) {
1739             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1740             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1741             av.sub(bv, vmask).intoArray(r, i);
1742         }
1743 
1744         assertArraysEquals(r, a, b, mask, Double256VectorTests::sub);
1745     }
1746 
1747     static double MUL(double a, double b) {
1748         return (double)(a * b);
1749     }
1750 
1751     @Test(dataProvider = "doubleBinaryOpProvider")
1752     static void MULDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1753         double[] a = fa.apply(SPECIES.length());
1754         double[] b = fb.apply(SPECIES.length());
1755         double[] r = fr.apply(SPECIES.length());
1756 
1757         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1758             for (int i = 0; i < a.length; i += SPECIES.length()) {
1759                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1760                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1761                 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1762             }
1763         }
1764 
1765         assertArraysEquals(r, a, b, Double256VectorTests::MUL);
1766     }
1767 
1768     static double mul(double a, double b) {
1769         return (double)(a * b);
1770     }
1771 
1772     @Test(dataProvider = "doubleBinaryOpProvider")
1773     static void mulDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1774         double[] a = fa.apply(SPECIES.length());
1775         double[] b = fb.apply(SPECIES.length());
1776         double[] r = fr.apply(SPECIES.length());
1777 
1778         for (int i = 0; i < a.length; i += SPECIES.length()) {
1779             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1780             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1781             av.mul(bv).intoArray(r, i);
1782         }
1783 
1784         assertArraysEquals(r, a, b, Double256VectorTests::mul);
1785     }
1786 
1787     @Test(dataProvider = "doubleBinaryOpMaskProvider")
1788     static void MULDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1789                                           IntFunction<boolean[]> fm) {
1790         double[] a = fa.apply(SPECIES.length());
1791         double[] b = fb.apply(SPECIES.length());
1792         double[] r = fr.apply(SPECIES.length());
1793         boolean[] mask = fm.apply(SPECIES.length());
1794         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1795 
1796         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1797             for (int i = 0; i < a.length; i += SPECIES.length()) {
1798                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1799                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1800                 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1801             }
1802         }
1803 
1804         assertArraysEquals(r, a, b, mask, Double256VectorTests::MUL);
1805     }
1806 
1807     @Test(dataProvider = "doubleBinaryOpMaskProvider")
1808     static void mulDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1809                                           IntFunction<boolean[]> fm) {
1810         double[] a = fa.apply(SPECIES.length());
1811         double[] b = fb.apply(SPECIES.length());
1812         double[] r = fr.apply(SPECIES.length());
1813         boolean[] mask = fm.apply(SPECIES.length());
1814         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1815 
1816         for (int i = 0; i < a.length; i += SPECIES.length()) {
1817             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1818             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1819             av.mul(bv, vmask).intoArray(r, i);
1820         }
1821 
1822         assertArraysEquals(r, a, b, mask, Double256VectorTests::mul);
1823     }
1824 
1825     static double DIV(double a, double b) {
1826         return (double)(a / b);
1827     }
1828 
1829     @Test(dataProvider = "doubleBinaryOpProvider")
1830     static void DIVDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1831         double[] a = fa.apply(SPECIES.length());
1832         double[] b = fb.apply(SPECIES.length());
1833         double[] r = fr.apply(SPECIES.length());
1834 
1835         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1836             for (int i = 0; i < a.length; i += SPECIES.length()) {
1837                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1838                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1839                 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1840             }
1841         }
1842 
1843         assertArraysEquals(r, a, b, Double256VectorTests::DIV);
1844     }
1845 
1846     static double div(double a, double b) {
1847         return (double)(a / b);
1848     }
1849 
1850     @Test(dataProvider = "doubleBinaryOpProvider")
1851     static void divDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1852         double[] a = fa.apply(SPECIES.length());
1853         double[] b = fb.apply(SPECIES.length());
1854         double[] r = fr.apply(SPECIES.length());
1855 
1856         for (int i = 0; i < a.length; i += SPECIES.length()) {
1857             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1858             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1859             av.div(bv).intoArray(r, i);
1860         }
1861 
1862         assertArraysEquals(r, a, b, Double256VectorTests::div);
1863     }
1864 
1865     @Test(dataProvider = "doubleBinaryOpMaskProvider")
1866     static void DIVDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1867                                           IntFunction<boolean[]> fm) {
1868         double[] a = fa.apply(SPECIES.length());
1869         double[] b = fb.apply(SPECIES.length());
1870         double[] r = fr.apply(SPECIES.length());
1871         boolean[] mask = fm.apply(SPECIES.length());
1872         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1873 
1874         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1875             for (int i = 0; i < a.length; i += SPECIES.length()) {
1876                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1877                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1878                 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1879             }
1880         }
1881 
1882         assertArraysEquals(r, a, b, mask, Double256VectorTests::DIV);
1883     }
1884 
1885     @Test(dataProvider = "doubleBinaryOpMaskProvider")
1886     static void divDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1887                                           IntFunction<boolean[]> fm) {
1888         double[] a = fa.apply(SPECIES.length());
1889         double[] b = fb.apply(SPECIES.length());
1890         double[] r = fr.apply(SPECIES.length());
1891         boolean[] mask = fm.apply(SPECIES.length());
1892         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1893 
1894         for (int i = 0; i < a.length; i += SPECIES.length()) {
1895             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1896             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1897             av.div(bv, vmask).intoArray(r, i);
1898         }
1899 
1900         assertArraysEquals(r, a, b, mask, Double256VectorTests::div);
1901     }
1902 
1903     static double FIRST_NONZERO(double a, double b) {
1904         return (double)(Double.doubleToLongBits(a)!=0?a:b);
1905     }
1906 
1907     @Test(dataProvider = "doubleBinaryOpProvider")
1908     static void FIRST_NONZERODouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1909         double[] a = fa.apply(SPECIES.length());
1910         double[] b = fb.apply(SPECIES.length());
1911         double[] r = fr.apply(SPECIES.length());
1912 
1913         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1914             for (int i = 0; i < a.length; i += SPECIES.length()) {
1915                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1916                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1917                 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1918             }
1919         }
1920 
1921         assertArraysEquals(r, a, b, Double256VectorTests::FIRST_NONZERO);
1922     }
1923 
1924     @Test(dataProvider = "doubleBinaryOpMaskProvider")
1925     static void FIRST_NONZERODouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1926                                           IntFunction<boolean[]> fm) {
1927         double[] a = fa.apply(SPECIES.length());
1928         double[] b = fb.apply(SPECIES.length());
1929         double[] r = fr.apply(SPECIES.length());
1930         boolean[] mask = fm.apply(SPECIES.length());
1931         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1932 
1933         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1934             for (int i = 0; i < a.length; i += SPECIES.length()) {
1935                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1936                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1937                 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1938             }
1939         }
1940 
1941         assertArraysEquals(r, a, b, mask, Double256VectorTests::FIRST_NONZERO);
1942     }
1943 
1944     @Test(dataProvider = "doubleBinaryOpProvider")
1945     static void addDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1946         double[] a = fa.apply(SPECIES.length());
1947         double[] b = fb.apply(SPECIES.length());
1948         double[] r = fr.apply(SPECIES.length());
1949 
1950         for (int i = 0; i < a.length; i += SPECIES.length()) {
1951             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1952             av.add(b[i]).intoArray(r, i);
1953         }
1954 
1955         assertBroadcastArraysEquals(r, a, b, Double256VectorTests::add);
1956     }
1957 
1958     @Test(dataProvider = "doubleBinaryOpMaskProvider")
1959     static void addDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
1960                                           IntFunction<boolean[]> fm) {
1961         double[] a = fa.apply(SPECIES.length());
1962         double[] b = fb.apply(SPECIES.length());
1963         double[] r = fr.apply(SPECIES.length());
1964         boolean[] mask = fm.apply(SPECIES.length());
1965         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1966 
1967         for (int i = 0; i < a.length; i += SPECIES.length()) {
1968             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1969             av.add(b[i], vmask).intoArray(r, i);
1970         }
1971 
1972         assertBroadcastArraysEquals(r, a, b, mask, Double256VectorTests::add);
1973     }
1974 
1975     @Test(dataProvider = "doubleBinaryOpProvider")
1976     static void subDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1977         double[] a = fa.apply(SPECIES.length());
1978         double[] b = fb.apply(SPECIES.length());
1979         double[] r = fr.apply(SPECIES.length());
1980 
1981         for (int i = 0; i < a.length; i += SPECIES.length()) {
1982             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1983             av.sub(b[i]).intoArray(r, i);
1984         }
1985 
1986         assertBroadcastArraysEquals(r, a, b, Double256VectorTests::sub);
1987     }
1988 
1989     @Test(dataProvider = "doubleBinaryOpMaskProvider")
1990     static void subDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
1991                                           IntFunction<boolean[]> fm) {
1992         double[] a = fa.apply(SPECIES.length());
1993         double[] b = fb.apply(SPECIES.length());
1994         double[] r = fr.apply(SPECIES.length());
1995         boolean[] mask = fm.apply(SPECIES.length());
1996         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1997 
1998         for (int i = 0; i < a.length; i += SPECIES.length()) {
1999             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2000             av.sub(b[i], vmask).intoArray(r, i);
2001         }
2002 
2003         assertBroadcastArraysEquals(r, a, b, mask, Double256VectorTests::sub);
2004     }
2005 
2006     @Test(dataProvider = "doubleBinaryOpProvider")
2007     static void mulDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2008         double[] a = fa.apply(SPECIES.length());
2009         double[] b = fb.apply(SPECIES.length());
2010         double[] r = fr.apply(SPECIES.length());
2011 
2012         for (int i = 0; i < a.length; i += SPECIES.length()) {
2013             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2014             av.mul(b[i]).intoArray(r, i);
2015         }
2016 
2017         assertBroadcastArraysEquals(r, a, b, Double256VectorTests::mul);
2018     }
2019 
2020     @Test(dataProvider = "doubleBinaryOpMaskProvider")
2021     static void mulDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
2022                                           IntFunction<boolean[]> fm) {
2023         double[] a = fa.apply(SPECIES.length());
2024         double[] b = fb.apply(SPECIES.length());
2025         double[] r = fr.apply(SPECIES.length());
2026         boolean[] mask = fm.apply(SPECIES.length());
2027         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2028 
2029         for (int i = 0; i < a.length; i += SPECIES.length()) {
2030             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2031             av.mul(b[i], vmask).intoArray(r, i);
2032         }
2033 
2034         assertBroadcastArraysEquals(r, a, b, mask, Double256VectorTests::mul);
2035     }
2036 
2037     @Test(dataProvider = "doubleBinaryOpProvider")
2038     static void divDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2039         double[] a = fa.apply(SPECIES.length());
2040         double[] b = fb.apply(SPECIES.length());
2041         double[] r = fr.apply(SPECIES.length());
2042 
2043         for (int i = 0; i < a.length; i += SPECIES.length()) {
2044             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2045             av.div(b[i]).intoArray(r, i);
2046         }
2047 
2048         assertBroadcastArraysEquals(r, a, b, Double256VectorTests::div);
2049     }
2050 
2051     @Test(dataProvider = "doubleBinaryOpMaskProvider")
2052     static void divDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
2053                                           IntFunction<boolean[]> fm) {
2054         double[] a = fa.apply(SPECIES.length());
2055         double[] b = fb.apply(SPECIES.length());
2056         double[] r = fr.apply(SPECIES.length());
2057         boolean[] mask = fm.apply(SPECIES.length());
2058         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2059 
2060         for (int i = 0; i < a.length; i += SPECIES.length()) {
2061             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2062             av.div(b[i], vmask).intoArray(r, i);
2063         }
2064 
2065         assertBroadcastArraysEquals(r, a, b, mask, Double256VectorTests::div);
2066     }
2067 
2068     @Test(dataProvider = "doubleBinaryOpProvider")
2069     static void ADDDouble256VectorTestsBroadcastLongSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2070         double[] a = fa.apply(SPECIES.length());
2071         double[] b = fb.apply(SPECIES.length());
2072         double[] r = fr.apply(SPECIES.length());
2073 
2074         for (int i = 0; i < a.length; i += SPECIES.length()) {
2075             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2076             av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2077         }
2078 
2079         assertBroadcastLongArraysEquals(r, a, b, Double256VectorTests::ADD);
2080     }
2081 
2082     @Test(dataProvider = "doubleBinaryOpMaskProvider")
2083     static void ADDDouble256VectorTestsBroadcastMaskedLongSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
2084                                           IntFunction<boolean[]> fm) {
2085         double[] a = fa.apply(SPECIES.length());
2086         double[] b = fb.apply(SPECIES.length());
2087         double[] r = fr.apply(SPECIES.length());
2088         boolean[] mask = fm.apply(SPECIES.length());
2089         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2090 
2091         for (int i = 0; i < a.length; i += SPECIES.length()) {
2092             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2093             av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2094         }
2095 
2096         assertBroadcastLongArraysEquals(r, a, b, mask, Double256VectorTests::ADD);
2097     }
2098 
2099     static DoubleVector bv_MIN = DoubleVector.broadcast(SPECIES, (double)10);
2100 
2101     @Test(dataProvider = "doubleUnaryOpProvider")
2102     static void MINDouble256VectorTestsWithMemOp(IntFunction<double[]> fa) {
2103         double[] a = fa.apply(SPECIES.length());
2104         double[] r = fr.apply(SPECIES.length());
2105 
2106         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2107             for (int i = 0; i < a.length; i += SPECIES.length()) {
2108                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2109                 av.lanewise(VectorOperators.MIN, bv_MIN).intoArray(r, i);
2110             }
2111         }
2112 
2113         assertArraysEquals(r, a, (double)10, Double256VectorTests::MIN);
2114     }
2115 
2116     static DoubleVector bv_min = DoubleVector.broadcast(SPECIES, (double)10);
2117 
2118     @Test(dataProvider = "doubleUnaryOpProvider")
2119     static void minDouble256VectorTestsWithMemOp(IntFunction<double[]> fa) {
2120         double[] a = fa.apply(SPECIES.length());
2121         double[] r = fr.apply(SPECIES.length());
2122 
2123         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2124             for (int i = 0; i < a.length; i += SPECIES.length()) {
2125                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2126                 av.min(bv_min).intoArray(r, i);
2127             }
2128         }
2129 
2130         assertArraysEquals(r, a, (double)10, Double256VectorTests::min);
2131     }
2132 
2133     static DoubleVector bv_MIN_M = DoubleVector.broadcast(SPECIES, (double)10);
2134 
2135     @Test(dataProvider = "doubleUnaryOpMaskProvider")
2136     static void MINDouble256VectorTestsMaskedWithMemOp(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2137         double[] a = fa.apply(SPECIES.length());
2138         double[] r = fr.apply(SPECIES.length());
2139         boolean[] mask = fm.apply(SPECIES.length());
2140         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2141 
2142         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2143             for (int i = 0; i < a.length; i += SPECIES.length()) {
2144                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2145                 av.lanewise(VectorOperators.MIN, bv_MIN_M, vmask).intoArray(r, i);
2146             }
2147         }
2148 
2149         assertArraysEquals(r, a, (double)10, mask, Double256VectorTests::MIN);
2150     }
2151 
2152     static DoubleVector bv_MAX = DoubleVector.broadcast(SPECIES, (double)10);
2153 
2154     @Test(dataProvider = "doubleUnaryOpProvider")
2155     static void MAXDouble256VectorTestsWithMemOp(IntFunction<double[]> fa) {
2156         double[] a = fa.apply(SPECIES.length());
2157         double[] r = fr.apply(SPECIES.length());
2158 
2159         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2160             for (int i = 0; i < a.length; i += SPECIES.length()) {
2161                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2162                 av.lanewise(VectorOperators.MAX, bv_MAX).intoArray(r, i);
2163             }
2164         }
2165 
2166         assertArraysEquals(r, a, (double)10, Double256VectorTests::MAX);
2167     }
2168 
2169     static DoubleVector bv_max = DoubleVector.broadcast(SPECIES, (double)10);
2170 
2171     @Test(dataProvider = "doubleUnaryOpProvider")
2172     static void maxDouble256VectorTestsWithMemOp(IntFunction<double[]> fa) {
2173         double[] a = fa.apply(SPECIES.length());
2174         double[] r = fr.apply(SPECIES.length());
2175 
2176         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2177             for (int i = 0; i < a.length; i += SPECIES.length()) {
2178                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2179                 av.max(bv_max).intoArray(r, i);
2180             }
2181         }
2182 
2183         assertArraysEquals(r, a, (double)10, Double256VectorTests::max);
2184     }
2185 
2186     static DoubleVector bv_MAX_M = DoubleVector.broadcast(SPECIES, (double)10);
2187 
2188     @Test(dataProvider = "doubleUnaryOpMaskProvider")
2189     static void MAXDouble256VectorTestsMaskedWithMemOp(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2190         double[] a = fa.apply(SPECIES.length());
2191         double[] r = fr.apply(SPECIES.length());
2192         boolean[] mask = fm.apply(SPECIES.length());
2193         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2194 
2195         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2196             for (int i = 0; i < a.length; i += SPECIES.length()) {
2197                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2198                 av.lanewise(VectorOperators.MAX, bv_MAX_M, vmask).intoArray(r, i);
2199             }
2200         }
2201 
2202         assertArraysEquals(r, a, (double)10, mask, Double256VectorTests::MAX);
2203     }
2204 
2205     static double MIN(double a, double b) {
2206         return (double)(Math.min(a, b));
2207     }
2208 
2209     @Test(dataProvider = "doubleBinaryOpProvider")
2210     static void MINDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2211         double[] a = fa.apply(SPECIES.length());
2212         double[] b = fb.apply(SPECIES.length());
2213         double[] r = fr.apply(SPECIES.length());
2214 
2215         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2216             for (int i = 0; i < a.length; i += SPECIES.length()) {
2217                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2218                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
2219                 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
2220             }
2221         }
2222 
2223         assertArraysEquals(r, a, b, Double256VectorTests::MIN);
2224     }
2225 
2226     static double min(double a, double b) {
2227         return (double)(Math.min(a, b));
2228     }
2229 
2230     @Test(dataProvider = "doubleBinaryOpProvider")
2231     static void minDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2232         double[] a = fa.apply(SPECIES.length());
2233         double[] b = fb.apply(SPECIES.length());
2234         double[] r = fr.apply(SPECIES.length());
2235 
2236         for (int i = 0; i < a.length; i += SPECIES.length()) {
2237             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2238             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
2239             av.min(bv).intoArray(r, i);
2240         }
2241 
2242         assertArraysEquals(r, a, b, Double256VectorTests::min);
2243     }
2244 
2245     static double MAX(double a, double b) {
2246         return (double)(Math.max(a, b));
2247     }
2248 
2249     @Test(dataProvider = "doubleBinaryOpProvider")
2250     static void MAXDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2251         double[] a = fa.apply(SPECIES.length());
2252         double[] b = fb.apply(SPECIES.length());
2253         double[] r = fr.apply(SPECIES.length());
2254 
2255         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2256             for (int i = 0; i < a.length; i += SPECIES.length()) {
2257                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2258                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
2259                 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
2260             }
2261         }
2262 
2263         assertArraysEquals(r, a, b, Double256VectorTests::MAX);
2264     }
2265 
2266     static double max(double a, double b) {
2267         return (double)(Math.max(a, b));
2268     }
2269 
2270     @Test(dataProvider = "doubleBinaryOpProvider")
2271     static void maxDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2272         double[] a = fa.apply(SPECIES.length());
2273         double[] b = fb.apply(SPECIES.length());
2274         double[] r = fr.apply(SPECIES.length());
2275 
2276         for (int i = 0; i < a.length; i += SPECIES.length()) {
2277             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2278             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
2279             av.max(bv).intoArray(r, i);
2280         }
2281 
2282         assertArraysEquals(r, a, b, Double256VectorTests::max);
2283     }
2284 
2285     @Test(dataProvider = "doubleBinaryOpProvider")
2286     static void MINDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2287         double[] a = fa.apply(SPECIES.length());
2288         double[] b = fb.apply(SPECIES.length());
2289         double[] r = fr.apply(SPECIES.length());
2290 
2291         for (int i = 0; i < a.length; i += SPECIES.length()) {
2292             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2293             av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
2294         }
2295 
2296         assertBroadcastArraysEquals(r, a, b, Double256VectorTests::MIN);
2297     }
2298 
2299     @Test(dataProvider = "doubleBinaryOpProvider")
2300     static void minDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2301         double[] a = fa.apply(SPECIES.length());
2302         double[] b = fb.apply(SPECIES.length());
2303         double[] r = fr.apply(SPECIES.length());
2304 
2305         for (int i = 0; i < a.length; i += SPECIES.length()) {
2306             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2307             av.min(b[i]).intoArray(r, i);
2308         }
2309 
2310         assertBroadcastArraysEquals(r, a, b, Double256VectorTests::min);
2311     }
2312 
2313     @Test(dataProvider = "doubleBinaryOpProvider")
2314     static void MAXDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2315         double[] a = fa.apply(SPECIES.length());
2316         double[] b = fb.apply(SPECIES.length());
2317         double[] r = fr.apply(SPECIES.length());
2318 
2319         for (int i = 0; i < a.length; i += SPECIES.length()) {
2320             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2321             av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
2322         }
2323 
2324         assertBroadcastArraysEquals(r, a, b, Double256VectorTests::MAX);
2325     }
2326 
2327     @Test(dataProvider = "doubleBinaryOpProvider")
2328     static void maxDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2329         double[] a = fa.apply(SPECIES.length());
2330         double[] b = fb.apply(SPECIES.length());
2331         double[] r = fr.apply(SPECIES.length());
2332 
2333         for (int i = 0; i < a.length; i += SPECIES.length()) {
2334             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2335             av.max(b[i]).intoArray(r, i);
2336         }
2337 
2338         assertBroadcastArraysEquals(r, a, b, Double256VectorTests::max);
2339     }
2340 
2341     static double ADDReduce(double[] a, int idx) {
2342         double res = 0;
2343         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2344             res += a[i];
2345         }
2346 
2347         return res;
2348     }
2349 
2350     static double ADDReduceAll(double[] a) {
2351         double res = 0;
2352         for (int i = 0; i < a.length; i += SPECIES.length()) {
2353             res += ADDReduce(a, i);
2354         }
2355 
2356         return res;
2357     }
2358 
2359     @Test(dataProvider = "doubleUnaryOpProvider")
2360     static void ADDReduceDouble256VectorTests(IntFunction<double[]> fa) {
2361         double[] a = fa.apply(SPECIES.length());
2362         double[] r = fr.apply(SPECIES.length());
2363         double ra = 0;
2364 
2365         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2366             for (int i = 0; i < a.length; i += SPECIES.length()) {
2367                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2368                 r[i] = av.reduceLanes(VectorOperators.ADD);
2369             }
2370         }
2371 
2372         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2373             ra = 0;
2374             for (int i = 0; i < a.length; i += SPECIES.length()) {
2375                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2376                 ra += av.reduceLanes(VectorOperators.ADD);
2377             }
2378         }
2379 
2380         assertReductionArraysEquals(r, ra, a,
2381                 Double256VectorTests::ADDReduce, Double256VectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD);
2382     }
2383 
2384     static double ADDReduceMasked(double[] a, int idx, boolean[] mask) {
2385         double res = 0;
2386         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2387             if (mask[i % SPECIES.length()])
2388                 res += a[i];
2389         }
2390 
2391         return res;
2392     }
2393 
2394     static double ADDReduceAllMasked(double[] a, boolean[] mask) {
2395         double res = 0;
2396         for (int i = 0; i < a.length; i += SPECIES.length()) {
2397             res += ADDReduceMasked(a, i, mask);
2398         }
2399 
2400         return res;
2401     }
2402 
2403     @Test(dataProvider = "doubleUnaryOpMaskProvider")
2404     static void ADDReduceDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2405         double[] a = fa.apply(SPECIES.length());
2406         double[] r = fr.apply(SPECIES.length());
2407         boolean[] mask = fm.apply(SPECIES.length());
2408         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2409         double ra = 0;
2410 
2411         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2412             for (int i = 0; i < a.length; i += SPECIES.length()) {
2413                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2414                 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
2415             }
2416         }
2417 
2418         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2419             ra = 0;
2420             for (int i = 0; i < a.length; i += SPECIES.length()) {
2421                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2422                 ra += av.reduceLanes(VectorOperators.ADD, vmask);
2423             }
2424         }
2425 
2426         assertReductionArraysEqualsMasked(r, ra, a, mask,
2427                 Double256VectorTests::ADDReduceMasked, Double256VectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD);
2428     }
2429 
2430     static double MULReduce(double[] a, int idx) {
2431         double res = 1;
2432         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2433             res *= a[i];
2434         }
2435 
2436         return res;
2437     }
2438 
2439     static double MULReduceAll(double[] a) {
2440         double res = 1;
2441         for (int i = 0; i < a.length; i += SPECIES.length()) {
2442             res *= MULReduce(a, i);
2443         }
2444 
2445         return res;
2446     }
2447 
2448     @Test(dataProvider = "doubleUnaryOpProvider")
2449     static void MULReduceDouble256VectorTests(IntFunction<double[]> fa) {
2450         double[] a = fa.apply(SPECIES.length());
2451         double[] r = fr.apply(SPECIES.length());
2452         double ra = 1;
2453 
2454         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2455             for (int i = 0; i < a.length; i += SPECIES.length()) {
2456                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2457                 r[i] = av.reduceLanes(VectorOperators.MUL);
2458             }
2459         }
2460 
2461         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2462             ra = 1;
2463             for (int i = 0; i < a.length; i += SPECIES.length()) {
2464                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2465                 ra *= av.reduceLanes(VectorOperators.MUL);
2466             }
2467         }
2468 
2469         assertReductionArraysEquals(r, ra, a,
2470                 Double256VectorTests::MULReduce, Double256VectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL);
2471     }
2472 
2473     static double MULReduceMasked(double[] a, int idx, boolean[] mask) {
2474         double res = 1;
2475         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2476             if (mask[i % SPECIES.length()])
2477                 res *= a[i];
2478         }
2479 
2480         return res;
2481     }
2482 
2483     static double MULReduceAllMasked(double[] a, boolean[] mask) {
2484         double res = 1;
2485         for (int i = 0; i < a.length; i += SPECIES.length()) {
2486             res *= MULReduceMasked(a, i, mask);
2487         }
2488 
2489         return res;
2490     }
2491 
2492     @Test(dataProvider = "doubleUnaryOpMaskProvider")
2493     static void MULReduceDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2494         double[] a = fa.apply(SPECIES.length());
2495         double[] r = fr.apply(SPECIES.length());
2496         boolean[] mask = fm.apply(SPECIES.length());
2497         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2498         double ra = 1;
2499 
2500         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2501             for (int i = 0; i < a.length; i += SPECIES.length()) {
2502                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2503                 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
2504             }
2505         }
2506 
2507         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2508             ra = 1;
2509             for (int i = 0; i < a.length; i += SPECIES.length()) {
2510                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2511                 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
2512             }
2513         }
2514 
2515         assertReductionArraysEqualsMasked(r, ra, a, mask,
2516                 Double256VectorTests::MULReduceMasked, Double256VectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL);
2517     }
2518 
2519     static double MINReduce(double[] a, int idx) {
2520         double res = Double.POSITIVE_INFINITY;
2521         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2522             res = (double) Math.min(res, a[i]);
2523         }
2524 
2525         return res;
2526     }
2527 
2528     static double MINReduceAll(double[] a) {
2529         double res = Double.POSITIVE_INFINITY;
2530         for (int i = 0; i < a.length; i += SPECIES.length()) {
2531             res = (double) Math.min(res, MINReduce(a, i));
2532         }
2533 
2534         return res;
2535     }
2536 
2537     @Test(dataProvider = "doubleUnaryOpProvider")
2538     static void MINReduceDouble256VectorTests(IntFunction<double[]> fa) {
2539         double[] a = fa.apply(SPECIES.length());
2540         double[] r = fr.apply(SPECIES.length());
2541         double ra = Double.POSITIVE_INFINITY;
2542 
2543         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2544             for (int i = 0; i < a.length; i += SPECIES.length()) {
2545                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2546                 r[i] = av.reduceLanes(VectorOperators.MIN);
2547             }
2548         }
2549 
2550         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2551             ra = Double.POSITIVE_INFINITY;
2552             for (int i = 0; i < a.length; i += SPECIES.length()) {
2553                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2554                 ra = (double) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
2555             }
2556         }
2557 
2558         assertReductionArraysEquals(r, ra, a,
2559                 Double256VectorTests::MINReduce, Double256VectorTests::MINReduceAll);
2560     }
2561 
2562     static double MINReduceMasked(double[] a, int idx, boolean[] mask) {
2563         double res = Double.POSITIVE_INFINITY;
2564         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2565             if (mask[i % SPECIES.length()])
2566                 res = (double) Math.min(res, a[i]);
2567         }
2568 
2569         return res;
2570     }
2571 
2572     static double MINReduceAllMasked(double[] a, boolean[] mask) {
2573         double res = Double.POSITIVE_INFINITY;
2574         for (int i = 0; i < a.length; i += SPECIES.length()) {
2575             res = (double) Math.min(res, MINReduceMasked(a, i, mask));
2576         }
2577 
2578         return res;
2579     }
2580 
2581     @Test(dataProvider = "doubleUnaryOpMaskProvider")
2582     static void MINReduceDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2583         double[] a = fa.apply(SPECIES.length());
2584         double[] r = fr.apply(SPECIES.length());
2585         boolean[] mask = fm.apply(SPECIES.length());
2586         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2587         double ra = Double.POSITIVE_INFINITY;
2588 
2589         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2590             for (int i = 0; i < a.length; i += SPECIES.length()) {
2591                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2592                 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
2593             }
2594         }
2595 
2596         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2597             ra = Double.POSITIVE_INFINITY;
2598             for (int i = 0; i < a.length; i += SPECIES.length()) {
2599                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2600                 ra = (double) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
2601             }
2602         }
2603 
2604         assertReductionArraysEqualsMasked(r, ra, a, mask,
2605                 Double256VectorTests::MINReduceMasked, Double256VectorTests::MINReduceAllMasked);
2606     }
2607 
2608     static double MAXReduce(double[] a, int idx) {
2609         double res = Double.NEGATIVE_INFINITY;
2610         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2611             res = (double) Math.max(res, a[i]);
2612         }
2613 
2614         return res;
2615     }
2616 
2617     static double MAXReduceAll(double[] a) {
2618         double res = Double.NEGATIVE_INFINITY;
2619         for (int i = 0; i < a.length; i += SPECIES.length()) {
2620             res = (double) Math.max(res, MAXReduce(a, i));
2621         }
2622 
2623         return res;
2624     }
2625 
2626     @Test(dataProvider = "doubleUnaryOpProvider")
2627     static void MAXReduceDouble256VectorTests(IntFunction<double[]> fa) {
2628         double[] a = fa.apply(SPECIES.length());
2629         double[] r = fr.apply(SPECIES.length());
2630         double ra = Double.NEGATIVE_INFINITY;
2631 
2632         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2633             for (int i = 0; i < a.length; i += SPECIES.length()) {
2634                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2635                 r[i] = av.reduceLanes(VectorOperators.MAX);
2636             }
2637         }
2638 
2639         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2640             ra = Double.NEGATIVE_INFINITY;
2641             for (int i = 0; i < a.length; i += SPECIES.length()) {
2642                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2643                 ra = (double) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
2644             }
2645         }
2646 
2647         assertReductionArraysEquals(r, ra, a,
2648                 Double256VectorTests::MAXReduce, Double256VectorTests::MAXReduceAll);
2649     }
2650 
2651     static double MAXReduceMasked(double[] a, int idx, boolean[] mask) {
2652         double res = Double.NEGATIVE_INFINITY;
2653         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2654             if (mask[i % SPECIES.length()])
2655                 res = (double) Math.max(res, a[i]);
2656         }
2657 
2658         return res;
2659     }
2660 
2661     static double MAXReduceAllMasked(double[] a, boolean[] mask) {
2662         double res = Double.NEGATIVE_INFINITY;
2663         for (int i = 0; i < a.length; i += SPECIES.length()) {
2664             res = (double) Math.max(res, MAXReduceMasked(a, i, mask));
2665         }
2666 
2667         return res;
2668     }
2669 
2670     @Test(dataProvider = "doubleUnaryOpMaskProvider")
2671     static void MAXReduceDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2672         double[] a = fa.apply(SPECIES.length());
2673         double[] r = fr.apply(SPECIES.length());
2674         boolean[] mask = fm.apply(SPECIES.length());
2675         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2676         double ra = Double.NEGATIVE_INFINITY;
2677 
2678         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2679             for (int i = 0; i < a.length; i += SPECIES.length()) {
2680                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2681                 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
2682             }
2683         }
2684 
2685         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2686             ra = Double.NEGATIVE_INFINITY;
2687             for (int i = 0; i < a.length; i += SPECIES.length()) {
2688                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2689                 ra = (double) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
2690             }
2691         }
2692 
2693         assertReductionArraysEqualsMasked(r, ra, a, mask,
2694                 Double256VectorTests::MAXReduceMasked, Double256VectorTests::MAXReduceAllMasked);
2695     }
2696 
2697     static double FIRST_NONZEROReduce(double[] a, int idx) {
2698         double res = (double) 0;
2699         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2700             res = firstNonZero(res, a[i]);
2701         }
2702 
2703         return res;
2704     }
2705 
2706     static double FIRST_NONZEROReduceAll(double[] a) {
2707         double res = (double) 0;
2708         for (int i = 0; i < a.length; i += SPECIES.length()) {
2709             res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
2710         }
2711 
2712         return res;
2713     }
2714 
2715     @Test(dataProvider = "doubleUnaryOpProvider")
2716     static void FIRST_NONZEROReduceDouble256VectorTests(IntFunction<double[]> fa) {
2717         double[] a = fa.apply(SPECIES.length());
2718         double[] r = fr.apply(SPECIES.length());
2719         double ra = (double) 0;
2720 
2721         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2722             for (int i = 0; i < a.length; i += SPECIES.length()) {
2723                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2724                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO);
2725             }
2726         }
2727 
2728         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2729             ra = (double) 0;
2730             for (int i = 0; i < a.length; i += SPECIES.length()) {
2731                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2732                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
2733             }
2734         }
2735 
2736         assertReductionArraysEquals(r, ra, a,
2737                 Double256VectorTests::FIRST_NONZEROReduce, Double256VectorTests::FIRST_NONZEROReduceAll);
2738     }
2739 
2740     static double FIRST_NONZEROReduceMasked(double[] a, int idx, boolean[] mask) {
2741         double res = (double) 0;
2742         for (int i = idx; i < (idx + SPECIES.length()); i++) {
2743             if (mask[i % SPECIES.length()])
2744                 res = firstNonZero(res, a[i]);
2745         }
2746 
2747         return res;
2748     }
2749 
2750     static double FIRST_NONZEROReduceAllMasked(double[] a, boolean[] mask) {
2751         double res = (double) 0;
2752         for (int i = 0; i < a.length; i += SPECIES.length()) {
2753             res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
2754         }
2755 
2756         return res;
2757     }
2758 
2759     @Test(dataProvider = "doubleUnaryOpMaskProvider")
2760     static void FIRST_NONZEROReduceDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2761         double[] a = fa.apply(SPECIES.length());
2762         double[] r = fr.apply(SPECIES.length());
2763         boolean[] mask = fm.apply(SPECIES.length());
2764         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2765         double ra = (double) 0;
2766 
2767         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2768             for (int i = 0; i < a.length; i += SPECIES.length()) {
2769                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2770                 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask);
2771             }
2772         }
2773 
2774         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2775             ra = (double) 0;
2776             for (int i = 0; i < a.length; i += SPECIES.length()) {
2777                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2778                 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
2779             }
2780         }
2781 
2782         assertReductionArraysEqualsMasked(r, ra, a, mask,
2783                 Double256VectorTests::FIRST_NONZEROReduceMasked, Double256VectorTests::FIRST_NONZEROReduceAllMasked);
2784     }
2785 
2786     @Test(dataProvider = "doubleBinaryOpProvider")
2787     static void withDouble256VectorTests(IntFunction<double []> fa, IntFunction<double []> fb) {
2788         double[] a = fa.apply(SPECIES.length());
2789         double[] b = fb.apply(SPECIES.length());
2790         double[] r = fr.apply(SPECIES.length());
2791 
2792         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2793             for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
2794                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2795                 av.withLane(j, b[i + j]).intoArray(r, i);
2796                 a[i + j] = b[i + j];
2797                 j = (j + 1) & (SPECIES.length() - 1);
2798             }
2799         }
2800 
2801 
2802         assertArraysStrictlyEquals(r, a);
2803     }
2804 
2805     static boolean testIS_DEFAULT(double a) {
2806         return bits(a)==0;
2807     }
2808 
2809     @Test(dataProvider = "doubleTestOpProvider")
2810     static void IS_DEFAULTDouble256VectorTests(IntFunction<double[]> fa) {
2811         double[] a = fa.apply(SPECIES.length());
2812 
2813         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2814             for (int i = 0; i < a.length; i += SPECIES.length()) {
2815                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2816                 VectorMask<Double> mv = av.test(VectorOperators.IS_DEFAULT);
2817 
2818                 // Check results as part of computation.
2819                 for (int j = 0; j < SPECIES.length(); j++) {
2820                     Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
2821                 }
2822             }
2823         }
2824     }
2825 
2826     @Test(dataProvider = "doubleTestOpMaskProvider")
2827     static void IS_DEFAULTMaskedDouble256VectorTests(IntFunction<double[]> fa,
2828                                           IntFunction<boolean[]> fm) {
2829         double[] a = fa.apply(SPECIES.length());
2830         boolean[] mask = fm.apply(SPECIES.length());
2831         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2832 
2833         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2834             for (int i = 0; i < a.length; i += SPECIES.length()) {
2835                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2836                 VectorMask<Double> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
2837 
2838                 // Check results as part of computation.
2839                 for (int j = 0; j < SPECIES.length(); j++) {
2840                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
2841                 }
2842             }
2843         }
2844     }
2845 
2846     static boolean testIS_NEGATIVE(double a) {
2847         return bits(a)<0;
2848     }
2849 
2850     @Test(dataProvider = "doubleTestOpProvider")
2851     static void IS_NEGATIVEDouble256VectorTests(IntFunction<double[]> fa) {
2852         double[] a = fa.apply(SPECIES.length());
2853 
2854         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2855             for (int i = 0; i < a.length; i += SPECIES.length()) {
2856                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2857                 VectorMask<Double> mv = av.test(VectorOperators.IS_NEGATIVE);
2858 
2859                 // Check results as part of computation.
2860                 for (int j = 0; j < SPECIES.length(); j++) {
2861                     Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
2862                 }
2863             }
2864         }
2865     }
2866 
2867     @Test(dataProvider = "doubleTestOpMaskProvider")
2868     static void IS_NEGATIVEMaskedDouble256VectorTests(IntFunction<double[]> fa,
2869                                           IntFunction<boolean[]> fm) {
2870         double[] a = fa.apply(SPECIES.length());
2871         boolean[] mask = fm.apply(SPECIES.length());
2872         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2873 
2874         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2875             for (int i = 0; i < a.length; i += SPECIES.length()) {
2876                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2877                 VectorMask<Double> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
2878 
2879                 // Check results as part of computation.
2880                 for (int j = 0; j < SPECIES.length(); j++) {
2881                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
2882                 }
2883             }
2884         }
2885     }
2886 
2887     static boolean testIS_FINITE(double a) {
2888         return Double.isFinite(a);
2889     }
2890 
2891     @Test(dataProvider = "doubleTestOpProvider")
2892     static void IS_FINITEDouble256VectorTests(IntFunction<double[]> fa) {
2893         double[] a = fa.apply(SPECIES.length());
2894 
2895         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2896             for (int i = 0; i < a.length; i += SPECIES.length()) {
2897                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2898                 VectorMask<Double> mv = av.test(VectorOperators.IS_FINITE);
2899 
2900                 // Check results as part of computation.
2901                 for (int j = 0; j < SPECIES.length(); j++) {
2902                     Assert.assertEquals(mv.laneIsSet(j), testIS_FINITE(a[i + j]));
2903                 }
2904             }
2905         }
2906     }
2907 
2908     @Test(dataProvider = "doubleTestOpMaskProvider")
2909     static void IS_FINITEMaskedDouble256VectorTests(IntFunction<double[]> fa,
2910                                           IntFunction<boolean[]> fm) {
2911         double[] a = fa.apply(SPECIES.length());
2912         boolean[] mask = fm.apply(SPECIES.length());
2913         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2914 
2915         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2916             for (int i = 0; i < a.length; i += SPECIES.length()) {
2917                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2918                 VectorMask<Double> mv = av.test(VectorOperators.IS_FINITE, vmask);
2919 
2920                 // Check results as part of computation.
2921                 for (int j = 0; j < SPECIES.length(); j++) {
2922                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_FINITE(a[i + j]));
2923                 }
2924             }
2925         }
2926     }
2927 
2928     static boolean testIS_NAN(double a) {
2929         return Double.isNaN(a);
2930     }
2931 
2932     @Test(dataProvider = "doubleTestOpProvider")
2933     static void IS_NANDouble256VectorTests(IntFunction<double[]> fa) {
2934         double[] a = fa.apply(SPECIES.length());
2935 
2936         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2937             for (int i = 0; i < a.length; i += SPECIES.length()) {
2938                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2939                 VectorMask<Double> mv = av.test(VectorOperators.IS_NAN);
2940 
2941                 // Check results as part of computation.
2942                 for (int j = 0; j < SPECIES.length(); j++) {
2943                     Assert.assertEquals(mv.laneIsSet(j), testIS_NAN(a[i + j]));
2944                 }
2945             }
2946         }
2947     }
2948 
2949     @Test(dataProvider = "doubleTestOpMaskProvider")
2950     static void IS_NANMaskedDouble256VectorTests(IntFunction<double[]> fa,
2951                                           IntFunction<boolean[]> fm) {
2952         double[] a = fa.apply(SPECIES.length());
2953         boolean[] mask = fm.apply(SPECIES.length());
2954         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2955 
2956         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2957             for (int i = 0; i < a.length; i += SPECIES.length()) {
2958                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2959                 VectorMask<Double> mv = av.test(VectorOperators.IS_NAN, vmask);
2960 
2961                 // Check results as part of computation.
2962                 for (int j = 0; j < SPECIES.length(); j++) {
2963                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_NAN(a[i + j]));
2964                 }
2965             }
2966         }
2967     }
2968 
2969     static boolean testIS_INFINITE(double a) {
2970         return Double.isInfinite(a);
2971     }
2972 
2973     @Test(dataProvider = "doubleTestOpProvider")
2974     static void IS_INFINITEDouble256VectorTests(IntFunction<double[]> fa) {
2975         double[] a = fa.apply(SPECIES.length());
2976 
2977         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2978             for (int i = 0; i < a.length; i += SPECIES.length()) {
2979                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2980                 VectorMask<Double> mv = av.test(VectorOperators.IS_INFINITE);
2981 
2982                 // Check results as part of computation.
2983                 for (int j = 0; j < SPECIES.length(); j++) {
2984                     Assert.assertEquals(mv.laneIsSet(j), testIS_INFINITE(a[i + j]));
2985                 }
2986             }
2987         }
2988     }
2989 
2990     @Test(dataProvider = "doubleTestOpMaskProvider")
2991     static void IS_INFINITEMaskedDouble256VectorTests(IntFunction<double[]> fa,
2992                                           IntFunction<boolean[]> fm) {
2993         double[] a = fa.apply(SPECIES.length());
2994         boolean[] mask = fm.apply(SPECIES.length());
2995         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2996 
2997         for (int ic = 0; ic < INVOC_COUNT; ic++) {
2998             for (int i = 0; i < a.length; i += SPECIES.length()) {
2999                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3000                 VectorMask<Double> mv = av.test(VectorOperators.IS_INFINITE, vmask);
3001 
3002                 // Check results as part of computation.
3003                 for (int j = 0; j < SPECIES.length(); j++) {
3004                     Assert.assertEquals(mv.laneIsSet(j),  vmask.laneIsSet(j) && testIS_INFINITE(a[i + j]));
3005                 }
3006             }
3007         }
3008     }
3009 
3010     @Test(dataProvider = "doubleCompareOpProvider")
3011     static void LTDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3012         double[] a = fa.apply(SPECIES.length());
3013         double[] b = fb.apply(SPECIES.length());
3014 
3015         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3016             for (int i = 0; i < a.length; i += SPECIES.length()) {
3017                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3018                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3019                 VectorMask<Double> mv = av.compare(VectorOperators.LT, bv);
3020 
3021                 // Check results as part of computation.
3022                 for (int j = 0; j < SPECIES.length(); j++) {
3023                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3024                 }
3025             }
3026         }
3027     }
3028 
3029     @Test(dataProvider = "doubleCompareOpProvider")
3030     static void ltDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3031         double[] a = fa.apply(SPECIES.length());
3032         double[] b = fb.apply(SPECIES.length());
3033 
3034         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3035             for (int i = 0; i < a.length; i += SPECIES.length()) {
3036                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3037                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3038                 VectorMask<Double> mv = av.lt(bv);
3039 
3040                 // Check results as part of computation.
3041                 for (int j = 0; j < SPECIES.length(); j++) {
3042                     Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3043                 }
3044             }
3045         }
3046     }
3047 
3048     @Test(dataProvider = "doubleCompareOpMaskProvider")
3049     static void LTDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3050                                                 IntFunction<boolean[]> fm) {
3051         double[] a = fa.apply(SPECIES.length());
3052         double[] b = fb.apply(SPECIES.length());
3053         boolean[] mask = fm.apply(SPECIES.length());
3054 
3055         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3056 
3057         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3058             for (int i = 0; i < a.length; i += SPECIES.length()) {
3059                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3060                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3061                 VectorMask<Double> mv = av.compare(VectorOperators.LT, bv, vmask);
3062 
3063                 // Check results as part of computation.
3064                 for (int j = 0; j < SPECIES.length(); j++) {
3065                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
3066                 }
3067             }
3068         }
3069     }
3070 
3071     @Test(dataProvider = "doubleCompareOpProvider")
3072     static void GTDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3073         double[] a = fa.apply(SPECIES.length());
3074         double[] b = fb.apply(SPECIES.length());
3075 
3076         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3077             for (int i = 0; i < a.length; i += SPECIES.length()) {
3078                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3079                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3080                 VectorMask<Double> mv = av.compare(VectorOperators.GT, bv);
3081 
3082                 // Check results as part of computation.
3083                 for (int j = 0; j < SPECIES.length(); j++) {
3084                     Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
3085                 }
3086             }
3087         }
3088     }
3089 
3090     @Test(dataProvider = "doubleCompareOpMaskProvider")
3091     static void GTDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3092                                                 IntFunction<boolean[]> fm) {
3093         double[] a = fa.apply(SPECIES.length());
3094         double[] b = fb.apply(SPECIES.length());
3095         boolean[] mask = fm.apply(SPECIES.length());
3096 
3097         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3098 
3099         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3100             for (int i = 0; i < a.length; i += SPECIES.length()) {
3101                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3102                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3103                 VectorMask<Double> mv = av.compare(VectorOperators.GT, bv, vmask);
3104 
3105                 // Check results as part of computation.
3106                 for (int j = 0; j < SPECIES.length(); j++) {
3107                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
3108                 }
3109             }
3110         }
3111     }
3112 
3113     @Test(dataProvider = "doubleCompareOpProvider")
3114     static void EQDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3115         double[] a = fa.apply(SPECIES.length());
3116         double[] b = fb.apply(SPECIES.length());
3117 
3118         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3119             for (int i = 0; i < a.length; i += SPECIES.length()) {
3120                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3121                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3122                 VectorMask<Double> mv = av.compare(VectorOperators.EQ, bv);
3123 
3124                 // Check results as part of computation.
3125                 for (int j = 0; j < SPECIES.length(); j++) {
3126                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3127                 }
3128             }
3129         }
3130     }
3131 
3132     @Test(dataProvider = "doubleCompareOpProvider")
3133     static void eqDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3134         double[] a = fa.apply(SPECIES.length());
3135         double[] b = fb.apply(SPECIES.length());
3136 
3137         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3138             for (int i = 0; i < a.length; i += SPECIES.length()) {
3139                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3140                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3141                 VectorMask<Double> mv = av.eq(bv);
3142 
3143                 // Check results as part of computation.
3144                 for (int j = 0; j < SPECIES.length(); j++) {
3145                     Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3146                 }
3147             }
3148         }
3149     }
3150 
3151     @Test(dataProvider = "doubleCompareOpMaskProvider")
3152     static void EQDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3153                                                 IntFunction<boolean[]> fm) {
3154         double[] a = fa.apply(SPECIES.length());
3155         double[] b = fb.apply(SPECIES.length());
3156         boolean[] mask = fm.apply(SPECIES.length());
3157 
3158         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3159 
3160         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3161             for (int i = 0; i < a.length; i += SPECIES.length()) {
3162                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3163                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3164                 VectorMask<Double> mv = av.compare(VectorOperators.EQ, bv, vmask);
3165 
3166                 // Check results as part of computation.
3167                 for (int j = 0; j < SPECIES.length(); j++) {
3168                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
3169                 }
3170             }
3171         }
3172     }
3173 
3174     @Test(dataProvider = "doubleCompareOpProvider")
3175     static void NEDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3176         double[] a = fa.apply(SPECIES.length());
3177         double[] b = fb.apply(SPECIES.length());
3178 
3179         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3180             for (int i = 0; i < a.length; i += SPECIES.length()) {
3181                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3182                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3183                 VectorMask<Double> mv = av.compare(VectorOperators.NE, bv);
3184 
3185                 // Check results as part of computation.
3186                 for (int j = 0; j < SPECIES.length(); j++) {
3187                     Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
3188                 }
3189             }
3190         }
3191     }
3192 
3193     @Test(dataProvider = "doubleCompareOpMaskProvider")
3194     static void NEDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3195                                                 IntFunction<boolean[]> fm) {
3196         double[] a = fa.apply(SPECIES.length());
3197         double[] b = fb.apply(SPECIES.length());
3198         boolean[] mask = fm.apply(SPECIES.length());
3199 
3200         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3201 
3202         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3203             for (int i = 0; i < a.length; i += SPECIES.length()) {
3204                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3205                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3206                 VectorMask<Double> mv = av.compare(VectorOperators.NE, bv, vmask);
3207 
3208                 // Check results as part of computation.
3209                 for (int j = 0; j < SPECIES.length(); j++) {
3210                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
3211                 }
3212             }
3213         }
3214     }
3215 
3216     @Test(dataProvider = "doubleCompareOpProvider")
3217     static void LEDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3218         double[] a = fa.apply(SPECIES.length());
3219         double[] b = fb.apply(SPECIES.length());
3220 
3221         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3222             for (int i = 0; i < a.length; i += SPECIES.length()) {
3223                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3224                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3225                 VectorMask<Double> mv = av.compare(VectorOperators.LE, bv);
3226 
3227                 // Check results as part of computation.
3228                 for (int j = 0; j < SPECIES.length(); j++) {
3229                     Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
3230                 }
3231             }
3232         }
3233     }
3234 
3235     @Test(dataProvider = "doubleCompareOpMaskProvider")
3236     static void LEDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3237                                                 IntFunction<boolean[]> fm) {
3238         double[] a = fa.apply(SPECIES.length());
3239         double[] b = fb.apply(SPECIES.length());
3240         boolean[] mask = fm.apply(SPECIES.length());
3241 
3242         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3243 
3244         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3245             for (int i = 0; i < a.length; i += SPECIES.length()) {
3246                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3247                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3248                 VectorMask<Double> mv = av.compare(VectorOperators.LE, bv, vmask);
3249 
3250                 // Check results as part of computation.
3251                 for (int j = 0; j < SPECIES.length(); j++) {
3252                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
3253                 }
3254             }
3255         }
3256     }
3257 
3258     @Test(dataProvider = "doubleCompareOpProvider")
3259     static void GEDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3260         double[] a = fa.apply(SPECIES.length());
3261         double[] b = fb.apply(SPECIES.length());
3262 
3263         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3264             for (int i = 0; i < a.length; i += SPECIES.length()) {
3265                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3266                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3267                 VectorMask<Double> mv = av.compare(VectorOperators.GE, bv);
3268 
3269                 // Check results as part of computation.
3270                 for (int j = 0; j < SPECIES.length(); j++) {
3271                     Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
3272                 }
3273             }
3274         }
3275     }
3276 
3277     @Test(dataProvider = "doubleCompareOpMaskProvider")
3278     static void GEDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3279                                                 IntFunction<boolean[]> fm) {
3280         double[] a = fa.apply(SPECIES.length());
3281         double[] b = fb.apply(SPECIES.length());
3282         boolean[] mask = fm.apply(SPECIES.length());
3283 
3284         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3285 
3286         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3287             for (int i = 0; i < a.length; i += SPECIES.length()) {
3288                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3289                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3290                 VectorMask<Double> mv = av.compare(VectorOperators.GE, bv, vmask);
3291 
3292                 // Check results as part of computation.
3293                 for (int j = 0; j < SPECIES.length(); j++) {
3294                     Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
3295                 }
3296             }
3297         }
3298     }
3299 
3300     @Test(dataProvider = "doubleCompareOpProvider")
3301     static void LTDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3302         double[] a = fa.apply(SPECIES.length());
3303         double[] b = fb.apply(SPECIES.length());
3304 
3305         for (int i = 0; i < a.length; i += SPECIES.length()) {
3306             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3307             VectorMask<Double> mv = av.compare(VectorOperators.LT, b[i]);
3308 
3309             // Check results as part of computation.
3310             for (int j = 0; j < SPECIES.length(); j++) {
3311                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
3312             }
3313         }
3314     }
3315 
3316     @Test(dataProvider = "doubleCompareOpMaskProvider")
3317     static void LTDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa,
3318                                 IntFunction<double[]> fb, IntFunction<boolean[]> fm) {
3319         double[] a = fa.apply(SPECIES.length());
3320         double[] b = fb.apply(SPECIES.length());
3321         boolean[] mask = fm.apply(SPECIES.length());
3322 
3323         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3324 
3325         for (int i = 0; i < a.length; i += SPECIES.length()) {
3326             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3327             VectorMask<Double> mv = av.compare(VectorOperators.LT, b[i], vmask);
3328 
3329             // Check results as part of computation.
3330             for (int j = 0; j < SPECIES.length(); j++) {
3331                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
3332             }
3333         }
3334     }
3335 
3336     @Test(dataProvider = "doubleCompareOpProvider")
3337     static void LTDouble256VectorTestsBroadcastLongSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3338         double[] a = fa.apply(SPECIES.length());
3339         double[] b = fb.apply(SPECIES.length());
3340 
3341         for (int i = 0; i < a.length; i += SPECIES.length()) {
3342             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3343             VectorMask<Double> mv = av.compare(VectorOperators.LT, (long)b[i]);
3344 
3345             // Check results as part of computation.
3346             for (int j = 0; j < SPECIES.length(); j++) {
3347                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (double)((long)b[i]));
3348             }
3349         }
3350     }
3351 
3352     @Test(dataProvider = "doubleCompareOpMaskProvider")
3353     static void LTDouble256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<double[]> fa,
3354                                 IntFunction<double[]> fb, IntFunction<boolean[]> fm) {
3355         double[] a = fa.apply(SPECIES.length());
3356         double[] b = fb.apply(SPECIES.length());
3357         boolean[] mask = fm.apply(SPECIES.length());
3358 
3359         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3360 
3361         for (int i = 0; i < a.length; i += SPECIES.length()) {
3362             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3363             VectorMask<Double> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
3364 
3365             // Check results as part of computation.
3366             for (int j = 0; j < SPECIES.length(); j++) {
3367                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (double)((long)b[i])));
3368             }
3369         }
3370     }
3371 
3372     @Test(dataProvider = "doubleCompareOpProvider")
3373     static void EQDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3374         double[] a = fa.apply(SPECIES.length());
3375         double[] b = fb.apply(SPECIES.length());
3376 
3377         for (int i = 0; i < a.length; i += SPECIES.length()) {
3378             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3379             VectorMask<Double> mv = av.compare(VectorOperators.EQ, b[i]);
3380 
3381             // Check results as part of computation.
3382             for (int j = 0; j < SPECIES.length(); j++) {
3383                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
3384             }
3385         }
3386     }
3387 
3388     @Test(dataProvider = "doubleCompareOpMaskProvider")
3389     static void EQDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa,
3390                                 IntFunction<double[]> fb, IntFunction<boolean[]> fm) {
3391         double[] a = fa.apply(SPECIES.length());
3392         double[] b = fb.apply(SPECIES.length());
3393         boolean[] mask = fm.apply(SPECIES.length());
3394 
3395         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3396 
3397         for (int i = 0; i < a.length; i += SPECIES.length()) {
3398             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3399             VectorMask<Double> mv = av.compare(VectorOperators.EQ, b[i], vmask);
3400 
3401             // Check results as part of computation.
3402             for (int j = 0; j < SPECIES.length(); j++) {
3403                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
3404             }
3405         }
3406     }
3407 
3408     @Test(dataProvider = "doubleCompareOpProvider")
3409     static void EQDouble256VectorTestsBroadcastLongSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3410         double[] a = fa.apply(SPECIES.length());
3411         double[] b = fb.apply(SPECIES.length());
3412 
3413         for (int i = 0; i < a.length; i += SPECIES.length()) {
3414             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3415             VectorMask<Double> mv = av.compare(VectorOperators.EQ, (long)b[i]);
3416 
3417             // Check results as part of computation.
3418             for (int j = 0; j < SPECIES.length(); j++) {
3419                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (double)((long)b[i]));
3420             }
3421         }
3422     }
3423 
3424     @Test(dataProvider = "doubleCompareOpMaskProvider")
3425     static void EQDouble256VectorTestsBroadcastLongMaskedSmokeTest(IntFunction<double[]> fa,
3426                                 IntFunction<double[]> fb, IntFunction<boolean[]> fm) {
3427         double[] a = fa.apply(SPECIES.length());
3428         double[] b = fb.apply(SPECIES.length());
3429         boolean[] mask = fm.apply(SPECIES.length());
3430 
3431         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3432 
3433         for (int i = 0; i < a.length; i += SPECIES.length()) {
3434             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3435             VectorMask<Double> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
3436 
3437             // Check results as part of computation.
3438             for (int j = 0; j < SPECIES.length(); j++) {
3439                 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (double)((long)b[i])));
3440             }
3441         }
3442     }
3443 
3444     static double blend(double a, double b, boolean mask) {
3445         return mask ? b : a;
3446     }
3447 
3448     @Test(dataProvider = "doubleBinaryOpMaskProvider")
3449     static void blendDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb,
3450                                           IntFunction<boolean[]> fm) {
3451         double[] a = fa.apply(SPECIES.length());
3452         double[] b = fb.apply(SPECIES.length());
3453         double[] r = fr.apply(SPECIES.length());
3454         boolean[] mask = fm.apply(SPECIES.length());
3455         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3456 
3457         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3458             for (int i = 0; i < a.length; i += SPECIES.length()) {
3459                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3460                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3461                 av.blend(bv, vmask).intoArray(r, i);
3462             }
3463         }
3464 
3465         assertArraysEquals(r, a, b, mask, Double256VectorTests::blend);
3466     }
3467 
3468     @Test(dataProvider = "doubleUnaryOpShuffleProvider")
3469     static void RearrangeDouble256VectorTests(IntFunction<double[]> fa,
3470                                            BiFunction<Integer,Integer,int[]> fs) {
3471         double[] a = fa.apply(SPECIES.length());
3472         int[] order = fs.apply(a.length, SPECIES.length());
3473         double[] r = fr.apply(SPECIES.length());
3474 
3475         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3476             for (int i = 0; i < a.length; i += SPECIES.length()) {
3477                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3478                 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
3479             }
3480         }
3481 
3482         assertRearrangeArraysEquals(r, a, order, SPECIES.length());
3483     }
3484 
3485     @Test(dataProvider = "doubleUnaryOpShuffleMaskProvider")
3486     static void RearrangeDouble256VectorTestsMaskedSmokeTest(IntFunction<double[]> fa,
3487                                                           BiFunction<Integer,Integer,int[]> fs,
3488                                                           IntFunction<boolean[]> fm) {
3489         double[] a = fa.apply(SPECIES.length());
3490         int[] order = fs.apply(a.length, SPECIES.length());
3491         double[] r = fr.apply(SPECIES.length());
3492         boolean[] mask = fm.apply(SPECIES.length());
3493         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3494 
3495         for (int i = 0; i < a.length; i += SPECIES.length()) {
3496             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3497             av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
3498         }
3499 
3500         assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
3501     }
3502 
3503     @Test(dataProvider = "doubleUnaryOpMaskProvider")
3504     static void compressDouble256VectorTests(IntFunction<double[]> fa,
3505                                                 IntFunction<boolean[]> fm) {
3506         double[] a = fa.apply(SPECIES.length());
3507         double[] r = fr.apply(SPECIES.length());
3508         boolean[] mask = fm.apply(SPECIES.length());
3509         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3510 
3511         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3512             for (int i = 0; i < a.length; i += SPECIES.length()) {
3513                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3514                 av.compress(vmask).intoArray(r, i);
3515             }
3516         }
3517 
3518         assertcompressArraysEquals(r, a, mask, SPECIES.length());
3519     }
3520 
3521     @Test(dataProvider = "doubleUnaryOpMaskProvider")
3522     static void expandDouble256VectorTests(IntFunction<double[]> fa,
3523                                                 IntFunction<boolean[]> fm) {
3524         double[] a = fa.apply(SPECIES.length());
3525         double[] r = fr.apply(SPECIES.length());
3526         boolean[] mask = fm.apply(SPECIES.length());
3527         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3528 
3529         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3530             for (int i = 0; i < a.length; i += SPECIES.length()) {
3531                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3532                 av.expand(vmask).intoArray(r, i);
3533             }
3534         }
3535 
3536         assertexpandArraysEquals(r, a, mask, SPECIES.length());
3537     }
3538 
3539     @Test(dataProvider = "doubleUnaryOpProvider")
3540     static void getDouble256VectorTests(IntFunction<double[]> fa) {
3541         double[] a = fa.apply(SPECIES.length());
3542         double[] r = fr.apply(SPECIES.length());
3543 
3544         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3545             for (int i = 0; i < a.length; i += SPECIES.length()) {
3546                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3547                 int num_lanes = SPECIES.length();
3548                 // Manually unroll because full unroll happens after intrinsification.
3549                 // Unroll is needed because get intrinsic requires for index to be a known constant.
3550                 if (num_lanes == 1) {
3551                     r[i]=av.lane(0);
3552                 } else if (num_lanes == 2) {
3553                     r[i]=av.lane(0);
3554                     r[i+1]=av.lane(1);
3555                 } else if (num_lanes == 4) {
3556                     r[i]=av.lane(0);
3557                     r[i+1]=av.lane(1);
3558                     r[i+2]=av.lane(2);
3559                     r[i+3]=av.lane(3);
3560                 } else if (num_lanes == 8) {
3561                     r[i]=av.lane(0);
3562                     r[i+1]=av.lane(1);
3563                     r[i+2]=av.lane(2);
3564                     r[i+3]=av.lane(3);
3565                     r[i+4]=av.lane(4);
3566                     r[i+5]=av.lane(5);
3567                     r[i+6]=av.lane(6);
3568                     r[i+7]=av.lane(7);
3569                 } else if (num_lanes == 16) {
3570                     r[i]=av.lane(0);
3571                     r[i+1]=av.lane(1);
3572                     r[i+2]=av.lane(2);
3573                     r[i+3]=av.lane(3);
3574                     r[i+4]=av.lane(4);
3575                     r[i+5]=av.lane(5);
3576                     r[i+6]=av.lane(6);
3577                     r[i+7]=av.lane(7);
3578                     r[i+8]=av.lane(8);
3579                     r[i+9]=av.lane(9);
3580                     r[i+10]=av.lane(10);
3581                     r[i+11]=av.lane(11);
3582                     r[i+12]=av.lane(12);
3583                     r[i+13]=av.lane(13);
3584                     r[i+14]=av.lane(14);
3585                     r[i+15]=av.lane(15);
3586                 } else if (num_lanes == 32) {
3587                     r[i]=av.lane(0);
3588                     r[i+1]=av.lane(1);
3589                     r[i+2]=av.lane(2);
3590                     r[i+3]=av.lane(3);
3591                     r[i+4]=av.lane(4);
3592                     r[i+5]=av.lane(5);
3593                     r[i+6]=av.lane(6);
3594                     r[i+7]=av.lane(7);
3595                     r[i+8]=av.lane(8);
3596                     r[i+9]=av.lane(9);
3597                     r[i+10]=av.lane(10);
3598                     r[i+11]=av.lane(11);
3599                     r[i+12]=av.lane(12);
3600                     r[i+13]=av.lane(13);
3601                     r[i+14]=av.lane(14);
3602                     r[i+15]=av.lane(15);
3603                     r[i+16]=av.lane(16);
3604                     r[i+17]=av.lane(17);
3605                     r[i+18]=av.lane(18);
3606                     r[i+19]=av.lane(19);
3607                     r[i+20]=av.lane(20);
3608                     r[i+21]=av.lane(21);
3609                     r[i+22]=av.lane(22);
3610                     r[i+23]=av.lane(23);
3611                     r[i+24]=av.lane(24);
3612                     r[i+25]=av.lane(25);
3613                     r[i+26]=av.lane(26);
3614                     r[i+27]=av.lane(27);
3615                     r[i+28]=av.lane(28);
3616                     r[i+29]=av.lane(29);
3617                     r[i+30]=av.lane(30);
3618                     r[i+31]=av.lane(31);
3619                 } else if (num_lanes == 64) {
3620                     r[i]=av.lane(0);
3621                     r[i+1]=av.lane(1);
3622                     r[i+2]=av.lane(2);
3623                     r[i+3]=av.lane(3);
3624                     r[i+4]=av.lane(4);
3625                     r[i+5]=av.lane(5);
3626                     r[i+6]=av.lane(6);
3627                     r[i+7]=av.lane(7);
3628                     r[i+8]=av.lane(8);
3629                     r[i+9]=av.lane(9);
3630                     r[i+10]=av.lane(10);
3631                     r[i+11]=av.lane(11);
3632                     r[i+12]=av.lane(12);
3633                     r[i+13]=av.lane(13);
3634                     r[i+14]=av.lane(14);
3635                     r[i+15]=av.lane(15);
3636                     r[i+16]=av.lane(16);
3637                     r[i+17]=av.lane(17);
3638                     r[i+18]=av.lane(18);
3639                     r[i+19]=av.lane(19);
3640                     r[i+20]=av.lane(20);
3641                     r[i+21]=av.lane(21);
3642                     r[i+22]=av.lane(22);
3643                     r[i+23]=av.lane(23);
3644                     r[i+24]=av.lane(24);
3645                     r[i+25]=av.lane(25);
3646                     r[i+26]=av.lane(26);
3647                     r[i+27]=av.lane(27);
3648                     r[i+28]=av.lane(28);
3649                     r[i+29]=av.lane(29);
3650                     r[i+30]=av.lane(30);
3651                     r[i+31]=av.lane(31);
3652                     r[i+32]=av.lane(32);
3653                     r[i+33]=av.lane(33);
3654                     r[i+34]=av.lane(34);
3655                     r[i+35]=av.lane(35);
3656                     r[i+36]=av.lane(36);
3657                     r[i+37]=av.lane(37);
3658                     r[i+38]=av.lane(38);
3659                     r[i+39]=av.lane(39);
3660                     r[i+40]=av.lane(40);
3661                     r[i+41]=av.lane(41);
3662                     r[i+42]=av.lane(42);
3663                     r[i+43]=av.lane(43);
3664                     r[i+44]=av.lane(44);
3665                     r[i+45]=av.lane(45);
3666                     r[i+46]=av.lane(46);
3667                     r[i+47]=av.lane(47);
3668                     r[i+48]=av.lane(48);
3669                     r[i+49]=av.lane(49);
3670                     r[i+50]=av.lane(50);
3671                     r[i+51]=av.lane(51);
3672                     r[i+52]=av.lane(52);
3673                     r[i+53]=av.lane(53);
3674                     r[i+54]=av.lane(54);
3675                     r[i+55]=av.lane(55);
3676                     r[i+56]=av.lane(56);
3677                     r[i+57]=av.lane(57);
3678                     r[i+58]=av.lane(58);
3679                     r[i+59]=av.lane(59);
3680                     r[i+60]=av.lane(60);
3681                     r[i+61]=av.lane(61);
3682                     r[i+62]=av.lane(62);
3683                     r[i+63]=av.lane(63);
3684                 } else {
3685                     for (int j = 0; j < SPECIES.length(); j++) {
3686                         r[i+j]=av.lane(j);
3687                     }
3688                 }
3689             }
3690         }
3691 
3692         assertArraysStrictlyEquals(r, a);
3693     }
3694 
3695     @Test(dataProvider = "doubleUnaryOpProvider")
3696     static void BroadcastDouble256VectorTests(IntFunction<double[]> fa) {
3697         double[] a = fa.apply(SPECIES.length());
3698         double[] r = new double[a.length];
3699 
3700         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3701             for (int i = 0; i < a.length; i += SPECIES.length()) {
3702                 DoubleVector.broadcast(SPECIES, a[i]).intoArray(r, i);
3703             }
3704         }
3705 
3706         assertBroadcastArraysEquals(r, a);
3707     }
3708 
3709     @Test(dataProvider = "doubleUnaryOpProvider")
3710     static void ZeroDouble256VectorTests(IntFunction<double[]> fa) {
3711         double[] a = fa.apply(SPECIES.length());
3712         double[] r = new double[a.length];
3713 
3714         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3715             for (int i = 0; i < a.length; i += SPECIES.length()) {
3716                 DoubleVector.zero(SPECIES).intoArray(a, i);
3717             }
3718         }
3719 
3720         Assert.assertEquals(a, r);
3721     }
3722 
3723     static double[] sliceUnary(double[] a, int origin, int idx) {
3724         double[] res = new double[SPECIES.length()];
3725         for (int i = 0; i < SPECIES.length(); i++){
3726             if(i+origin < SPECIES.length())
3727                 res[i] = a[idx+i+origin];
3728             else
3729                 res[i] = (double)0;
3730         }
3731         return res;
3732     }
3733 
3734     @Test(dataProvider = "doubleUnaryOpProvider")
3735     static void sliceUnaryDouble256VectorTests(IntFunction<double[]> fa) {
3736         double[] a = fa.apply(SPECIES.length());
3737         double[] r = new double[a.length];
3738         int origin = RAND.nextInt(SPECIES.length());
3739         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3740             for (int i = 0; i < a.length; i += SPECIES.length()) {
3741                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3742                 av.slice(origin).intoArray(r, i);
3743             }
3744         }
3745 
3746         assertArraysEquals(r, a, origin, Double256VectorTests::sliceUnary);
3747     }
3748 
3749     static double[] sliceBinary(double[] a, double[] b, int origin, int idx) {
3750         double[] res = new double[SPECIES.length()];
3751         for (int i = 0, j = 0; i < SPECIES.length(); i++){
3752             if(i+origin < SPECIES.length())
3753                 res[i] = a[idx+i+origin];
3754             else {
3755                 res[i] = b[idx+j];
3756                 j++;
3757             }
3758         }
3759         return res;
3760     }
3761 
3762     @Test(dataProvider = "doubleBinaryOpProvider")
3763     static void sliceBinaryDouble256VectorTestsBinary(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3764         double[] a = fa.apply(SPECIES.length());
3765         double[] b = fb.apply(SPECIES.length());
3766         double[] r = new double[a.length];
3767         int origin = RAND.nextInt(SPECIES.length());
3768         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3769             for (int i = 0; i < a.length; i += SPECIES.length()) {
3770                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3771                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3772                 av.slice(origin, bv).intoArray(r, i);
3773             }
3774         }
3775 
3776         assertArraysEquals(r, a, b, origin, Double256VectorTests::sliceBinary);
3777     }
3778 
3779     static double[] slice(double[] a, double[] b, int origin, boolean[] mask, int idx) {
3780         double[] res = new double[SPECIES.length()];
3781         for (int i = 0, j = 0; i < SPECIES.length(); i++){
3782             if(i+origin < SPECIES.length())
3783                 res[i] = mask[i] ? a[idx+i+origin] : (double)0;
3784             else {
3785                 res[i] = mask[i] ? b[idx+j] : (double)0;
3786                 j++;
3787             }
3788         }
3789         return res;
3790     }
3791 
3792     @Test(dataProvider = "doubleBinaryOpMaskProvider")
3793     static void sliceDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3794     IntFunction<boolean[]> fm) {
3795         double[] a = fa.apply(SPECIES.length());
3796         double[] b = fb.apply(SPECIES.length());
3797         boolean[] mask = fm.apply(SPECIES.length());
3798         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3799 
3800         double[] r = new double[a.length];
3801         int origin = RAND.nextInt(SPECIES.length());
3802         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3803             for (int i = 0; i < a.length; i += SPECIES.length()) {
3804                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3805                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3806                 av.slice(origin, bv, vmask).intoArray(r, i);
3807             }
3808         }
3809 
3810         assertArraysEquals(r, a, b, origin, mask, Double256VectorTests::slice);
3811     }
3812 
3813     static double[] unsliceUnary(double[] a, int origin, int idx) {
3814         double[] res = new double[SPECIES.length()];
3815         for (int i = 0, j = 0; i < SPECIES.length(); i++){
3816             if(i < origin)
3817                 res[i] = (double)0;
3818             else {
3819                 res[i] = a[idx+j];
3820                 j++;
3821             }
3822         }
3823         return res;
3824     }
3825 
3826     @Test(dataProvider = "doubleUnaryOpProvider")
3827     static void unsliceUnaryDouble256VectorTests(IntFunction<double[]> fa) {
3828         double[] a = fa.apply(SPECIES.length());
3829         double[] r = new double[a.length];
3830         int origin = RAND.nextInt(SPECIES.length());
3831         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3832             for (int i = 0; i < a.length; i += SPECIES.length()) {
3833                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3834                 av.unslice(origin).intoArray(r, i);
3835             }
3836         }
3837 
3838         assertArraysEquals(r, a, origin, Double256VectorTests::unsliceUnary);
3839     }
3840 
3841     static double[] unsliceBinary(double[] a, double[] b, int origin, int part, int idx) {
3842         double[] res = new double[SPECIES.length()];
3843         for (int i = 0, j = 0; i < SPECIES.length(); i++){
3844             if (part == 0) {
3845                 if (i < origin)
3846                     res[i] = b[idx+i];
3847                 else {
3848                     res[i] = a[idx+j];
3849                     j++;
3850                 }
3851             } else if (part == 1) {
3852                 if (i < origin)
3853                     res[i] = a[idx+SPECIES.length()-origin+i];
3854                 else {
3855                     res[i] = b[idx+origin+j];
3856                     j++;
3857                 }
3858             }
3859         }
3860         return res;
3861     }
3862 
3863     @Test(dataProvider = "doubleBinaryOpProvider")
3864     static void unsliceBinaryDouble256VectorTestsBinary(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3865         double[] a = fa.apply(SPECIES.length());
3866         double[] b = fb.apply(SPECIES.length());
3867         double[] r = new double[a.length];
3868         int origin = RAND.nextInt(SPECIES.length());
3869         int part = RAND.nextInt(2);
3870         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3871             for (int i = 0; i < a.length; i += SPECIES.length()) {
3872                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3873                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3874                 av.unslice(origin, bv, part).intoArray(r, i);
3875             }
3876         }
3877 
3878         assertArraysEquals(r, a, b, origin, part, Double256VectorTests::unsliceBinary);
3879     }
3880 
3881     static double[] unslice(double[] a, double[] b, int origin, int part, boolean[] mask, int idx) {
3882         double[] res = new double[SPECIES.length()];
3883         for (int i = 0, j = 0; i < SPECIES.length(); i++){
3884             if(i+origin < SPECIES.length())
3885                 res[i] = b[idx+i+origin];
3886             else {
3887                 res[i] = b[idx+j];
3888                 j++;
3889             }
3890         }
3891         for (int i = 0; i < SPECIES.length(); i++){
3892             res[i] = mask[i] ? a[idx+i] : res[i];
3893         }
3894         double[] res1 = new double[SPECIES.length()];
3895         if (part == 0) {
3896             for (int i = 0, j = 0; i < SPECIES.length(); i++){
3897                 if (i < origin)
3898                     res1[i] = b[idx+i];
3899                 else {
3900                    res1[i] = res[j];
3901                    j++;
3902                 }
3903             }
3904         } else if (part == 1) {
3905             for (int i = 0, j = 0; i < SPECIES.length(); i++){
3906                 if (i < origin)
3907                     res1[i] = res[SPECIES.length()-origin+i];
3908                 else {
3909                     res1[i] = b[idx+origin+j];
3910                     j++;
3911                 }
3912             }
3913         }
3914         return res1;
3915     }
3916 
3917     @Test(dataProvider = "doubleBinaryOpMaskProvider")
3918     static void unsliceDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3919     IntFunction<boolean[]> fm) {
3920         double[] a = fa.apply(SPECIES.length());
3921         double[] b = fb.apply(SPECIES.length());
3922         boolean[] mask = fm.apply(SPECIES.length());
3923         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3924         double[] r = new double[a.length];
3925         int origin = RAND.nextInt(SPECIES.length());
3926         int part = RAND.nextInt(2);
3927         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3928             for (int i = 0; i < a.length; i += SPECIES.length()) {
3929                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3930                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3931                 av.unslice(origin, bv, part, vmask).intoArray(r, i);
3932             }
3933         }
3934 
3935         assertArraysEquals(r, a, b, origin, part, mask, Double256VectorTests::unslice);
3936     }
3937 
3938     static double SIN(double a) {
3939         return (double)(Math.sin((double)a));
3940     }
3941 
3942     static double strictSIN(double a) {
3943         return (double)(StrictMath.sin((double)a));
3944     }
3945 
3946     @Test(dataProvider = "doubleUnaryOpProvider")
3947     static void SINDouble256VectorTests(IntFunction<double[]> fa) {
3948         double[] a = fa.apply(SPECIES.length());
3949         double[] r = fr.apply(SPECIES.length());
3950 
3951         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3952             for (int i = 0; i < a.length; i += SPECIES.length()) {
3953                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3954                 av.lanewise(VectorOperators.SIN).intoArray(r, i);
3955             }
3956         }
3957 
3958         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::SIN, Double256VectorTests::strictSIN);
3959     }
3960 
3961     static double EXP(double a) {
3962         return (double)(Math.exp((double)a));
3963     }
3964 
3965     static double strictEXP(double a) {
3966         return (double)(StrictMath.exp((double)a));
3967     }
3968 
3969     @Test(dataProvider = "doubleUnaryOpProvider")
3970     static void EXPDouble256VectorTests(IntFunction<double[]> fa) {
3971         double[] a = fa.apply(SPECIES.length());
3972         double[] r = fr.apply(SPECIES.length());
3973 
3974         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3975             for (int i = 0; i < a.length; i += SPECIES.length()) {
3976                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3977                 av.lanewise(VectorOperators.EXP).intoArray(r, i);
3978             }
3979         }
3980 
3981         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::EXP, Double256VectorTests::strictEXP);
3982     }
3983 
3984     static double LOG1P(double a) {
3985         return (double)(Math.log1p((double)a));
3986     }
3987 
3988     static double strictLOG1P(double a) {
3989         return (double)(StrictMath.log1p((double)a));
3990     }
3991 
3992     @Test(dataProvider = "doubleUnaryOpProvider")
3993     static void LOG1PDouble256VectorTests(IntFunction<double[]> fa) {
3994         double[] a = fa.apply(SPECIES.length());
3995         double[] r = fr.apply(SPECIES.length());
3996 
3997         for (int ic = 0; ic < INVOC_COUNT; ic++) {
3998             for (int i = 0; i < a.length; i += SPECIES.length()) {
3999                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4000                 av.lanewise(VectorOperators.LOG1P).intoArray(r, i);
4001             }
4002         }
4003 
4004         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::LOG1P, Double256VectorTests::strictLOG1P);
4005     }
4006 
4007     static double LOG(double a) {
4008         return (double)(Math.log((double)a));
4009     }
4010 
4011     static double strictLOG(double a) {
4012         return (double)(StrictMath.log((double)a));
4013     }
4014 
4015     @Test(dataProvider = "doubleUnaryOpProvider")
4016     static void LOGDouble256VectorTests(IntFunction<double[]> fa) {
4017         double[] a = fa.apply(SPECIES.length());
4018         double[] r = fr.apply(SPECIES.length());
4019 
4020         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4021             for (int i = 0; i < a.length; i += SPECIES.length()) {
4022                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4023                 av.lanewise(VectorOperators.LOG).intoArray(r, i);
4024             }
4025         }
4026 
4027         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::LOG, Double256VectorTests::strictLOG);
4028     }
4029 
4030     static double LOG10(double a) {
4031         return (double)(Math.log10((double)a));
4032     }
4033 
4034     static double strictLOG10(double a) {
4035         return (double)(StrictMath.log10((double)a));
4036     }
4037 
4038     @Test(dataProvider = "doubleUnaryOpProvider")
4039     static void LOG10Double256VectorTests(IntFunction<double[]> fa) {
4040         double[] a = fa.apply(SPECIES.length());
4041         double[] r = fr.apply(SPECIES.length());
4042 
4043         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4044             for (int i = 0; i < a.length; i += SPECIES.length()) {
4045                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4046                 av.lanewise(VectorOperators.LOG10).intoArray(r, i);
4047             }
4048         }
4049 
4050         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::LOG10, Double256VectorTests::strictLOG10);
4051     }
4052 
4053     static double EXPM1(double a) {
4054         return (double)(Math.expm1((double)a));
4055     }
4056 
4057     static double strictEXPM1(double a) {
4058         return (double)(StrictMath.expm1((double)a));
4059     }
4060 
4061     @Test(dataProvider = "doubleUnaryOpProvider")
4062     static void EXPM1Double256VectorTests(IntFunction<double[]> fa) {
4063         double[] a = fa.apply(SPECIES.length());
4064         double[] r = fr.apply(SPECIES.length());
4065 
4066         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4067             for (int i = 0; i < a.length; i += SPECIES.length()) {
4068                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4069                 av.lanewise(VectorOperators.EXPM1).intoArray(r, i);
4070             }
4071         }
4072 
4073         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::EXPM1, Double256VectorTests::strictEXPM1);
4074     }
4075 
4076     static double COS(double a) {
4077         return (double)(Math.cos((double)a));
4078     }
4079 
4080     static double strictCOS(double a) {
4081         return (double)(StrictMath.cos((double)a));
4082     }
4083 
4084     @Test(dataProvider = "doubleUnaryOpProvider")
4085     static void COSDouble256VectorTests(IntFunction<double[]> fa) {
4086         double[] a = fa.apply(SPECIES.length());
4087         double[] r = fr.apply(SPECIES.length());
4088 
4089         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4090             for (int i = 0; i < a.length; i += SPECIES.length()) {
4091                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4092                 av.lanewise(VectorOperators.COS).intoArray(r, i);
4093             }
4094         }
4095 
4096         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::COS, Double256VectorTests::strictCOS);
4097     }
4098 
4099     static double TAN(double a) {
4100         return (double)(Math.tan((double)a));
4101     }
4102 
4103     static double strictTAN(double a) {
4104         return (double)(StrictMath.tan((double)a));
4105     }
4106 
4107     @Test(dataProvider = "doubleUnaryOpProvider")
4108     static void TANDouble256VectorTests(IntFunction<double[]> fa) {
4109         double[] a = fa.apply(SPECIES.length());
4110         double[] r = fr.apply(SPECIES.length());
4111 
4112         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4113             for (int i = 0; i < a.length; i += SPECIES.length()) {
4114                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4115                 av.lanewise(VectorOperators.TAN).intoArray(r, i);
4116             }
4117         }
4118 
4119         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::TAN, Double256VectorTests::strictTAN);
4120     }
4121 
4122     static double SINH(double a) {
4123         return (double)(Math.sinh((double)a));
4124     }
4125 
4126     static double strictSINH(double a) {
4127         return (double)(StrictMath.sinh((double)a));
4128     }
4129 
4130     @Test(dataProvider = "doubleUnaryOpProvider")
4131     static void SINHDouble256VectorTests(IntFunction<double[]> fa) {
4132         double[] a = fa.apply(SPECIES.length());
4133         double[] r = fr.apply(SPECIES.length());
4134 
4135         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4136             for (int i = 0; i < a.length; i += SPECIES.length()) {
4137                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4138                 av.lanewise(VectorOperators.SINH).intoArray(r, i);
4139             }
4140         }
4141 
4142         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::SINH, Double256VectorTests::strictSINH);
4143     }
4144 
4145     static double COSH(double a) {
4146         return (double)(Math.cosh((double)a));
4147     }
4148 
4149     static double strictCOSH(double a) {
4150         return (double)(StrictMath.cosh((double)a));
4151     }
4152 
4153     @Test(dataProvider = "doubleUnaryOpProvider")
4154     static void COSHDouble256VectorTests(IntFunction<double[]> fa) {
4155         double[] a = fa.apply(SPECIES.length());
4156         double[] r = fr.apply(SPECIES.length());
4157 
4158         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4159             for (int i = 0; i < a.length; i += SPECIES.length()) {
4160                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4161                 av.lanewise(VectorOperators.COSH).intoArray(r, i);
4162             }
4163         }
4164 
4165         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::COSH, Double256VectorTests::strictCOSH);
4166     }
4167 
4168     static double TANH(double a) {
4169         return (double)(Math.tanh((double)a));
4170     }
4171 
4172     static double strictTANH(double a) {
4173         return (double)(StrictMath.tanh((double)a));
4174     }
4175 
4176     @Test(dataProvider = "doubleUnaryOpProvider")
4177     static void TANHDouble256VectorTests(IntFunction<double[]> fa) {
4178         double[] a = fa.apply(SPECIES.length());
4179         double[] r = fr.apply(SPECIES.length());
4180 
4181         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4182             for (int i = 0; i < a.length; i += SPECIES.length()) {
4183                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4184                 av.lanewise(VectorOperators.TANH).intoArray(r, i);
4185             }
4186         }
4187 
4188         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::TANH, Double256VectorTests::strictTANH);
4189     }
4190 
4191     static double ASIN(double a) {
4192         return (double)(Math.asin((double)a));
4193     }
4194 
4195     static double strictASIN(double a) {
4196         return (double)(StrictMath.asin((double)a));
4197     }
4198 
4199     @Test(dataProvider = "doubleUnaryOpProvider")
4200     static void ASINDouble256VectorTests(IntFunction<double[]> fa) {
4201         double[] a = fa.apply(SPECIES.length());
4202         double[] r = fr.apply(SPECIES.length());
4203 
4204         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4205             for (int i = 0; i < a.length; i += SPECIES.length()) {
4206                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4207                 av.lanewise(VectorOperators.ASIN).intoArray(r, i);
4208             }
4209         }
4210 
4211         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::ASIN, Double256VectorTests::strictASIN);
4212     }
4213 
4214     static double ACOS(double a) {
4215         return (double)(Math.acos((double)a));
4216     }
4217 
4218     static double strictACOS(double a) {
4219         return (double)(StrictMath.acos((double)a));
4220     }
4221 
4222     @Test(dataProvider = "doubleUnaryOpProvider")
4223     static void ACOSDouble256VectorTests(IntFunction<double[]> fa) {
4224         double[] a = fa.apply(SPECIES.length());
4225         double[] r = fr.apply(SPECIES.length());
4226 
4227         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4228             for (int i = 0; i < a.length; i += SPECIES.length()) {
4229                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4230                 av.lanewise(VectorOperators.ACOS).intoArray(r, i);
4231             }
4232         }
4233 
4234         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::ACOS, Double256VectorTests::strictACOS);
4235     }
4236 
4237     static double ATAN(double a) {
4238         return (double)(Math.atan((double)a));
4239     }
4240 
4241     static double strictATAN(double a) {
4242         return (double)(StrictMath.atan((double)a));
4243     }
4244 
4245     @Test(dataProvider = "doubleUnaryOpProvider")
4246     static void ATANDouble256VectorTests(IntFunction<double[]> fa) {
4247         double[] a = fa.apply(SPECIES.length());
4248         double[] r = fr.apply(SPECIES.length());
4249 
4250         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4251             for (int i = 0; i < a.length; i += SPECIES.length()) {
4252                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4253                 av.lanewise(VectorOperators.ATAN).intoArray(r, i);
4254             }
4255         }
4256 
4257         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::ATAN, Double256VectorTests::strictATAN);
4258     }
4259 
4260     static double CBRT(double a) {
4261         return (double)(Math.cbrt((double)a));
4262     }
4263 
4264     static double strictCBRT(double a) {
4265         return (double)(StrictMath.cbrt((double)a));
4266     }
4267 
4268     @Test(dataProvider = "doubleUnaryOpProvider")
4269     static void CBRTDouble256VectorTests(IntFunction<double[]> fa) {
4270         double[] a = fa.apply(SPECIES.length());
4271         double[] r = fr.apply(SPECIES.length());
4272 
4273         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4274             for (int i = 0; i < a.length; i += SPECIES.length()) {
4275                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4276                 av.lanewise(VectorOperators.CBRT).intoArray(r, i);
4277             }
4278         }
4279 
4280         assertArraysEqualsWithinOneUlp(r, a, Double256VectorTests::CBRT, Double256VectorTests::strictCBRT);
4281     }
4282 
4283     static double HYPOT(double a, double b) {
4284         return (double)(Math.hypot((double)a, (double)b));
4285     }
4286 
4287     static double strictHYPOT(double a, double b) {
4288         return (double)(StrictMath.hypot((double)a, (double)b));
4289     }
4290 
4291     @Test(dataProvider = "doubleBinaryOpProvider")
4292     static void HYPOTDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4293         double[] a = fa.apply(SPECIES.length());
4294         double[] b = fb.apply(SPECIES.length());
4295         double[] r = fr.apply(SPECIES.length());
4296 
4297         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4298             for (int i = 0; i < a.length; i += SPECIES.length()) {
4299                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4300                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4301                 av.lanewise(VectorOperators.HYPOT, bv).intoArray(r, i);
4302             }
4303         }
4304 
4305         assertArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::HYPOT, Double256VectorTests::strictHYPOT);
4306     }
4307 
4308 
4309     static double POW(double a, double b) {
4310         return (double)(Math.pow((double)a, (double)b));
4311     }
4312 
4313     static double strictPOW(double a, double b) {
4314         return (double)(StrictMath.pow((double)a, (double)b));
4315     }
4316 
4317     @Test(dataProvider = "doubleBinaryOpProvider")
4318     static void POWDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4319         double[] a = fa.apply(SPECIES.length());
4320         double[] b = fb.apply(SPECIES.length());
4321         double[] r = fr.apply(SPECIES.length());
4322 
4323         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4324             for (int i = 0; i < a.length; i += SPECIES.length()) {
4325                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4326                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4327                 av.lanewise(VectorOperators.POW, bv).intoArray(r, i);
4328             }
4329         }
4330 
4331         assertArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::POW, Double256VectorTests::strictPOW);
4332     }
4333 
4334 
4335     static double pow(double a, double b) {
4336         return (double)(Math.pow((double)a, (double)b));
4337     }
4338 
4339     static double strictpow(double a, double b) {
4340         return (double)(StrictMath.pow((double)a, (double)b));
4341     }
4342 
4343     @Test(dataProvider = "doubleBinaryOpProvider")
4344     static void powDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4345         double[] a = fa.apply(SPECIES.length());
4346         double[] b = fb.apply(SPECIES.length());
4347         double[] r = fr.apply(SPECIES.length());
4348 
4349         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4350             for (int i = 0; i < a.length; i += SPECIES.length()) {
4351                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4352                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4353                 av.pow(bv).intoArray(r, i);
4354             }
4355         }
4356 
4357         assertArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::pow, Double256VectorTests::strictpow);
4358     }
4359 
4360 
4361     static double ATAN2(double a, double b) {
4362         return (double)(Math.atan2((double)a, (double)b));
4363     }
4364 
4365     static double strictATAN2(double a, double b) {
4366         return (double)(StrictMath.atan2((double)a, (double)b));
4367     }
4368 
4369     @Test(dataProvider = "doubleBinaryOpProvider")
4370     static void ATAN2Double256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4371         double[] a = fa.apply(SPECIES.length());
4372         double[] b = fb.apply(SPECIES.length());
4373         double[] r = fr.apply(SPECIES.length());
4374 
4375         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4376             for (int i = 0; i < a.length; i += SPECIES.length()) {
4377                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4378                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4379                 av.lanewise(VectorOperators.ATAN2, bv).intoArray(r, i);
4380             }
4381         }
4382 
4383         assertArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::ATAN2, Double256VectorTests::strictATAN2);
4384     }
4385 
4386 
4387     @Test(dataProvider = "doubleBinaryOpProvider")
4388     static void POWDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4389         double[] a = fa.apply(SPECIES.length());
4390         double[] b = fb.apply(SPECIES.length());
4391         double[] r = fr.apply(SPECIES.length());
4392 
4393         for (int i = 0; i < a.length; i += SPECIES.length()) {
4394             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4395             av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i);
4396         }
4397 
4398         assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::POW, Double256VectorTests::strictPOW);
4399     }
4400 
4401 
4402     @Test(dataProvider = "doubleBinaryOpProvider")
4403     static void powDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4404         double[] a = fa.apply(SPECIES.length());
4405         double[] b = fb.apply(SPECIES.length());
4406         double[] r = fr.apply(SPECIES.length());
4407 
4408         for (int i = 0; i < a.length; i += SPECIES.length()) {
4409             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4410             av.pow(b[i]).intoArray(r, i);
4411         }
4412 
4413         assertBroadcastArraysEqualsWithinOneUlp(r, a, b, Double256VectorTests::pow, Double256VectorTests::strictpow);
4414     }
4415 
4416 
4417     static double FMA(double a, double b, double c) {
4418         return (double)(Math.fma(a, b, c));
4419     }
4420 
4421     static double fma(double a, double b, double c) {
4422         return (double)(Math.fma(a, b, c));
4423     }
4424 
4425     @Test(dataProvider = "doubleTernaryOpProvider")
4426     static void FMADouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4427         int count = INVOC_COUNT;
4428         switch ("FMA") {
4429         case "fma": case "lanewise_FMA":
4430            // Math.fma uses BigDecimal
4431            count = Math.max(5, count/20); break;
4432         }
4433         final int INVOC_COUNT = count;
4434         double[] a = fa.apply(SPECIES.length());
4435         double[] b = fb.apply(SPECIES.length());
4436         double[] c = fc.apply(SPECIES.length());
4437         double[] r = fr.apply(SPECIES.length());
4438 
4439         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4440             for (int i = 0; i < a.length; i += SPECIES.length()) {
4441                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4442                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4443                 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
4444                 av.lanewise(VectorOperators.FMA, bv, cv).intoArray(r, i);
4445             }
4446         }
4447 
4448         assertArraysEquals(r, a, b, c, Double256VectorTests::FMA);
4449     }
4450 
4451     @Test(dataProvider = "doubleTernaryOpProvider")
4452     static void fmaDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4453         int count = INVOC_COUNT;
4454         switch ("fma") {
4455         case "fma": case "lanewise_FMA":
4456            // Math.fma uses BigDecimal
4457            count = Math.max(5, count/20); break;
4458         }
4459         final int INVOC_COUNT = count;
4460         double[] a = fa.apply(SPECIES.length());
4461         double[] b = fb.apply(SPECIES.length());
4462         double[] c = fc.apply(SPECIES.length());
4463         double[] r = fr.apply(SPECIES.length());
4464 
4465         for (int i = 0; i < a.length; i += SPECIES.length()) {
4466             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4467             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4468             DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
4469             av.fma(bv, cv).intoArray(r, i);
4470         }
4471 
4472         assertArraysEquals(r, a, b, c, Double256VectorTests::fma);
4473     }
4474 
4475     @Test(dataProvider = "doubleTernaryOpMaskProvider")
4476     static void FMADouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
4477                                           IntFunction<double[]> fc, IntFunction<boolean[]> fm) {
4478         int count = INVOC_COUNT;
4479         switch ("FMA") {
4480         case "fma": case "lanewise_FMA":
4481            // Math.fma uses BigDecimal
4482            count = Math.max(5, count/20); break;
4483         }
4484         final int INVOC_COUNT = count;
4485         double[] a = fa.apply(SPECIES.length());
4486         double[] b = fb.apply(SPECIES.length());
4487         double[] c = fc.apply(SPECIES.length());
4488         double[] r = fr.apply(SPECIES.length());
4489         boolean[] mask = fm.apply(SPECIES.length());
4490         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4491 
4492         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4493             for (int i = 0; i < a.length; i += SPECIES.length()) {
4494                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4495                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4496                 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
4497                 av.lanewise(VectorOperators.FMA, bv, cv, vmask).intoArray(r, i);
4498             }
4499         }
4500 
4501         assertArraysEquals(r, a, b, c, mask, Double256VectorTests::FMA);
4502     }
4503 
4504     @Test(dataProvider = "doubleTernaryOpProvider")
4505     static void FMADouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4506         double[] a = fa.apply(SPECIES.length());
4507         double[] b = fb.apply(SPECIES.length());
4508         double[] c = fc.apply(SPECIES.length());
4509         double[] r = fr.apply(SPECIES.length());
4510 
4511         for (int i = 0; i < a.length; i += SPECIES.length()) {
4512             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4513             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4514             av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i);
4515         }
4516         assertBroadcastArraysEquals(r, a, b, c, Double256VectorTests::FMA);
4517     }
4518 
4519     @Test(dataProvider = "doubleTernaryOpProvider")
4520     static void FMADouble256VectorTestsAltBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4521         double[] a = fa.apply(SPECIES.length());
4522         double[] b = fb.apply(SPECIES.length());
4523         double[] c = fc.apply(SPECIES.length());
4524         double[] r = fr.apply(SPECIES.length());
4525 
4526         for (int i = 0; i < a.length; i += SPECIES.length()) {
4527             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4528             DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
4529             av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i);
4530         }
4531         assertAltBroadcastArraysEquals(r, a, b, c, Double256VectorTests::FMA);
4532     }
4533 
4534     @Test(dataProvider = "doubleTernaryOpMaskProvider")
4535     static void FMADouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
4536                                           IntFunction<double[]> fc, IntFunction<boolean[]> fm) {
4537         double[] a = fa.apply(SPECIES.length());
4538         double[] b = fb.apply(SPECIES.length());
4539         double[] c = fc.apply(SPECIES.length());
4540         double[] r = fr.apply(SPECIES.length());
4541         boolean[] mask = fm.apply(SPECIES.length());
4542         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4543 
4544         for (int i = 0; i < a.length; i += SPECIES.length()) {
4545             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4546             DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4547             av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i);
4548         }
4549 
4550         assertBroadcastArraysEquals(r, a, b, c, mask, Double256VectorTests::FMA);
4551     }
4552 
4553     @Test(dataProvider = "doubleTernaryOpMaskProvider")
4554     static void FMADouble256VectorTestsAltBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
4555                                           IntFunction<double[]> fc, IntFunction<boolean[]> fm) {
4556         double[] a = fa.apply(SPECIES.length());
4557         double[] b = fb.apply(SPECIES.length());
4558         double[] c = fc.apply(SPECIES.length());
4559         double[] r = fr.apply(SPECIES.length());
4560         boolean[] mask = fm.apply(SPECIES.length());
4561         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4562 
4563         for (int i = 0; i < a.length; i += SPECIES.length()) {
4564             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4565             DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
4566             av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i);
4567         }
4568 
4569         assertAltBroadcastArraysEquals(r, a, b, c, mask, Double256VectorTests::FMA);
4570     }
4571 
4572     @Test(dataProvider = "doubleTernaryOpProvider")
4573     static void FMADouble256VectorTestsDoubleBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4574         int count = INVOC_COUNT;
4575         switch ("FMA") {
4576         case "fma": case "lanewise_FMA":
4577            // Math.fma uses BigDecimal
4578            count = Math.max(5, count/20); break;
4579         }
4580         final int INVOC_COUNT = count;
4581         double[] a = fa.apply(SPECIES.length());
4582         double[] b = fb.apply(SPECIES.length());
4583         double[] c = fc.apply(SPECIES.length());
4584         double[] r = fr.apply(SPECIES.length());
4585 
4586         for (int i = 0; i < a.length; i += SPECIES.length()) {
4587             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4588             av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i);
4589         }
4590 
4591         assertDoubleBroadcastArraysEquals(r, a, b, c, Double256VectorTests::FMA);
4592     }
4593 
4594     @Test(dataProvider = "doubleTernaryOpProvider")
4595     static void fmaDouble256VectorTestsDoubleBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4596         int count = INVOC_COUNT;
4597         switch ("fma") {
4598         case "fma": case "lanewise_FMA":
4599            // Math.fma uses BigDecimal
4600            count = Math.max(5, count/20); break;
4601         }
4602         final int INVOC_COUNT = count;
4603         double[] a = fa.apply(SPECIES.length());
4604         double[] b = fb.apply(SPECIES.length());
4605         double[] c = fc.apply(SPECIES.length());
4606         double[] r = fr.apply(SPECIES.length());
4607 
4608         for (int i = 0; i < a.length; i += SPECIES.length()) {
4609             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4610             av.fma(b[i], c[i]).intoArray(r, i);
4611         }
4612 
4613         assertDoubleBroadcastArraysEquals(r, a, b, c, Double256VectorTests::fma);
4614     }
4615 
4616     @Test(dataProvider = "doubleTernaryOpMaskProvider")
4617     static void FMADouble256VectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
4618                                           IntFunction<double[]> fc, IntFunction<boolean[]> fm) {
4619         int count = INVOC_COUNT;
4620         switch ("FMA") {
4621         case "fma": case "lanewise_FMA":
4622            // Math.fma uses BigDecimal
4623            count = Math.max(5, count/20); break;
4624         }
4625         final int INVOC_COUNT = count;
4626         double[] a = fa.apply(SPECIES.length());
4627         double[] b = fb.apply(SPECIES.length());
4628         double[] c = fc.apply(SPECIES.length());
4629         double[] r = fr.apply(SPECIES.length());
4630         boolean[] mask = fm.apply(SPECIES.length());
4631         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4632 
4633         for (int i = 0; i < a.length; i += SPECIES.length()) {
4634             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4635             av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i);
4636         }
4637 
4638         assertDoubleBroadcastArraysEquals(r, a, b, c, mask, Double256VectorTests::FMA);
4639     }
4640 
4641     static double NEG(double a) {
4642         return (double)(-((double)a));
4643     }
4644 
4645     static double neg(double a) {
4646         return (double)(-((double)a));
4647     }
4648 
4649     @Test(dataProvider = "doubleUnaryOpProvider")
4650     static void NEGDouble256VectorTests(IntFunction<double[]> fa) {
4651         double[] a = fa.apply(SPECIES.length());
4652         double[] r = fr.apply(SPECIES.length());
4653 
4654         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4655             for (int i = 0; i < a.length; i += SPECIES.length()) {
4656                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4657                 av.lanewise(VectorOperators.NEG).intoArray(r, i);
4658             }
4659         }
4660 
4661         assertArraysEquals(r, a, Double256VectorTests::NEG);
4662     }
4663 
4664     @Test(dataProvider = "doubleUnaryOpProvider")
4665     static void negDouble256VectorTests(IntFunction<double[]> fa) {
4666         double[] a = fa.apply(SPECIES.length());
4667         double[] r = fr.apply(SPECIES.length());
4668 
4669         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4670             for (int i = 0; i < a.length; i += SPECIES.length()) {
4671                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4672                 av.neg().intoArray(r, i);
4673             }
4674         }
4675 
4676         assertArraysEquals(r, a, Double256VectorTests::neg);
4677     }
4678 
4679     @Test(dataProvider = "doubleUnaryOpMaskProvider")
4680     static void NEGMaskedDouble256VectorTests(IntFunction<double[]> fa,
4681                                                 IntFunction<boolean[]> fm) {
4682         double[] a = fa.apply(SPECIES.length());
4683         double[] r = fr.apply(SPECIES.length());
4684         boolean[] mask = fm.apply(SPECIES.length());
4685         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4686 
4687         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4688             for (int i = 0; i < a.length; i += SPECIES.length()) {
4689                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4690                 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
4691             }
4692         }
4693 
4694         assertArraysEquals(r, a, mask, Double256VectorTests::NEG);
4695     }
4696 
4697     static double ABS(double a) {
4698         return (double)(Math.abs((double)a));
4699     }
4700 
4701     static double abs(double a) {
4702         return (double)(Math.abs((double)a));
4703     }
4704 
4705     @Test(dataProvider = "doubleUnaryOpProvider")
4706     static void ABSDouble256VectorTests(IntFunction<double[]> fa) {
4707         double[] a = fa.apply(SPECIES.length());
4708         double[] r = fr.apply(SPECIES.length());
4709 
4710         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4711             for (int i = 0; i < a.length; i += SPECIES.length()) {
4712                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4713                 av.lanewise(VectorOperators.ABS).intoArray(r, i);
4714             }
4715         }
4716 
4717         assertArraysEquals(r, a, Double256VectorTests::ABS);
4718     }
4719 
4720     @Test(dataProvider = "doubleUnaryOpProvider")
4721     static void absDouble256VectorTests(IntFunction<double[]> fa) {
4722         double[] a = fa.apply(SPECIES.length());
4723         double[] r = fr.apply(SPECIES.length());
4724 
4725         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4726             for (int i = 0; i < a.length; i += SPECIES.length()) {
4727                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4728                 av.abs().intoArray(r, i);
4729             }
4730         }
4731 
4732         assertArraysEquals(r, a, Double256VectorTests::abs);
4733     }
4734 
4735     @Test(dataProvider = "doubleUnaryOpMaskProvider")
4736     static void ABSMaskedDouble256VectorTests(IntFunction<double[]> fa,
4737                                                 IntFunction<boolean[]> fm) {
4738         double[] a = fa.apply(SPECIES.length());
4739         double[] r = fr.apply(SPECIES.length());
4740         boolean[] mask = fm.apply(SPECIES.length());
4741         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4742 
4743         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4744             for (int i = 0; i < a.length; i += SPECIES.length()) {
4745                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4746                 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
4747             }
4748         }
4749 
4750         assertArraysEquals(r, a, mask, Double256VectorTests::ABS);
4751     }
4752 
4753     static double SQRT(double a) {
4754         return (double)(Math.sqrt((double)a));
4755     }
4756 
4757     static double sqrt(double a) {
4758         return (double)(Math.sqrt((double)a));
4759     }
4760 
4761     @Test(dataProvider = "doubleUnaryOpProvider")
4762     static void SQRTDouble256VectorTests(IntFunction<double[]> fa) {
4763         double[] a = fa.apply(SPECIES.length());
4764         double[] r = fr.apply(SPECIES.length());
4765 
4766         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4767             for (int i = 0; i < a.length; i += SPECIES.length()) {
4768                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4769                 av.lanewise(VectorOperators.SQRT).intoArray(r, i);
4770             }
4771         }
4772 
4773         assertArraysEquals(r, a, Double256VectorTests::SQRT);
4774     }
4775 
4776     @Test(dataProvider = "doubleUnaryOpProvider")
4777     static void sqrtDouble256VectorTests(IntFunction<double[]> fa) {
4778         double[] a = fa.apply(SPECIES.length());
4779         double[] r = fr.apply(SPECIES.length());
4780 
4781         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4782             for (int i = 0; i < a.length; i += SPECIES.length()) {
4783                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4784                 av.sqrt().intoArray(r, i);
4785             }
4786         }
4787 
4788         assertArraysEquals(r, a, Double256VectorTests::sqrt);
4789     }
4790 
4791     @Test(dataProvider = "doubleUnaryOpMaskProvider")
4792     static void SQRTMaskedDouble256VectorTests(IntFunction<double[]> fa,
4793                                                 IntFunction<boolean[]> fm) {
4794         double[] a = fa.apply(SPECIES.length());
4795         double[] r = fr.apply(SPECIES.length());
4796         boolean[] mask = fm.apply(SPECIES.length());
4797         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4798 
4799         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4800             for (int i = 0; i < a.length; i += SPECIES.length()) {
4801                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4802                 av.lanewise(VectorOperators.SQRT, vmask).intoArray(r, i);
4803             }
4804         }
4805 
4806         assertArraysEquals(r, a, mask, Double256VectorTests::SQRT);
4807     }
4808 
4809     @Test(dataProvider = "doubleCompareOpProvider")
4810     static void ltDouble256VectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4811         double[] a = fa.apply(SPECIES.length());
4812         double[] b = fb.apply(SPECIES.length());
4813 
4814         for (int i = 0; i < a.length; i += SPECIES.length()) {
4815             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4816             VectorMask<Double> mv = av.lt(b[i]);
4817 
4818             // Check results as part of computation.
4819             for (int j = 0; j < SPECIES.length(); j++) {
4820                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
4821             }
4822         }
4823     }
4824 
4825     @Test(dataProvider = "doubleCompareOpProvider")
4826     static void eqDouble256VectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4827         double[] a = fa.apply(SPECIES.length());
4828         double[] b = fb.apply(SPECIES.length());
4829 
4830         for (int i = 0; i < a.length; i += SPECIES.length()) {
4831             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4832             VectorMask<Double> mv = av.eq(b[i]);
4833 
4834             // Check results as part of computation.
4835             for (int j = 0; j < SPECIES.length(); j++) {
4836                 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
4837             }
4838         }
4839     }
4840 
4841     @Test(dataProvider = "doubletoIntUnaryOpProvider")
4842     static void toIntArrayDouble256VectorTestsSmokeTest(IntFunction<double[]> fa) {
4843         double[] a = fa.apply(SPECIES.length());
4844 
4845         for (int i = 0; i < a.length; i += SPECIES.length()) {
4846             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4847             int[] r = av.toIntArray();
4848             assertArraysEquals(r, a, i);
4849         }
4850     }
4851 
4852     @Test(dataProvider = "doubletoLongUnaryOpProvider")
4853     static void toLongArrayDouble256VectorTestsSmokeTest(IntFunction<double[]> fa) {
4854         double[] a = fa.apply(SPECIES.length());
4855 
4856         for (int i = 0; i < a.length; i += SPECIES.length()) {
4857             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4858             long[] r = av.toLongArray();
4859             assertArraysEquals(r, a, i);
4860         }
4861     }
4862 
4863 
4864     @Test(dataProvider = "doubleUnaryOpProvider")
4865     static void toStringDouble256VectorTestsSmokeTest(IntFunction<double[]> fa) {
4866         double[] a = fa.apply(SPECIES.length());
4867 
4868         for (int i = 0; i < a.length; i += SPECIES.length()) {
4869             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4870             String str = av.toString();
4871 
4872             double subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
4873             Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
4874         }
4875     }
4876 
4877     @Test(dataProvider = "doubleUnaryOpProvider")
4878     static void hashCodeDouble256VectorTestsSmokeTest(IntFunction<double[]> fa) {
4879         double[] a = fa.apply(SPECIES.length());
4880 
4881         for (int i = 0; i < a.length; i += SPECIES.length()) {
4882             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4883             int hash = av.hashCode();
4884 
4885             double subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
4886             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
4887             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
4888         }
4889     }
4890 
4891 
4892     static long ADDReduceLong(double[] a, int idx) {
4893         double res = 0;
4894         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4895             res += a[i];
4896         }
4897 
4898         return (long)res;
4899     }
4900 
4901     static long ADDReduceAllLong(double[] a) {
4902         long res = 0;
4903         for (int i = 0; i < a.length; i += SPECIES.length()) {
4904             res += ADDReduceLong(a, i);
4905         }
4906 
4907         return res;
4908     }
4909 
4910     @Test(dataProvider = "doubleUnaryOpProvider")
4911     static void ADDReduceLongDouble256VectorTests(IntFunction<double[]> fa) {
4912         double[] a = fa.apply(SPECIES.length());
4913         long[] r = lfr.apply(SPECIES.length());
4914         long ra = 0;
4915 
4916         for (int i = 0; i < a.length; i += SPECIES.length()) {
4917             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4918             r[i] = av.reduceLanesToLong(VectorOperators.ADD);
4919         }
4920 
4921         ra = 0;
4922         for (int i = 0; i < a.length; i ++) {
4923             ra += r[i];
4924         }
4925 
4926         assertReductionLongArraysEquals(r, ra, a,
4927                 Double256VectorTests::ADDReduceLong, Double256VectorTests::ADDReduceAllLong);
4928     }
4929 
4930     static long ADDReduceLongMasked(double[] a, int idx, boolean[] mask) {
4931         double res = 0;
4932         for (int i = idx; i < (idx + SPECIES.length()); i++) {
4933             if(mask[i % SPECIES.length()])
4934                 res += a[i];
4935         }
4936 
4937         return (long)res;
4938     }
4939 
4940     static long ADDReduceAllLongMasked(double[] a, boolean[] mask) {
4941         long res = 0;
4942         for (int i = 0; i < a.length; i += SPECIES.length()) {
4943             res += ADDReduceLongMasked(a, i, mask);
4944         }
4945 
4946         return res;
4947     }
4948 
4949     @Test(dataProvider = "doubleUnaryOpMaskProvider")
4950     static void ADDReduceLongDouble256VectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
4951         double[] a = fa.apply(SPECIES.length());
4952         long[] r = lfr.apply(SPECIES.length());
4953         boolean[] mask = fm.apply(SPECIES.length());
4954         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4955         long ra = 0;
4956 
4957         for (int i = 0; i < a.length; i += SPECIES.length()) {
4958             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4959             r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
4960         }
4961 
4962         ra = 0;
4963         for (int i = 0; i < a.length; i ++) {
4964             ra += r[i];
4965         }
4966 
4967         assertReductionLongArraysEqualsMasked(r, ra, a, mask,
4968                 Double256VectorTests::ADDReduceLongMasked, Double256VectorTests::ADDReduceAllLongMasked);
4969     }
4970 
4971     @Test(dataProvider = "doubletoLongUnaryOpProvider")
4972     static void BroadcastLongDouble256VectorTestsSmokeTest(IntFunction<double[]> fa) {
4973         double[] a = fa.apply(SPECIES.length());
4974         double[] r = new double[a.length];
4975 
4976         for (int i = 0; i < a.length; i += SPECIES.length()) {
4977             DoubleVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
4978         }
4979         assertBroadcastArraysEquals(r, a);
4980     }
4981 
4982     @Test(dataProvider = "doubleBinaryOpMaskProvider")
4983     static void blendDouble256VectorTestsBroadcastLongSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
4984                                           IntFunction<boolean[]> fm) {
4985         double[] a = fa.apply(SPECIES.length());
4986         double[] b = fb.apply(SPECIES.length());
4987         double[] r = fr.apply(SPECIES.length());
4988         boolean[] mask = fm.apply(SPECIES.length());
4989         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4990 
4991         for (int ic = 0; ic < INVOC_COUNT; ic++) {
4992             for (int i = 0; i < a.length; i += SPECIES.length()) {
4993                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4994                 av.blend((long)b[i], vmask).intoArray(r, i);
4995             }
4996         }
4997         assertBroadcastLongArraysEquals(r, a, b, mask, Double256VectorTests::blend);
4998     }
4999 
5000 
5001     @Test(dataProvider = "doubleUnaryOpSelectFromProvider")
5002     static void SelectFromDouble256VectorTests(IntFunction<double[]> fa,
5003                                            BiFunction<Integer,Integer,double[]> fs) {
5004         double[] a = fa.apply(SPECIES.length());
5005         double[] order = fs.apply(a.length, SPECIES.length());
5006         double[] r = fr.apply(SPECIES.length());
5007 
5008         for (int i = 0; i < a.length; i += SPECIES.length()) {
5009             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
5010             DoubleVector bv = DoubleVector.fromArray(SPECIES, order, i);
5011             bv.selectFrom(av).intoArray(r, i);
5012         }
5013 
5014         assertSelectFromArraysEquals(r, a, order, SPECIES.length());
5015     }
5016 
5017     @Test(dataProvider = "doubleSelectFromTwoVectorOpProvider")
5018     static void SelectFromTwoVectorDouble256VectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
5019         double[] a = fa.apply(SPECIES.length());
5020         double[] b = fb.apply(SPECIES.length());
5021         double[] idx = fc.apply(SPECIES.length());
5022         double[] r = fr.apply(SPECIES.length());
5023 
5024         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5025             for (int i = 0; i < idx.length; i += SPECIES.length()) {
5026                 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
5027                 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
5028                 DoubleVector idxv = DoubleVector.fromArray(SPECIES, idx, i);
5029                 idxv.selectFrom(av, bv).intoArray(r, i);
5030             }
5031         }
5032         assertSelectFromTwoVectorEquals(r, idx, a, b, SPECIES.length());
5033     }
5034 
5035     @Test(dataProvider = "doubleUnaryOpSelectFromMaskProvider")
5036     static void SelectFromDouble256VectorTestsMaskedSmokeTest(IntFunction<double[]> fa,
5037                                                            BiFunction<Integer,Integer,double[]> fs,
5038                                                            IntFunction<boolean[]> fm) {
5039         double[] a = fa.apply(SPECIES.length());
5040         double[] order = fs.apply(a.length, SPECIES.length());
5041         double[] r = fr.apply(SPECIES.length());
5042         boolean[] mask = fm.apply(SPECIES.length());
5043         VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5044 
5045         for (int i = 0; i < a.length; i += SPECIES.length()) {
5046             DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
5047             DoubleVector bv = DoubleVector.fromArray(SPECIES, order, i);
5048             bv.selectFrom(av, vmask).intoArray(r, i);
5049         }
5050 
5051         assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
5052     }
5053 
5054     @Test(dataProvider = "shuffleProvider")
5055     static void shuffleMiscellaneousDouble256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5056         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5057 
5058         for (int i = 0; i < a.length; i += SPECIES.length()) {
5059             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5060             int hash = shuffle.hashCode();
5061             int length = shuffle.length();
5062 
5063             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5064             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5065             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5066             Assert.assertEquals(length, SPECIES.length());
5067         }
5068     }
5069 
5070     @Test(dataProvider = "shuffleProvider")
5071     static void shuffleToStringDouble256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5072         int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5073 
5074         for (int i = 0; i < a.length; i += SPECIES.length()) {
5075             var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5076             String str = shuffle.toString();
5077 
5078             int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5079             Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
5080                 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5081         }
5082     }
5083 
5084     @Test(dataProvider = "shuffleCompareOpProvider")
5085     static void shuffleEqualsDouble256VectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
5086         int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5087         int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5088 
5089         for (int i = 0; i < a.length; i += SPECIES.length()) {
5090             var av = VectorShuffle.fromArray(SPECIES, a, i);
5091             var bv = VectorShuffle.fromArray(SPECIES, b, i);
5092             boolean eq = av.equals(bv);
5093             int to = i + SPECIES.length();
5094             Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
5095         }
5096     }
5097 
5098     @Test(dataProvider = "maskCompareOpProvider")
5099     static void maskEqualsDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5100         boolean[] a = fa.apply(SPECIES.length());
5101         boolean[] b = fb.apply(SPECIES.length());
5102 
5103         for (int i = 0; i < a.length; i += SPECIES.length()) {
5104             var av = SPECIES.loadMask(a, i);
5105             var bv = SPECIES.loadMask(b, i);
5106             boolean equals = av.equals(bv);
5107             int to = i + SPECIES.length();
5108             Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
5109         }
5110     }
5111 
5112     static boolean band(boolean a, boolean b) {
5113         return a & b;
5114     }
5115 
5116     @Test(dataProvider = "maskCompareOpProvider")
5117     static void maskAndDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5118         boolean[] a = fa.apply(SPECIES.length());
5119         boolean[] b = fb.apply(SPECIES.length());
5120         boolean[] r = new boolean[a.length];
5121 
5122         for (int i = 0; i < a.length; i += SPECIES.length()) {
5123             var av = SPECIES.loadMask(a, i);
5124             var bv = SPECIES.loadMask(b, i);
5125             var cv = av.and(bv);
5126             cv.intoArray(r, i);
5127         }
5128         assertArraysEquals(r, a, b, Double256VectorTests::band);
5129     }
5130 
5131     static boolean bor(boolean a, boolean b) {
5132         return a | b;
5133     }
5134 
5135     @Test(dataProvider = "maskCompareOpProvider")
5136     static void maskOrDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5137         boolean[] a = fa.apply(SPECIES.length());
5138         boolean[] b = fb.apply(SPECIES.length());
5139         boolean[] r = new boolean[a.length];
5140 
5141         for (int i = 0; i < a.length; i += SPECIES.length()) {
5142             var av = SPECIES.loadMask(a, i);
5143             var bv = SPECIES.loadMask(b, i);
5144             var cv = av.or(bv);
5145             cv.intoArray(r, i);
5146         }
5147         assertArraysEquals(r, a, b, Double256VectorTests::bor);
5148     }
5149 
5150     static boolean bxor(boolean a, boolean b) {
5151         return a != b;
5152     }
5153 
5154     @Test(dataProvider = "maskCompareOpProvider")
5155     static void maskXorDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5156         boolean[] a = fa.apply(SPECIES.length());
5157         boolean[] b = fb.apply(SPECIES.length());
5158         boolean[] r = new boolean[a.length];
5159 
5160         for (int i = 0; i < a.length; i += SPECIES.length()) {
5161             var av = SPECIES.loadMask(a, i);
5162             var bv = SPECIES.loadMask(b, i);
5163             var cv = av.xor(bv);
5164             cv.intoArray(r, i);
5165         }
5166         assertArraysEquals(r, a, b, Double256VectorTests::bxor);
5167     }
5168 
5169     static boolean bandNot(boolean a, boolean b) {
5170         return a & !b;
5171     }
5172 
5173     @Test(dataProvider = "maskCompareOpProvider")
5174     static void maskAndNotDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5175         boolean[] a = fa.apply(SPECIES.length());
5176         boolean[] b = fb.apply(SPECIES.length());
5177         boolean[] r = new boolean[a.length];
5178 
5179         for (int i = 0; i < a.length; i += SPECIES.length()) {
5180             var av = SPECIES.loadMask(a, i);
5181             var bv = SPECIES.loadMask(b, i);
5182             var cv = av.andNot(bv);
5183             cv.intoArray(r, i);
5184         }
5185         assertArraysEquals(r, a, b, Double256VectorTests::bandNot);
5186     }
5187 
5188     static boolean beq(boolean a, boolean b) {
5189         return (a == b);
5190     }
5191 
5192     @Test(dataProvider = "maskCompareOpProvider")
5193     static void maskEqDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5194         boolean[] a = fa.apply(SPECIES.length());
5195         boolean[] b = fb.apply(SPECIES.length());
5196         boolean[] r = new boolean[a.length];
5197 
5198         for (int i = 0; i < a.length; i += SPECIES.length()) {
5199             var av = SPECIES.loadMask(a, i);
5200             var bv = SPECIES.loadMask(b, i);
5201             var cv = av.eq(bv);
5202             cv.intoArray(r, i);
5203         }
5204         assertArraysEquals(r, a, b, Double256VectorTests::beq);
5205     }
5206 
5207     @Test(dataProvider = "maskProvider")
5208     static void maskHashCodeDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5209         boolean[] a = fa.apply(SPECIES.length());
5210 
5211         for (int i = 0; i < a.length; i += SPECIES.length()) {
5212             var vmask = SPECIES.loadMask(a, i);
5213             int hash = vmask.hashCode();
5214 
5215             boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5216             int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5217             Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5218         }
5219     }
5220 
5221     static int maskTrueCount(boolean[] a, int idx) {
5222         int trueCount = 0;
5223         for (int i = idx; i < idx + SPECIES.length(); i++) {
5224             trueCount += a[i] ? 1 : 0;
5225         }
5226         return trueCount;
5227     }
5228 
5229     @Test(dataProvider = "maskProvider")
5230     static void maskTrueCountDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5231         boolean[] a = fa.apply(SPECIES.length());
5232         int[] r = new int[a.length];
5233 
5234         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5235             for (int i = 0; i < a.length; i += SPECIES.length()) {
5236                 var vmask = SPECIES.loadMask(a, i);
5237                 r[i] = vmask.trueCount();
5238             }
5239         }
5240 
5241         assertMaskReductionArraysEquals(r, a, Double256VectorTests::maskTrueCount);
5242     }
5243 
5244     static int maskLastTrue(boolean[] a, int idx) {
5245         int i = idx + SPECIES.length() - 1;
5246         for (; i >= idx; i--) {
5247             if (a[i]) {
5248                 break;
5249             }
5250         }
5251         return i - idx;
5252     }
5253 
5254     @Test(dataProvider = "maskProvider")
5255     static void maskLastTrueDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5256         boolean[] a = fa.apply(SPECIES.length());
5257         int[] r = new int[a.length];
5258 
5259         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5260             for (int i = 0; i < a.length; i += SPECIES.length()) {
5261                 var vmask = SPECIES.loadMask(a, i);
5262                 r[i] = vmask.lastTrue();
5263             }
5264         }
5265 
5266         assertMaskReductionArraysEquals(r, a, Double256VectorTests::maskLastTrue);
5267     }
5268 
5269     static int maskFirstTrue(boolean[] a, int idx) {
5270         int i = idx;
5271         for (; i < idx + SPECIES.length(); i++) {
5272             if (a[i]) {
5273                 break;
5274             }
5275         }
5276         return i - idx;
5277     }
5278 
5279     @Test(dataProvider = "maskProvider")
5280     static void maskFirstTrueDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5281         boolean[] a = fa.apply(SPECIES.length());
5282         int[] r = new int[a.length];
5283 
5284         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5285             for (int i = 0; i < a.length; i += SPECIES.length()) {
5286                 var vmask = SPECIES.loadMask(a, i);
5287                 r[i] = vmask.firstTrue();
5288             }
5289         }
5290 
5291         assertMaskReductionArraysEquals(r, a, Double256VectorTests::maskFirstTrue);
5292     }
5293 
5294     @Test(dataProvider = "maskProvider")
5295     static void maskCompressDouble256VectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5296         int trueCount = 0;
5297         boolean[] a = fa.apply(SPECIES.length());
5298 
5299         for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5300             for (int i = 0; i < a.length; i += SPECIES.length()) {
5301                 var vmask = SPECIES.loadMask(a, i);
5302                 trueCount = vmask.trueCount();
5303                 var rmask = vmask.compress();
5304                 for (int j = 0; j < SPECIES.length(); j++)  {
5305                     Assert.assertEquals(rmask.laneIsSet(j), j < trueCount);
5306                 }
5307             }
5308         }
5309     }
5310 
5311     @DataProvider
5312     public static Object[][] longMaskProvider() {
5313         return new Object[][]{
5314                 {0xFFFFFFFFFFFFFFFFL},
5315                 {0x0000000000000000L},
5316                 {0x5555555555555555L},
5317                 {0x0123456789abcdefL},
5318         };
5319     }
5320 
5321     @Test(dataProvider = "longMaskProvider")
5322     static void maskFromToLongDouble256VectorTestsSmokeTest(long inputLong) {
5323         var vmask = VectorMask.fromLong(SPECIES, inputLong);
5324         long outputLong = vmask.toLong();
5325         Assert.assertEquals(outputLong, (inputLong & (((0xFFFFFFFFFFFFFFFFL >>> (64 - SPECIES.length()))))));
5326     }
5327 
5328     @DataProvider
5329     public static Object[][] offsetProvider() {
5330         return new Object[][]{
5331                 {0},
5332                 {-1},
5333                 {+1},
5334                 {+2},
5335                 {-2},
5336         };
5337     }
5338 
5339     @Test(dataProvider = "offsetProvider")
5340     static void indexInRangeDouble256VectorTestsSmokeTest(int offset) {
5341         int limit = SPECIES.length() * BUFFER_REPS;
5342         for (int i = 0; i < limit; i += SPECIES.length()) {
5343             var actualMask = SPECIES.indexInRange(i + offset, limit);
5344             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5345             assert(actualMask.equals(expectedMask));
5346             for (int j = 0; j < SPECIES.length(); j++)  {
5347                 int index = i + j + offset;
5348                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
5349             }
5350         }
5351     }
5352 
5353     @Test(dataProvider = "offsetProvider")
5354     static void indexInRangeLongDouble256VectorTestsSmokeTest(int offset) {
5355         long limit = SPECIES.length() * BUFFER_REPS;
5356         for (long i = 0; i < limit; i += SPECIES.length()) {
5357             var actualMask = SPECIES.indexInRange(i + offset, limit);
5358             var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5359             assert(actualMask.equals(expectedMask));
5360             for (int j = 0; j < SPECIES.length(); j++)  {
5361                 long index = i + j + offset;
5362                 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
5363             }
5364         }
5365     }
5366 
5367     @DataProvider
5368     public static Object[][] lengthProvider() {
5369         return new Object[][]{
5370                 {0},
5371                 {1},
5372                 {32},
5373                 {37},
5374                 {1024},
5375                 {1024+1},
5376                 {1024+5},
5377         };
5378     }
5379 
5380     @Test(dataProvider = "lengthProvider")
5381     static void loopBoundDouble256VectorTestsSmokeTest(int length) {
5382         int actualLoopBound = SPECIES.loopBound(length);
5383         int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
5384         Assert.assertEquals(actualLoopBound, expectedLoopBound);
5385     }
5386 
5387     @Test(dataProvider = "lengthProvider")
5388     static void loopBoundLongDouble256VectorTestsSmokeTest(int _length) {
5389         long length = _length;
5390         long actualLoopBound = SPECIES.loopBound(length);
5391         long expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
5392         Assert.assertEquals(actualLoopBound, expectedLoopBound);
5393     }
5394 
5395     @Test
5396     static void ElementSizeDouble256VectorTestsSmokeTest() {
5397         DoubleVector av = DoubleVector.zero(SPECIES);
5398         int elsize = av.elementSize();
5399         Assert.assertEquals(elsize, Double.SIZE);
5400     }
5401 
5402     @Test
5403     static void VectorShapeDouble256VectorTestsSmokeTest() {
5404         DoubleVector av = DoubleVector.zero(SPECIES);
5405         VectorShape vsh = av.shape();
5406         assert(vsh.equals(VectorShape.S_256_BIT));
5407     }
5408 
5409     @Test
5410     static void ShapeWithLanesDouble256VectorTestsSmokeTest() {
5411         DoubleVector av = DoubleVector.zero(SPECIES);
5412         VectorShape vsh = av.shape();
5413         VectorSpecies species = vsh.withLanes(double.class);
5414         assert(species.equals(SPECIES));
5415     }
5416 
5417     @Test
5418     static void ElementTypeDouble256VectorTestsSmokeTest() {
5419         DoubleVector av = DoubleVector.zero(SPECIES);
5420         assert(av.species().elementType() == double.class);
5421     }
5422 
5423     @Test
5424     static void SpeciesElementSizeDouble256VectorTestsSmokeTest() {
5425         DoubleVector av = DoubleVector.zero(SPECIES);
5426         assert(av.species().elementSize() == Double.SIZE);
5427     }
5428 
5429     @Test
5430     static void VectorTypeDouble256VectorTestsSmokeTest() {
5431         DoubleVector av = DoubleVector.zero(SPECIES);
5432         assert(av.species().vectorType() == av.getClass());
5433     }
5434 
5435     @Test
5436     static void WithLanesDouble256VectorTestsSmokeTest() {
5437         DoubleVector av = DoubleVector.zero(SPECIES);
5438         VectorSpecies species = av.species().withLanes(double.class);
5439         assert(species.equals(SPECIES));
5440     }
5441 
5442     @Test
5443     static void WithShapeDouble256VectorTestsSmokeTest() {
5444         DoubleVector av = DoubleVector.zero(SPECIES);
5445         VectorShape vsh = av.shape();
5446         VectorSpecies species = av.species().withShape(vsh);
5447         assert(species.equals(SPECIES));
5448     }
5449 
5450     @Test
5451     static void MaskAllTrueDouble256VectorTestsSmokeTest() {
5452         for (int ic = 0; ic < INVOC_COUNT; ic++) {
5453           Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
5454         }
5455     }
5456 }
--- EOF ---