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