1 /* 2 * Copyright (c) 2018, 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 21 * questions. 22 */ 23 24 /* 25 * @test 26 * @modules jdk.incubator.vector 27 * @run testng/othervm -ea -esa DoubleMaxVectorTests 28 */ 29 30 import jdk.incubator.vector.VectorShape; 31 import jdk.incubator.vector.VectorSpecies; 32 import jdk.incubator.vector.VectorShuffle; 33 import jdk.incubator.vector.VectorMask; 34 import jdk.incubator.vector.Vector; 35 36 import jdk.incubator.vector.DoubleVector; 37 38 import org.testng.Assert; 39 import org.testng.annotations.DataProvider; 40 import org.testng.annotations.Test; 41 42 import java.lang.Integer; 43 import java.util.List; 44 import java.util.Arrays; 45 import java.util.function.BiFunction; 46 import java.util.function.IntFunction; 47 import java.util.stream.Collectors; 48 import java.util.stream.Stream; 49 50 @Test 51 public class DoubleMaxVectorTests extends AbstractVectorTest { 52 53 static final VectorSpecies<Double> SPECIES = 54 DoubleVector.SPECIES_MAX; 55 56 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100); 57 58 static VectorShape getMaxBit() { 59 return VectorShape.S_Max_BIT; 60 } 61 62 interface FUnOp { 63 double apply(double a); 64 } 65 66 static void assertArraysEquals(double[] a, double[] r, FUnOp f) { 67 int i = 0; 68 try { 69 for (; i < a.length; i++) { 70 Assert.assertEquals(r[i], f.apply(a[i])); 71 } 72 } catch (AssertionError e) { 73 Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]); 74 } 75 } 76 77 static void assertArraysEquals(double[] a, double[] r, boolean[] mask, FUnOp f) { 78 int i = 0; 79 try { 80 for (; i < a.length; i++) { 81 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]); 82 } 83 } catch (AssertionError e) { 84 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()]); 85 } 86 } 87 88 interface FReductionOp { 89 double apply(double[] a, int idx); 90 } 91 92 interface FReductionAllOp { 93 double apply(double[] a); 94 } 95 96 static void assertReductionArraysEquals(double[] a, double[] b, double c, 97 FReductionOp f, FReductionAllOp fa) { 98 int i = 0; 99 try { 100 Assert.assertEquals(c, fa.apply(a)); 101 for (; i < a.length; i += SPECIES.length()) { 102 Assert.assertEquals(b[i], f.apply(a, i)); 103 } 104 } catch (AssertionError e) { 105 Assert.assertEquals(c, fa.apply(a), "Final result is incorrect!"); 106 Assert.assertEquals(b[i], f.apply(a, i), "at index #" + i); 107 } 108 } 109 110 interface FBoolReductionOp { 111 boolean apply(boolean[] a, int idx); 112 } 113 114 static void assertReductionBoolArraysEquals(boolean[] a, boolean[] b, FBoolReductionOp f) { 115 int i = 0; 116 try { 117 for (; i < a.length; i += SPECIES.length()) { 118 Assert.assertEquals(f.apply(a, i), b[i]); 119 } 120 } catch (AssertionError e) { 121 Assert.assertEquals(f.apply(a, i), b[i], "at index #" + i); 122 } 123 } 124 125 static void assertInsertArraysEquals(double[] a, double[] b, double element, int index) { 126 int i = 0; 127 try { 128 for (; i < a.length; i += 1) { 129 if(i%SPECIES.length() == index) { 130 Assert.assertEquals(b[i], element); 131 } else { 132 Assert.assertEquals(b[i], a[i]); 133 } 134 } 135 } catch (AssertionError e) { 136 if (i%SPECIES.length() == index) { 137 Assert.assertEquals(b[i], element, "at index #" + i); 138 } else { 139 Assert.assertEquals(b[i], a[i], "at index #" + i); 140 } 141 } 142 } 143 144 static void assertRearrangeArraysEquals(double[] a, double[] r, int[] order, int vector_len) { 145 int i = 0, j = 0; 146 try { 147 for (; i < a.length; i += vector_len) { 148 for (j = 0; j < vector_len; j++) { 149 Assert.assertEquals(r[i+j], a[i+order[i+j]]); 150 } 151 } 152 } catch (AssertionError e) { 153 int idx = i + j; 154 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]); 155 } 156 } 157 158 interface FBinOp { 159 double apply(double a, double b); 160 } 161 162 interface FBinMaskOp { 163 double apply(double a, double b, boolean m); 164 165 static FBinMaskOp lift(FBinOp f) { 166 return (a, b, m) -> m ? f.apply(a, b) : a; 167 } 168 } 169 170 static void assertArraysEquals(double[] a, double[] b, double[] r, FBinOp f) { 171 int i = 0; 172 try { 173 for (; i < a.length; i++) { 174 Assert.assertEquals(r[i], f.apply(a[i], b[i])); 175 } 176 } catch (AssertionError e) { 177 Assert.assertEquals(f.apply(a[i], b[i]), r[i], "(" + a[i] + ", " + b[i] + ") at index #" + i); 178 } 179 } 180 181 static void assertArraysEquals(double[] a, double[] b, double[] r, boolean[] mask, FBinOp f) { 182 assertArraysEquals(a, b, r, mask, FBinMaskOp.lift(f)); 183 } 184 185 static void assertArraysEquals(double[] a, double[] b, double[] r, boolean[] mask, FBinMaskOp f) { 186 int i = 0; 187 try { 188 for (; i < a.length; i++) { 189 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()])); 190 } 191 } catch (AssertionError err) { 192 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()]); 193 } 194 } 195 196 static void assertShiftArraysEquals(double[] a, double[] b, double[] r, FBinOp f) { 197 int i = 0; 198 int j = 0; 199 try { 200 for (; j < a.length; j += SPECIES.length()) { 201 for (i = 0; i < SPECIES.length(); i++) { 202 Assert.assertEquals(f.apply(a[i+j], b[j]), r[i+j]); 203 } 204 } 205 } catch (AssertionError e) { 206 Assert.assertEquals(f.apply(a[i+j], b[j]), r[i+j], "at index #" + i + ", " + j); 207 } 208 } 209 210 static void assertShiftArraysEquals(double[] a, double[] b, double[] r, boolean[] mask, FBinOp f) { 211 assertShiftArraysEquals(a, b, r, mask, FBinMaskOp.lift(f)); 212 } 213 214 static void assertShiftArraysEquals(double[] a, double[] b, double[] r, boolean[] mask, FBinMaskOp f) { 215 int i = 0; 216 int j = 0; 217 try { 218 for (; j < a.length; j += SPECIES.length()) { 219 for (i = 0; i < SPECIES.length(); i++) { 220 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i])); 221 } 222 } 223 } catch (AssertionError err) { 224 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]); 225 } 226 } 227 228 interface FTernOp { 229 double apply(double a, double b, double c); 230 } 231 232 interface FTernMaskOp { 233 double apply(double a, double b, double c, boolean m); 234 235 static FTernMaskOp lift(FTernOp f) { 236 return (a, b, c, m) -> m ? f.apply(a, b, c) : a; 237 } 238 } 239 240 static void assertArraysEquals(double[] a, double[] b, double[] c, double[] r, FTernOp f) { 241 int i = 0; 242 try { 243 for (; i < a.length; i++) { 244 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i])); 245 } 246 } catch (AssertionError e) { 247 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]); 248 } 249 } 250 251 static void assertArraysEquals(double[] a, double[] b, double[] c, double[] r, boolean[] mask, FTernOp f) { 252 assertArraysEquals(a, b, c, r, mask, FTernMaskOp.lift(f)); 253 } 254 255 static void assertArraysEquals(double[] a, double[] b, double[] c, double[] r, boolean[] mask, FTernMaskOp f) { 256 int i = 0; 257 try { 258 for (; i < a.length; i++) { 259 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()])); 260 } 261 } catch (AssertionError err) { 262 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " 263 + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]); 264 } 265 } 266 267 static boolean isWithin1Ulp(double actual, double expected) { 268 if (Double.isNaN(expected) && !Double.isNaN(actual)) { 269 return false; 270 } else if (!Double.isNaN(expected) && Double.isNaN(actual)) { 271 return false; 272 } 273 274 double low = Math.nextDown(expected); 275 double high = Math.nextUp(expected); 276 277 if (Double.compare(low, expected) > 0) { 278 return false; 279 } 280 281 if (Double.compare(high, expected) < 0) { 282 return false; 283 } 284 285 return true; 286 } 287 288 static void assertArraysEqualsWithinOneUlp(double[] a, double[] r, FUnOp mathf, FUnOp strictmathf) { 289 int i = 0; 290 try { 291 // Check that result is within 1 ulp of strict math or equivalent to math implementation. 292 for (; i < a.length; i++) { 293 Assert.assertTrue(Double.compare(r[i], mathf.apply(a[i])) == 0 || 294 isWithin1Ulp(r[i], strictmathf.apply(a[i]))); 295 } 296 } catch (AssertionError e) { 297 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])); 298 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])); 299 } 300 } 301 302 static void assertArraysEqualsWithinOneUlp(double[] a, double[] b, double[] r, FBinOp mathf, FBinOp strictmathf) { 303 int i = 0; 304 try { 305 // Check that result is within 1 ulp of strict math or equivalent to math implementation. 306 for (; i < a.length; i++) { 307 Assert.assertTrue(Double.compare(r[i], mathf.apply(a[i], b[i])) == 0 || 308 isWithin1Ulp(r[i], strictmathf.apply(a[i], b[i]))); 309 } 310 } catch (AssertionError e) { 311 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])); 312 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])); 313 } 314 } 315 316 interface FBinArrayOp { 317 double apply(double[] a, int b); 318 } 319 320 static void assertArraysEquals(double[] a, double[] r, FBinArrayOp f) { 321 int i = 0; 322 try { 323 for (; i < a.length; i++) { 324 Assert.assertEquals(f.apply(a, i), r[i]); 325 } 326 } catch (AssertionError e) { 327 Assert.assertEquals(f.apply(a,i), r[i], "at index #" + i); 328 } 329 } 330 interface FGatherScatterOp { 331 double[] apply(double[] a, int ix, int[] b, int iy); 332 } 333 334 static void assertArraysEquals(double[] a, int[] b, double[] r, FGatherScatterOp f) { 335 int i = 0; 336 try { 337 for (; i < a.length; i += SPECIES.length()) { 338 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()), 339 f.apply(a, i, b, i)); 340 } 341 } catch (AssertionError e) { 342 double[] ref = f.apply(a, i, b, i); 343 double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length()); 344 Assert.assertEquals(ref, res, 345 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: " 346 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length())) 347 + ", b: " 348 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length())) 349 + " at index #" + i); 350 } 351 } 352 353 354 static final List<IntFunction<double[]>> DOUBLE_GENERATORS = List.of( 355 withToString("double[-i * 5]", (int s) -> { 356 return fill(s * 1000, 357 i -> (double)(-i * 5)); 358 }), 359 withToString("double[i * 5]", (int s) -> { 360 return fill(s * 1000, 361 i -> (double)(i * 5)); 362 }), 363 withToString("double[i + 1]", (int s) -> { 364 return fill(s * 1000, 365 i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1))); 366 }), 367 withToString("double[cornerCaseValue(i)]", (int s) -> { 368 return fill(s * 1000, 369 i -> cornerCaseValue(i)); 370 }) 371 ); 372 373 // Create combinations of pairs 374 // @@@ Might be sensitive to order e.g. div by 0 375 static final List<List<IntFunction<double[]>>> DOUBLE_GENERATOR_PAIRS = 376 Stream.of(DOUBLE_GENERATORS.get(0)). 377 flatMap(fa -> DOUBLE_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))). 378 collect(Collectors.toList()); 379 380 @DataProvider 381 public Object[][] boolUnaryOpProvider() { 382 return BOOL_ARRAY_GENERATORS.stream(). 383 map(f -> new Object[]{f}). 384 toArray(Object[][]::new); 385 } 386 387 static final List<List<IntFunction<double[]>>> DOUBLE_GENERATOR_TRIPLES = 388 DOUBLE_GENERATOR_PAIRS.stream(). 389 flatMap(pair -> DOUBLE_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))). 390 collect(Collectors.toList()); 391 392 @DataProvider 393 public Object[][] doubleBinaryOpProvider() { 394 return DOUBLE_GENERATOR_PAIRS.stream().map(List::toArray). 395 toArray(Object[][]::new); 396 } 397 398 @DataProvider 399 public Object[][] doubleIndexedOpProvider() { 400 return DOUBLE_GENERATOR_PAIRS.stream().map(List::toArray). 401 toArray(Object[][]::new); 402 } 403 404 @DataProvider 405 public Object[][] doubleBinaryOpMaskProvider() { 406 return BOOLEAN_MASK_GENERATORS.stream(). 407 flatMap(fm -> DOUBLE_GENERATOR_PAIRS.stream().map(lfa -> { 408 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray(); 409 })). 410 toArray(Object[][]::new); 411 } 412 413 @DataProvider 414 public Object[][] doubleTernaryOpProvider() { 415 return DOUBLE_GENERATOR_TRIPLES.stream().map(List::toArray). 416 toArray(Object[][]::new); 417 } 418 419 @DataProvider 420 public Object[][] doubleTernaryOpMaskProvider() { 421 return BOOLEAN_MASK_GENERATORS.stream(). 422 flatMap(fm -> DOUBLE_GENERATOR_TRIPLES.stream().map(lfa -> { 423 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray(); 424 })). 425 toArray(Object[][]::new); 426 } 427 428 @DataProvider 429 public Object[][] doubleUnaryOpProvider() { 430 return DOUBLE_GENERATORS.stream(). 431 map(f -> new Object[]{f}). 432 toArray(Object[][]::new); 433 } 434 435 @DataProvider 436 public Object[][] doubleUnaryOpMaskProvider() { 437 return BOOLEAN_MASK_GENERATORS.stream(). 438 flatMap(fm -> DOUBLE_GENERATORS.stream().map(fa -> { 439 return new Object[] {fa, fm}; 440 })). 441 toArray(Object[][]::new); 442 } 443 444 @DataProvider 445 public Object[][] doubleUnaryOpShuffleProvider() { 446 return INT_SHUFFLE_GENERATORS.stream(). 447 flatMap(fs -> DOUBLE_GENERATORS.stream().map(fa -> { 448 return new Object[] {fa, fs}; 449 })). 450 toArray(Object[][]::new); 451 } 452 453 @DataProvider 454 public Object[][] doubleUnaryOpIndexProvider() { 455 return INT_INDEX_GENERATORS.stream(). 456 flatMap(fs -> DOUBLE_GENERATORS.stream().map(fa -> { 457 return new Object[] {fa, fs}; 458 })). 459 toArray(Object[][]::new); 460 } 461 462 463 static final List<IntFunction<double[]>> DOUBLE_COMPARE_GENERATORS = List.of( 464 withToString("double[i]", (int s) -> { 465 return fill(s * 1000, 466 i -> (double)i); 467 }), 468 withToString("double[i + 1]", (int s) -> { 469 return fill(s * 1000, 470 i -> (double)(i + 1)); 471 }), 472 withToString("double[i - 2]", (int s) -> { 473 return fill(s * 1000, 474 i -> (double)(i - 2)); 475 }), 476 withToString("double[zigZag(i)]", (int s) -> { 477 return fill(s * 1000, 478 i -> i%3 == 0 ? (double)i : (i%3 == 1 ? (double)(i + 1) : (double)(i - 2))); 479 }), 480 withToString("double[cornerCaseValue(i)]", (int s) -> { 481 return fill(s * 1000, 482 i -> cornerCaseValue(i)); 483 }) 484 ); 485 486 static final List<List<IntFunction<double[]>>> DOUBLE_COMPARE_GENERATOR_PAIRS = 487 DOUBLE_COMPARE_GENERATORS.stream(). 488 flatMap(fa -> DOUBLE_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))). 489 collect(Collectors.toList()); 490 491 @DataProvider 492 public Object[][] doubleCompareOpProvider() { 493 return DOUBLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray). 494 toArray(Object[][]::new); 495 } 496 497 interface ToDoubleF { 498 double apply(int i); 499 } 500 501 static double[] fill(int s , ToDoubleF f) { 502 return fill(new double[s], f); 503 } 504 505 static double[] fill(double[] a, ToDoubleF f) { 506 for (int i = 0; i < a.length; i++) { 507 a[i] = f.apply(i); 508 } 509 return a; 510 } 511 512 static double cornerCaseValue(int i) { 513 switch(i % 7) { 514 case 0: 515 return Double.MAX_VALUE; 516 case 1: 517 return Double.MIN_VALUE; 518 case 2: 519 return Double.NEGATIVE_INFINITY; 520 case 3: 521 return Double.POSITIVE_INFINITY; 522 case 4: 523 return Double.NaN; 524 case 5: 525 return (double)0.0; 526 default: 527 return (double)-0.0; 528 } 529 } 530 static double get(double[] a, int i) { 531 return (double) a[i]; 532 } 533 534 static final IntFunction<double[]> fr = (vl) -> { 535 int length = 1000 * vl; 536 return new double[length]; 537 }; 538 539 static final IntFunction<boolean[]> fmr = (vl) -> { 540 int length = 1000 * vl; 541 return new boolean[length]; 542 }; 543 static double add(double a, double b) { 544 return (double)(a + b); 545 } 546 547 @Test(dataProvider = "doubleBinaryOpProvider") 548 static void addDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 549 double[] a = fa.apply(SPECIES.length()); 550 double[] b = fb.apply(SPECIES.length()); 551 double[] r = fr.apply(SPECIES.length()); 552 553 for (int ic = 0; ic < INVOC_COUNT; ic++) { 554 for (int i = 0; i < a.length; i += SPECIES.length()) { 555 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 556 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 557 av.add(bv).intoArray(r, i); 558 } 559 } 560 561 assertArraysEquals(a, b, r, DoubleMaxVectorTests::add); 562 } 563 564 @Test(dataProvider = "doubleBinaryOpMaskProvider") 565 static void addDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, 566 IntFunction<boolean[]> fm) { 567 double[] a = fa.apply(SPECIES.length()); 568 double[] b = fb.apply(SPECIES.length()); 569 double[] r = fr.apply(SPECIES.length()); 570 boolean[] mask = fm.apply(SPECIES.length()); 571 VectorMask<Double> vmask = VectorMask.fromValues(SPECIES, mask); 572 573 for (int ic = 0; ic < INVOC_COUNT; ic++) { 574 for (int i = 0; i < a.length; i += SPECIES.length()) { 575 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 576 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 577 av.add(bv, vmask).intoArray(r, i); 578 } 579 } 580 581 assertArraysEquals(a, b, r, mask, DoubleMaxVectorTests::add); 582 } 583 static double sub(double a, double b) { 584 return (double)(a - b); 585 } 586 587 @Test(dataProvider = "doubleBinaryOpProvider") 588 static void subDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 589 double[] a = fa.apply(SPECIES.length()); 590 double[] b = fb.apply(SPECIES.length()); 591 double[] r = fr.apply(SPECIES.length()); 592 593 for (int ic = 0; ic < INVOC_COUNT; ic++) { 594 for (int i = 0; i < a.length; i += SPECIES.length()) { 595 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 596 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 597 av.sub(bv).intoArray(r, i); 598 } 599 } 600 601 assertArraysEquals(a, b, r, DoubleMaxVectorTests::sub); 602 } 603 604 @Test(dataProvider = "doubleBinaryOpMaskProvider") 605 static void subDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, 606 IntFunction<boolean[]> fm) { 607 double[] a = fa.apply(SPECIES.length()); 608 double[] b = fb.apply(SPECIES.length()); 609 double[] r = fr.apply(SPECIES.length()); 610 boolean[] mask = fm.apply(SPECIES.length()); 611 VectorMask<Double> vmask = VectorMask.fromValues(SPECIES, mask); 612 613 for (int ic = 0; ic < INVOC_COUNT; ic++) { 614 for (int i = 0; i < a.length; i += SPECIES.length()) { 615 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 616 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 617 av.sub(bv, vmask).intoArray(r, i); 618 } 619 } 620 621 assertArraysEquals(a, b, r, mask, DoubleMaxVectorTests::sub); 622 } 623 624 static double div(double a, double b) { 625 return (double)(a / b); 626 } 627 628 @Test(dataProvider = "doubleBinaryOpProvider") 629 static void divDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 630 double[] a = fa.apply(SPECIES.length()); 631 double[] b = fb.apply(SPECIES.length()); 632 double[] r = fr.apply(SPECIES.length()); 633 634 for (int ic = 0; ic < INVOC_COUNT; ic++) { 635 for (int i = 0; i < a.length; i += SPECIES.length()) { 636 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 637 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 638 av.div(bv).intoArray(r, i); 639 } 640 } 641 642 assertArraysEquals(a, b, r, DoubleMaxVectorTests::div); 643 } 644 645 646 647 @Test(dataProvider = "doubleBinaryOpMaskProvider") 648 static void divDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, 649 IntFunction<boolean[]> fm) { 650 double[] a = fa.apply(SPECIES.length()); 651 double[] b = fb.apply(SPECIES.length()); 652 double[] r = fr.apply(SPECIES.length()); 653 boolean[] mask = fm.apply(SPECIES.length()); 654 VectorMask<Double> vmask = VectorMask.fromValues(SPECIES, mask); 655 656 for (int ic = 0; ic < INVOC_COUNT; ic++) { 657 for (int i = 0; i < a.length; i += SPECIES.length()) { 658 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 659 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 660 av.div(bv, vmask).intoArray(r, i); 661 } 662 } 663 664 assertArraysEquals(a, b, r, mask, DoubleMaxVectorTests::div); 665 } 666 667 static double mul(double a, double b) { 668 return (double)(a * b); 669 } 670 671 @Test(dataProvider = "doubleBinaryOpProvider") 672 static void mulDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 673 double[] a = fa.apply(SPECIES.length()); 674 double[] b = fb.apply(SPECIES.length()); 675 double[] r = fr.apply(SPECIES.length()); 676 677 for (int ic = 0; ic < INVOC_COUNT; ic++) { 678 for (int i = 0; i < a.length; i += SPECIES.length()) { 679 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 680 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 681 av.mul(bv).intoArray(r, i); 682 } 683 } 684 685 assertArraysEquals(a, b, r, DoubleMaxVectorTests::mul); 686 } 687 688 @Test(dataProvider = "doubleBinaryOpMaskProvider") 689 static void mulDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, 690 IntFunction<boolean[]> fm) { 691 double[] a = fa.apply(SPECIES.length()); 692 double[] b = fb.apply(SPECIES.length()); 693 double[] r = fr.apply(SPECIES.length()); 694 boolean[] mask = fm.apply(SPECIES.length()); 695 VectorMask<Double> vmask = VectorMask.fromValues(SPECIES, mask); 696 697 for (int ic = 0; ic < INVOC_COUNT; ic++) { 698 for (int i = 0; i < a.length; i += SPECIES.length()) { 699 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 700 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 701 av.mul(bv, vmask).intoArray(r, i); 702 } 703 } 704 705 assertArraysEquals(a, b, r, mask, DoubleMaxVectorTests::mul); 706 } 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 static double max(double a, double b) { 738 return (double)(Math.max(a, b)); 739 } 740 741 @Test(dataProvider = "doubleBinaryOpProvider") 742 static void maxDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 743 double[] a = fa.apply(SPECIES.length()); 744 double[] b = fb.apply(SPECIES.length()); 745 double[] r = fr.apply(SPECIES.length()); 746 747 for (int ic = 0; ic < INVOC_COUNT; ic++) { 748 for (int i = 0; i < a.length; i += SPECIES.length()) { 749 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 750 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 751 av.max(bv).intoArray(r, i); 752 } 753 } 754 755 assertArraysEquals(a, b, r, DoubleMaxVectorTests::max); 756 } 757 static double min(double a, double b) { 758 return (double)(Math.min(a, b)); 759 } 760 761 @Test(dataProvider = "doubleBinaryOpProvider") 762 static void minDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 763 double[] a = fa.apply(SPECIES.length()); 764 double[] b = fb.apply(SPECIES.length()); 765 double[] r = fr.apply(SPECIES.length()); 766 767 for (int ic = 0; ic < INVOC_COUNT; ic++) { 768 for (int i = 0; i < a.length; i += SPECIES.length()) { 769 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 770 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 771 av.min(bv).intoArray(r, i); 772 } 773 } 774 775 assertArraysEquals(a, b, r, DoubleMaxVectorTests::min); 776 } 777 778 779 780 781 782 783 static double addAll(double[] a, int idx) { 784 double res = 0; 785 for (int i = idx; i < (idx + SPECIES.length()); i++) { 786 res += a[i]; 787 } 788 789 return res; 790 } 791 792 static double addAll(double[] a) { 793 double res = 0; 794 for (int i = 0; i < a.length; i += SPECIES.length()) { 795 double tmp = 0; 796 for (int j = 0; j < SPECIES.length(); j++) { 797 tmp += a[i + j]; 798 } 799 res += tmp; 800 } 801 802 return res; 803 } 804 @Test(dataProvider = "doubleUnaryOpProvider") 805 static void addAllDoubleMaxVectorTests(IntFunction<double[]> fa) { 806 double[] a = fa.apply(SPECIES.length()); 807 double[] r = fr.apply(SPECIES.length()); 808 double ra = 0; 809 810 for (int ic = 0; ic < INVOC_COUNT; ic++) { 811 for (int i = 0; i < a.length; i += SPECIES.length()) { 812 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 813 r[i] = av.addAll(); 814 } 815 } 816 817 for (int ic = 0; ic < INVOC_COUNT; ic++) { 818 ra = 0; 819 for (int i = 0; i < a.length; i += SPECIES.length()) { 820 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 821 ra += av.addAll(); 822 } 823 } 824 825 assertReductionArraysEquals(a, r, ra, DoubleMaxVectorTests::addAll, DoubleMaxVectorTests::addAll); 826 } 827 static double mulAll(double[] a, int idx) { 828 double res = 1; 829 for (int i = idx; i < (idx + SPECIES.length()); i++) { 830 res *= a[i]; 831 } 832 833 return res; 834 } 835 836 static double mulAll(double[] a) { 837 double res = 1; 838 for (int i = 0; i < a.length; i += SPECIES.length()) { 839 double tmp = 1; 840 for (int j = 0; j < SPECIES.length(); j++) { 841 tmp *= a[i + j]; 842 } 843 res *= tmp; 844 } 845 846 return res; 847 } 848 @Test(dataProvider = "doubleUnaryOpProvider") 849 static void mulAllDoubleMaxVectorTests(IntFunction<double[]> fa) { 850 double[] a = fa.apply(SPECIES.length()); 851 double[] r = fr.apply(SPECIES.length()); 852 double ra = 1; 853 854 for (int ic = 0; ic < INVOC_COUNT; ic++) { 855 for (int i = 0; i < a.length; i += SPECIES.length()) { 856 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 857 r[i] = av.mulAll(); 858 } 859 } 860 861 for (int ic = 0; ic < INVOC_COUNT; ic++) { 862 ra = 1; 863 for (int i = 0; i < a.length; i += SPECIES.length()) { 864 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 865 ra *= av.mulAll(); 866 } 867 } 868 869 assertReductionArraysEquals(a, r, ra, DoubleMaxVectorTests::mulAll, DoubleMaxVectorTests::mulAll); 870 } 871 static double minAll(double[] a, int idx) { 872 double res = Double.POSITIVE_INFINITY; 873 for (int i = idx; i < (idx + SPECIES.length()); i++) { 874 res = (double)Math.min(res, a[i]); 875 } 876 877 return res; 878 } 879 880 static double minAll(double[] a) { 881 double res = Double.POSITIVE_INFINITY; 882 for (int i = 0; i < a.length; i++) { 883 res = (double)Math.min(res, a[i]); 884 } 885 886 return res; 887 } 888 @Test(dataProvider = "doubleUnaryOpProvider") 889 static void minAllDoubleMaxVectorTests(IntFunction<double[]> fa) { 890 double[] a = fa.apply(SPECIES.length()); 891 double[] r = fr.apply(SPECIES.length()); 892 double ra = Double.POSITIVE_INFINITY; 893 894 for (int ic = 0; ic < INVOC_COUNT; ic++) { 895 for (int i = 0; i < a.length; i += SPECIES.length()) { 896 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 897 r[i] = av.minAll(); 898 } 899 } 900 901 for (int ic = 0; ic < INVOC_COUNT; ic++) { 902 ra = Double.POSITIVE_INFINITY; 903 for (int i = 0; i < a.length; i += SPECIES.length()) { 904 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 905 ra = (double)Math.min(ra, av.minAll()); 906 } 907 } 908 909 assertReductionArraysEquals(a, r, ra, DoubleMaxVectorTests::minAll, DoubleMaxVectorTests::minAll); 910 } 911 static double maxAll(double[] a, int idx) { 912 double res = Double.NEGATIVE_INFINITY; 913 for (int i = idx; i < (idx + SPECIES.length()); i++) { 914 res = (double)Math.max(res, a[i]); 915 } 916 917 return res; 918 } 919 920 static double maxAll(double[] a) { 921 double res = Double.NEGATIVE_INFINITY; 922 for (int i = 0; i < a.length; i++) { 923 res = (double)Math.max(res, a[i]); 924 } 925 926 return res; 927 } 928 @Test(dataProvider = "doubleUnaryOpProvider") 929 static void maxAllDoubleMaxVectorTests(IntFunction<double[]> fa) { 930 double[] a = fa.apply(SPECIES.length()); 931 double[] r = fr.apply(SPECIES.length()); 932 double ra = Double.NEGATIVE_INFINITY; 933 934 for (int ic = 0; ic < INVOC_COUNT; ic++) { 935 for (int i = 0; i < a.length; i += SPECIES.length()) { 936 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 937 r[i] = av.maxAll(); 938 } 939 } 940 941 for (int ic = 0; ic < INVOC_COUNT; ic++) { 942 ra = Double.NEGATIVE_INFINITY; 943 for (int i = 0; i < a.length; i += SPECIES.length()) { 944 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 945 ra = (double)Math.max(ra, av.maxAll()); 946 } 947 } 948 949 assertReductionArraysEquals(a, r, ra, DoubleMaxVectorTests::maxAll, DoubleMaxVectorTests::maxAll); 950 } 951 952 953 954 955 956 @Test(dataProvider = "doubleUnaryOpProvider") 957 static void withDoubleMaxVectorTests(IntFunction<double []> fa) { 958 double[] a = fa.apply(SPECIES.length()); 959 double[] r = fr.apply(SPECIES.length()); 960 961 for (int ic = 0; ic < INVOC_COUNT; ic++) { 962 for (int i = 0; i < a.length; i += SPECIES.length()) { 963 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 964 av.with(0, (double)4).intoArray(r, i); 965 } 966 } 967 968 assertInsertArraysEquals(a, r, (double)4, 0); 969 } 970 971 @Test(dataProvider = "doubleCompareOpProvider") 972 static void lessThanDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 973 double[] a = fa.apply(SPECIES.length()); 974 double[] b = fb.apply(SPECIES.length()); 975 976 for (int ic = 0; ic < INVOC_COUNT; ic++) { 977 for (int i = 0; i < a.length; i += SPECIES.length()) { 978 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 979 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 980 VectorMask<Double> mv = av.lessThan(bv); 981 982 // Check results as part of computation. 983 for (int j = 0; j < SPECIES.length(); j++) { 984 Assert.assertEquals(mv.getElement(j), a[i + j] < b[i + j]); 985 } 986 } 987 } 988 } 989 990 991 @Test(dataProvider = "doubleCompareOpProvider") 992 static void greaterThanDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 993 double[] a = fa.apply(SPECIES.length()); 994 double[] b = fb.apply(SPECIES.length()); 995 996 for (int ic = 0; ic < INVOC_COUNT; ic++) { 997 for (int i = 0; i < a.length; i += SPECIES.length()) { 998 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 999 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1000 VectorMask<Double> mv = av.greaterThan(bv); 1001 1002 // Check results as part of computation. 1003 for (int j = 0; j < SPECIES.length(); j++) { 1004 Assert.assertEquals(mv.getElement(j), a[i + j] > b[i + j]); 1005 } 1006 } 1007 } 1008 } 1009 1010 1011 @Test(dataProvider = "doubleCompareOpProvider") 1012 static void equalDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 1013 double[] a = fa.apply(SPECIES.length()); 1014 double[] b = fb.apply(SPECIES.length()); 1015 1016 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1017 for (int i = 0; i < a.length; i += SPECIES.length()) { 1018 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1019 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1020 VectorMask<Double> mv = av.equal(bv); 1021 1022 // Check results as part of computation. 1023 for (int j = 0; j < SPECIES.length(); j++) { 1024 Assert.assertEquals(mv.getElement(j), a[i + j] == b[i + j]); 1025 } 1026 } 1027 } 1028 } 1029 1030 1031 @Test(dataProvider = "doubleCompareOpProvider") 1032 static void notEqualDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 1033 double[] a = fa.apply(SPECIES.length()); 1034 double[] b = fb.apply(SPECIES.length()); 1035 1036 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1037 for (int i = 0; i < a.length; i += SPECIES.length()) { 1038 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1039 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1040 VectorMask<Double> mv = av.notEqual(bv); 1041 1042 // Check results as part of computation. 1043 for (int j = 0; j < SPECIES.length(); j++) { 1044 Assert.assertEquals(mv.getElement(j), a[i + j] != b[i + j]); 1045 } 1046 } 1047 } 1048 } 1049 1050 1051 @Test(dataProvider = "doubleCompareOpProvider") 1052 static void lessThanEqDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 1053 double[] a = fa.apply(SPECIES.length()); 1054 double[] b = fb.apply(SPECIES.length()); 1055 1056 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1057 for (int i = 0; i < a.length; i += SPECIES.length()) { 1058 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1059 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1060 VectorMask<Double> mv = av.lessThanEq(bv); 1061 1062 // Check results as part of computation. 1063 for (int j = 0; j < SPECIES.length(); j++) { 1064 Assert.assertEquals(mv.getElement(j), a[i + j] <= b[i + j]); 1065 } 1066 } 1067 } 1068 } 1069 1070 1071 @Test(dataProvider = "doubleCompareOpProvider") 1072 static void greaterThanEqDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 1073 double[] a = fa.apply(SPECIES.length()); 1074 double[] b = fb.apply(SPECIES.length()); 1075 1076 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1077 for (int i = 0; i < a.length; i += SPECIES.length()) { 1078 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1079 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1080 VectorMask<Double> mv = av.greaterThanEq(bv); 1081 1082 // Check results as part of computation. 1083 for (int j = 0; j < SPECIES.length(); j++) { 1084 Assert.assertEquals(mv.getElement(j), a[i + j] >= b[i + j]); 1085 } 1086 } 1087 } 1088 } 1089 1090 1091 static double blend(double a, double b, boolean mask) { 1092 return mask ? b : a; 1093 } 1094 1095 @Test(dataProvider = "doubleBinaryOpMaskProvider") 1096 static void blendDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, 1097 IntFunction<boolean[]> fm) { 1098 double[] a = fa.apply(SPECIES.length()); 1099 double[] b = fb.apply(SPECIES.length()); 1100 double[] r = fr.apply(SPECIES.length()); 1101 boolean[] mask = fm.apply(SPECIES.length()); 1102 VectorMask<Double> vmask = VectorMask.fromValues(SPECIES, mask); 1103 1104 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1105 for (int i = 0; i < a.length; i += SPECIES.length()) { 1106 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1107 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1108 av.blend(bv, vmask).intoArray(r, i); 1109 } 1110 } 1111 1112 assertArraysEquals(a, b, r, mask, DoubleMaxVectorTests::blend); 1113 } 1114 1115 @Test(dataProvider = "doubleUnaryOpShuffleProvider") 1116 static void RearrangeDoubleMaxVectorTests(IntFunction<double[]> fa, 1117 BiFunction<Integer,Integer,int[]> fs) { 1118 double[] a = fa.apply(SPECIES.length()); 1119 int[] order = fs.apply(a.length, SPECIES.length()); 1120 double[] r = fr.apply(SPECIES.length()); 1121 1122 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1123 for (int i = 0; i < a.length; i += SPECIES.length()) { 1124 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1125 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i); 1126 } 1127 } 1128 1129 assertRearrangeArraysEquals(a, r, order, SPECIES.length()); 1130 } 1131 1132 1133 1134 1135 @Test(dataProvider = "doubleUnaryOpProvider") 1136 static void getDoubleMaxVectorTests(IntFunction<double[]> fa) { 1137 double[] a = fa.apply(SPECIES.length()); 1138 double[] r = fr.apply(SPECIES.length()); 1139 1140 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1141 for (int i = 0; i < a.length; i += SPECIES.length()) { 1142 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1143 int num_lanes = SPECIES.length(); 1144 // Manually unroll because full unroll happens after intrinsification. 1145 // Unroll is needed because get intrinsic requires for index to be a known constant. 1146 if (num_lanes == 1) { 1147 r[i]=av.get(0); 1148 } else if (num_lanes == 2) { 1149 r[i]=av.get(0); 1150 r[i+1]=av.get(1); 1151 } else if (num_lanes == 4) { 1152 r[i]=av.get(0); 1153 r[i+1]=av.get(1); 1154 r[i+2]=av.get(2); 1155 r[i+3]=av.get(3); 1156 } else if (num_lanes == 8) { 1157 r[i]=av.get(0); 1158 r[i+1]=av.get(1); 1159 r[i+2]=av.get(2); 1160 r[i+3]=av.get(3); 1161 r[i+4]=av.get(4); 1162 r[i+5]=av.get(5); 1163 r[i+6]=av.get(6); 1164 r[i+7]=av.get(7); 1165 } else if (num_lanes == 16) { 1166 r[i]=av.get(0); 1167 r[i+1]=av.get(1); 1168 r[i+2]=av.get(2); 1169 r[i+3]=av.get(3); 1170 r[i+4]=av.get(4); 1171 r[i+5]=av.get(5); 1172 r[i+6]=av.get(6); 1173 r[i+7]=av.get(7); 1174 r[i+8]=av.get(8); 1175 r[i+9]=av.get(9); 1176 r[i+10]=av.get(10); 1177 r[i+11]=av.get(11); 1178 r[i+12]=av.get(12); 1179 r[i+13]=av.get(13); 1180 r[i+14]=av.get(14); 1181 r[i+15]=av.get(15); 1182 } else if (num_lanes == 32) { 1183 r[i]=av.get(0); 1184 r[i+1]=av.get(1); 1185 r[i+2]=av.get(2); 1186 r[i+3]=av.get(3); 1187 r[i+4]=av.get(4); 1188 r[i+5]=av.get(5); 1189 r[i+6]=av.get(6); 1190 r[i+7]=av.get(7); 1191 r[i+8]=av.get(8); 1192 r[i+9]=av.get(9); 1193 r[i+10]=av.get(10); 1194 r[i+11]=av.get(11); 1195 r[i+12]=av.get(12); 1196 r[i+13]=av.get(13); 1197 r[i+14]=av.get(14); 1198 r[i+15]=av.get(15); 1199 r[i+16]=av.get(16); 1200 r[i+17]=av.get(17); 1201 r[i+18]=av.get(18); 1202 r[i+19]=av.get(19); 1203 r[i+20]=av.get(20); 1204 r[i+21]=av.get(21); 1205 r[i+22]=av.get(22); 1206 r[i+23]=av.get(23); 1207 r[i+24]=av.get(24); 1208 r[i+25]=av.get(25); 1209 r[i+26]=av.get(26); 1210 r[i+27]=av.get(27); 1211 r[i+28]=av.get(28); 1212 r[i+29]=av.get(29); 1213 r[i+30]=av.get(30); 1214 r[i+31]=av.get(31); 1215 } else if (num_lanes == 64) { 1216 r[i]=av.get(0); 1217 r[i+1]=av.get(1); 1218 r[i+2]=av.get(2); 1219 r[i+3]=av.get(3); 1220 r[i+4]=av.get(4); 1221 r[i+5]=av.get(5); 1222 r[i+6]=av.get(6); 1223 r[i+7]=av.get(7); 1224 r[i+8]=av.get(8); 1225 r[i+9]=av.get(9); 1226 r[i+10]=av.get(10); 1227 r[i+11]=av.get(11); 1228 r[i+12]=av.get(12); 1229 r[i+13]=av.get(13); 1230 r[i+14]=av.get(14); 1231 r[i+15]=av.get(15); 1232 r[i+16]=av.get(16); 1233 r[i+17]=av.get(17); 1234 r[i+18]=av.get(18); 1235 r[i+19]=av.get(19); 1236 r[i+20]=av.get(20); 1237 r[i+21]=av.get(21); 1238 r[i+22]=av.get(22); 1239 r[i+23]=av.get(23); 1240 r[i+24]=av.get(24); 1241 r[i+25]=av.get(25); 1242 r[i+26]=av.get(26); 1243 r[i+27]=av.get(27); 1244 r[i+28]=av.get(28); 1245 r[i+29]=av.get(29); 1246 r[i+30]=av.get(30); 1247 r[i+31]=av.get(31); 1248 r[i+32]=av.get(32); 1249 r[i+33]=av.get(33); 1250 r[i+34]=av.get(34); 1251 r[i+35]=av.get(35); 1252 r[i+36]=av.get(36); 1253 r[i+37]=av.get(37); 1254 r[i+38]=av.get(38); 1255 r[i+39]=av.get(39); 1256 r[i+40]=av.get(40); 1257 r[i+41]=av.get(41); 1258 r[i+42]=av.get(42); 1259 r[i+43]=av.get(43); 1260 r[i+44]=av.get(44); 1261 r[i+45]=av.get(45); 1262 r[i+46]=av.get(46); 1263 r[i+47]=av.get(47); 1264 r[i+48]=av.get(48); 1265 r[i+49]=av.get(49); 1266 r[i+50]=av.get(50); 1267 r[i+51]=av.get(51); 1268 r[i+52]=av.get(52); 1269 r[i+53]=av.get(53); 1270 r[i+54]=av.get(54); 1271 r[i+55]=av.get(55); 1272 r[i+56]=av.get(56); 1273 r[i+57]=av.get(57); 1274 r[i+58]=av.get(58); 1275 r[i+59]=av.get(59); 1276 r[i+60]=av.get(60); 1277 r[i+61]=av.get(61); 1278 r[i+62]=av.get(62); 1279 r[i+63]=av.get(63); 1280 } else { 1281 for (int j = 0; j < SPECIES.length(); j++) { 1282 r[i+j]=av.get(j); 1283 } 1284 } 1285 } 1286 } 1287 1288 assertArraysEquals(a, r, DoubleMaxVectorTests::get); 1289 } 1290 1291 static double sin(double a) { 1292 return (double)(Math.sin((double)a)); 1293 } 1294 1295 static double strictsin(double a) { 1296 return (double)(StrictMath.sin((double)a)); 1297 } 1298 1299 @Test(dataProvider = "doubleUnaryOpProvider") 1300 static void sinDoubleMaxVectorTests(IntFunction<double[]> fa) { 1301 double[] a = fa.apply(SPECIES.length()); 1302 double[] r = fr.apply(SPECIES.length()); 1303 1304 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1305 for (int i = 0; i < a.length; i += SPECIES.length()) { 1306 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1307 av.sin().intoArray(r, i); 1308 } 1309 } 1310 1311 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::sin, DoubleMaxVectorTests::strictsin); 1312 } 1313 1314 1315 static double exp(double a) { 1316 return (double)(Math.exp((double)a)); 1317 } 1318 1319 static double strictexp(double a) { 1320 return (double)(StrictMath.exp((double)a)); 1321 } 1322 1323 @Test(dataProvider = "doubleUnaryOpProvider") 1324 static void expDoubleMaxVectorTests(IntFunction<double[]> fa) { 1325 double[] a = fa.apply(SPECIES.length()); 1326 double[] r = fr.apply(SPECIES.length()); 1327 1328 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1329 for (int i = 0; i < a.length; i += SPECIES.length()) { 1330 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1331 av.exp().intoArray(r, i); 1332 } 1333 } 1334 1335 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::exp, DoubleMaxVectorTests::strictexp); 1336 } 1337 1338 1339 static double log1p(double a) { 1340 return (double)(Math.log1p((double)a)); 1341 } 1342 1343 static double strictlog1p(double a) { 1344 return (double)(StrictMath.log1p((double)a)); 1345 } 1346 1347 @Test(dataProvider = "doubleUnaryOpProvider") 1348 static void log1pDoubleMaxVectorTests(IntFunction<double[]> fa) { 1349 double[] a = fa.apply(SPECIES.length()); 1350 double[] r = fr.apply(SPECIES.length()); 1351 1352 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1353 for (int i = 0; i < a.length; i += SPECIES.length()) { 1354 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1355 av.log1p().intoArray(r, i); 1356 } 1357 } 1358 1359 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::log1p, DoubleMaxVectorTests::strictlog1p); 1360 } 1361 1362 1363 static double log(double a) { 1364 return (double)(Math.log((double)a)); 1365 } 1366 1367 static double strictlog(double a) { 1368 return (double)(StrictMath.log((double)a)); 1369 } 1370 1371 @Test(dataProvider = "doubleUnaryOpProvider") 1372 static void logDoubleMaxVectorTests(IntFunction<double[]> fa) { 1373 double[] a = fa.apply(SPECIES.length()); 1374 double[] r = fr.apply(SPECIES.length()); 1375 1376 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1377 for (int i = 0; i < a.length; i += SPECIES.length()) { 1378 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1379 av.log().intoArray(r, i); 1380 } 1381 } 1382 1383 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::log, DoubleMaxVectorTests::strictlog); 1384 } 1385 1386 1387 static double log10(double a) { 1388 return (double)(Math.log10((double)a)); 1389 } 1390 1391 static double strictlog10(double a) { 1392 return (double)(StrictMath.log10((double)a)); 1393 } 1394 1395 @Test(dataProvider = "doubleUnaryOpProvider") 1396 static void log10DoubleMaxVectorTests(IntFunction<double[]> fa) { 1397 double[] a = fa.apply(SPECIES.length()); 1398 double[] r = fr.apply(SPECIES.length()); 1399 1400 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1401 for (int i = 0; i < a.length; i += SPECIES.length()) { 1402 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1403 av.log10().intoArray(r, i); 1404 } 1405 } 1406 1407 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::log10, DoubleMaxVectorTests::strictlog10); 1408 } 1409 1410 1411 static double expm1(double a) { 1412 return (double)(Math.expm1((double)a)); 1413 } 1414 1415 static double strictexpm1(double a) { 1416 return (double)(StrictMath.expm1((double)a)); 1417 } 1418 1419 @Test(dataProvider = "doubleUnaryOpProvider") 1420 static void expm1DoubleMaxVectorTests(IntFunction<double[]> fa) { 1421 double[] a = fa.apply(SPECIES.length()); 1422 double[] r = fr.apply(SPECIES.length()); 1423 1424 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1425 for (int i = 0; i < a.length; i += SPECIES.length()) { 1426 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1427 av.expm1().intoArray(r, i); 1428 } 1429 } 1430 1431 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::expm1, DoubleMaxVectorTests::strictexpm1); 1432 } 1433 1434 1435 static double cos(double a) { 1436 return (double)(Math.cos((double)a)); 1437 } 1438 1439 static double strictcos(double a) { 1440 return (double)(StrictMath.cos((double)a)); 1441 } 1442 1443 @Test(dataProvider = "doubleUnaryOpProvider") 1444 static void cosDoubleMaxVectorTests(IntFunction<double[]> fa) { 1445 double[] a = fa.apply(SPECIES.length()); 1446 double[] r = fr.apply(SPECIES.length()); 1447 1448 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1449 for (int i = 0; i < a.length; i += SPECIES.length()) { 1450 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1451 av.cos().intoArray(r, i); 1452 } 1453 } 1454 1455 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::cos, DoubleMaxVectorTests::strictcos); 1456 } 1457 1458 1459 static double tan(double a) { 1460 return (double)(Math.tan((double)a)); 1461 } 1462 1463 static double stricttan(double a) { 1464 return (double)(StrictMath.tan((double)a)); 1465 } 1466 1467 @Test(dataProvider = "doubleUnaryOpProvider") 1468 static void tanDoubleMaxVectorTests(IntFunction<double[]> fa) { 1469 double[] a = fa.apply(SPECIES.length()); 1470 double[] r = fr.apply(SPECIES.length()); 1471 1472 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1473 for (int i = 0; i < a.length; i += SPECIES.length()) { 1474 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1475 av.tan().intoArray(r, i); 1476 } 1477 } 1478 1479 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::tan, DoubleMaxVectorTests::stricttan); 1480 } 1481 1482 1483 static double sinh(double a) { 1484 return (double)(Math.sinh((double)a)); 1485 } 1486 1487 static double strictsinh(double a) { 1488 return (double)(StrictMath.sinh((double)a)); 1489 } 1490 1491 @Test(dataProvider = "doubleUnaryOpProvider") 1492 static void sinhDoubleMaxVectorTests(IntFunction<double[]> fa) { 1493 double[] a = fa.apply(SPECIES.length()); 1494 double[] r = fr.apply(SPECIES.length()); 1495 1496 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1497 for (int i = 0; i < a.length; i += SPECIES.length()) { 1498 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1499 av.sinh().intoArray(r, i); 1500 } 1501 } 1502 1503 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::sinh, DoubleMaxVectorTests::strictsinh); 1504 } 1505 1506 1507 static double cosh(double a) { 1508 return (double)(Math.cosh((double)a)); 1509 } 1510 1511 static double strictcosh(double a) { 1512 return (double)(StrictMath.cosh((double)a)); 1513 } 1514 1515 @Test(dataProvider = "doubleUnaryOpProvider") 1516 static void coshDoubleMaxVectorTests(IntFunction<double[]> fa) { 1517 double[] a = fa.apply(SPECIES.length()); 1518 double[] r = fr.apply(SPECIES.length()); 1519 1520 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1521 for (int i = 0; i < a.length; i += SPECIES.length()) { 1522 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1523 av.cosh().intoArray(r, i); 1524 } 1525 } 1526 1527 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::cosh, DoubleMaxVectorTests::strictcosh); 1528 } 1529 1530 1531 static double tanh(double a) { 1532 return (double)(Math.tanh((double)a)); 1533 } 1534 1535 static double stricttanh(double a) { 1536 return (double)(StrictMath.tanh((double)a)); 1537 } 1538 1539 @Test(dataProvider = "doubleUnaryOpProvider") 1540 static void tanhDoubleMaxVectorTests(IntFunction<double[]> fa) { 1541 double[] a = fa.apply(SPECIES.length()); 1542 double[] r = fr.apply(SPECIES.length()); 1543 1544 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1545 for (int i = 0; i < a.length; i += SPECIES.length()) { 1546 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1547 av.tanh().intoArray(r, i); 1548 } 1549 } 1550 1551 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::tanh, DoubleMaxVectorTests::stricttanh); 1552 } 1553 1554 1555 static double asin(double a) { 1556 return (double)(Math.asin((double)a)); 1557 } 1558 1559 static double strictasin(double a) { 1560 return (double)(StrictMath.asin((double)a)); 1561 } 1562 1563 @Test(dataProvider = "doubleUnaryOpProvider") 1564 static void asinDoubleMaxVectorTests(IntFunction<double[]> fa) { 1565 double[] a = fa.apply(SPECIES.length()); 1566 double[] r = fr.apply(SPECIES.length()); 1567 1568 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1569 for (int i = 0; i < a.length; i += SPECIES.length()) { 1570 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1571 av.asin().intoArray(r, i); 1572 } 1573 } 1574 1575 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::asin, DoubleMaxVectorTests::strictasin); 1576 } 1577 1578 1579 static double acos(double a) { 1580 return (double)(Math.acos((double)a)); 1581 } 1582 1583 static double strictacos(double a) { 1584 return (double)(StrictMath.acos((double)a)); 1585 } 1586 1587 @Test(dataProvider = "doubleUnaryOpProvider") 1588 static void acosDoubleMaxVectorTests(IntFunction<double[]> fa) { 1589 double[] a = fa.apply(SPECIES.length()); 1590 double[] r = fr.apply(SPECIES.length()); 1591 1592 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1593 for (int i = 0; i < a.length; i += SPECIES.length()) { 1594 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1595 av.acos().intoArray(r, i); 1596 } 1597 } 1598 1599 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::acos, DoubleMaxVectorTests::strictacos); 1600 } 1601 1602 1603 static double atan(double a) { 1604 return (double)(Math.atan((double)a)); 1605 } 1606 1607 static double strictatan(double a) { 1608 return (double)(StrictMath.atan((double)a)); 1609 } 1610 1611 @Test(dataProvider = "doubleUnaryOpProvider") 1612 static void atanDoubleMaxVectorTests(IntFunction<double[]> fa) { 1613 double[] a = fa.apply(SPECIES.length()); 1614 double[] r = fr.apply(SPECIES.length()); 1615 1616 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1617 for (int i = 0; i < a.length; i += SPECIES.length()) { 1618 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1619 av.atan().intoArray(r, i); 1620 } 1621 } 1622 1623 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::atan, DoubleMaxVectorTests::strictatan); 1624 } 1625 1626 1627 static double cbrt(double a) { 1628 return (double)(Math.cbrt((double)a)); 1629 } 1630 1631 static double strictcbrt(double a) { 1632 return (double)(StrictMath.cbrt((double)a)); 1633 } 1634 1635 @Test(dataProvider = "doubleUnaryOpProvider") 1636 static void cbrtDoubleMaxVectorTests(IntFunction<double[]> fa) { 1637 double[] a = fa.apply(SPECIES.length()); 1638 double[] r = fr.apply(SPECIES.length()); 1639 1640 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1641 for (int i = 0; i < a.length; i += SPECIES.length()) { 1642 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1643 av.cbrt().intoArray(r, i); 1644 } 1645 } 1646 1647 assertArraysEqualsWithinOneUlp(a, r, DoubleMaxVectorTests::cbrt, DoubleMaxVectorTests::strictcbrt); 1648 } 1649 1650 1651 static double hypot(double a, double b) { 1652 return (double)(Math.hypot((double)a, (double)b)); 1653 } 1654 1655 static double stricthypot(double a, double b) { 1656 return (double)(StrictMath.hypot((double)a, (double)b)); 1657 } 1658 1659 @Test(dataProvider = "doubleBinaryOpProvider") 1660 static void hypotDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 1661 double[] a = fa.apply(SPECIES.length()); 1662 double[] b = fb.apply(SPECIES.length()); 1663 double[] r = fr.apply(SPECIES.length()); 1664 1665 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1666 for (int i = 0; i < a.length; i += SPECIES.length()) { 1667 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1668 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1669 av.hypot(bv).intoArray(r, i); 1670 } 1671 } 1672 1673 assertArraysEqualsWithinOneUlp(a, b, r, DoubleMaxVectorTests::hypot, DoubleMaxVectorTests::stricthypot); 1674 } 1675 1676 1677 1678 static double pow(double a, double b) { 1679 return (double)(Math.pow((double)a, (double)b)); 1680 } 1681 1682 static double strictpow(double a, double b) { 1683 return (double)(StrictMath.pow((double)a, (double)b)); 1684 } 1685 1686 @Test(dataProvider = "doubleBinaryOpProvider") 1687 static void powDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 1688 double[] a = fa.apply(SPECIES.length()); 1689 double[] b = fb.apply(SPECIES.length()); 1690 double[] r = fr.apply(SPECIES.length()); 1691 1692 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1693 for (int i = 0; i < a.length; i += SPECIES.length()) { 1694 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1695 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1696 av.pow(bv).intoArray(r, i); 1697 } 1698 } 1699 1700 assertArraysEqualsWithinOneUlp(a, b, r, DoubleMaxVectorTests::pow, DoubleMaxVectorTests::strictpow); 1701 } 1702 1703 1704 1705 static double atan2(double a, double b) { 1706 return (double)(Math.atan2((double)a, (double)b)); 1707 } 1708 1709 static double strictatan2(double a, double b) { 1710 return (double)(StrictMath.atan2((double)a, (double)b)); 1711 } 1712 1713 @Test(dataProvider = "doubleBinaryOpProvider") 1714 static void atan2DoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) { 1715 double[] a = fa.apply(SPECIES.length()); 1716 double[] b = fb.apply(SPECIES.length()); 1717 double[] r = fr.apply(SPECIES.length()); 1718 1719 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1720 for (int i = 0; i < a.length; i += SPECIES.length()) { 1721 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1722 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1723 av.atan2(bv).intoArray(r, i); 1724 } 1725 } 1726 1727 assertArraysEqualsWithinOneUlp(a, b, r, DoubleMaxVectorTests::atan2, DoubleMaxVectorTests::strictatan2); 1728 } 1729 1730 1731 1732 static double fma(double a, double b, double c) { 1733 return (double)(Math.fma(a, b, c)); 1734 } 1735 1736 1737 @Test(dataProvider = "doubleTernaryOpProvider") 1738 static void fmaDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) { 1739 double[] a = fa.apply(SPECIES.length()); 1740 double[] b = fb.apply(SPECIES.length()); 1741 double[] c = fc.apply(SPECIES.length()); 1742 double[] r = fr.apply(SPECIES.length()); 1743 1744 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1745 for (int i = 0; i < a.length; i += SPECIES.length()) { 1746 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1747 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1748 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i); 1749 av.fma(bv, cv).intoArray(r, i); 1750 } 1751 } 1752 1753 assertArraysEquals(a, b, c, r, DoubleMaxVectorTests::fma); 1754 } 1755 1756 1757 @Test(dataProvider = "doubleTernaryOpMaskProvider") 1758 static void fmaDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, 1759 IntFunction<double[]> fc, IntFunction<boolean[]> fm) { 1760 double[] a = fa.apply(SPECIES.length()); 1761 double[] b = fb.apply(SPECIES.length()); 1762 double[] c = fc.apply(SPECIES.length()); 1763 double[] r = fr.apply(SPECIES.length()); 1764 boolean[] mask = fm.apply(SPECIES.length()); 1765 VectorMask<Double> vmask = VectorMask.fromValues(SPECIES, mask); 1766 1767 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1768 for (int i = 0; i < a.length; i += SPECIES.length()) { 1769 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1770 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i); 1771 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i); 1772 av.fma(bv, cv, vmask).intoArray(r, i); 1773 } 1774 } 1775 1776 assertArraysEquals(a, b, c, r, mask, DoubleMaxVectorTests::fma); 1777 } 1778 1779 1780 static double neg(double a) { 1781 return (double)(-((double)a)); 1782 } 1783 1784 @Test(dataProvider = "doubleUnaryOpProvider") 1785 static void negDoubleMaxVectorTests(IntFunction<double[]> fa) { 1786 double[] a = fa.apply(SPECIES.length()); 1787 double[] r = fr.apply(SPECIES.length()); 1788 1789 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1790 for (int i = 0; i < a.length; i += SPECIES.length()) { 1791 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1792 av.neg().intoArray(r, i); 1793 } 1794 } 1795 1796 assertArraysEquals(a, r, DoubleMaxVectorTests::neg); 1797 } 1798 1799 @Test(dataProvider = "doubleUnaryOpMaskProvider") 1800 static void negMaskedDoubleMaxVectorTests(IntFunction<double[]> fa, 1801 IntFunction<boolean[]> fm) { 1802 double[] a = fa.apply(SPECIES.length()); 1803 double[] r = fr.apply(SPECIES.length()); 1804 boolean[] mask = fm.apply(SPECIES.length()); 1805 VectorMask<Double> vmask = VectorMask.fromValues(SPECIES, mask); 1806 1807 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1808 for (int i = 0; i < a.length; i += SPECIES.length()) { 1809 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1810 av.neg(vmask).intoArray(r, i); 1811 } 1812 } 1813 1814 assertArraysEquals(a, r, mask, DoubleMaxVectorTests::neg); 1815 } 1816 1817 static double abs(double a) { 1818 return (double)(Math.abs((double)a)); 1819 } 1820 1821 @Test(dataProvider = "doubleUnaryOpProvider") 1822 static void absDoubleMaxVectorTests(IntFunction<double[]> fa) { 1823 double[] a = fa.apply(SPECIES.length()); 1824 double[] r = fr.apply(SPECIES.length()); 1825 1826 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1827 for (int i = 0; i < a.length; i += SPECIES.length()) { 1828 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1829 av.abs().intoArray(r, i); 1830 } 1831 } 1832 1833 assertArraysEquals(a, r, DoubleMaxVectorTests::abs); 1834 } 1835 1836 @Test(dataProvider = "doubleUnaryOpMaskProvider") 1837 static void absMaskedDoubleMaxVectorTests(IntFunction<double[]> fa, 1838 IntFunction<boolean[]> fm) { 1839 double[] a = fa.apply(SPECIES.length()); 1840 double[] r = fr.apply(SPECIES.length()); 1841 boolean[] mask = fm.apply(SPECIES.length()); 1842 VectorMask<Double> vmask = VectorMask.fromValues(SPECIES, mask); 1843 1844 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1845 for (int i = 0; i < a.length; i += SPECIES.length()) { 1846 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1847 av.abs(vmask).intoArray(r, i); 1848 } 1849 } 1850 1851 assertArraysEquals(a, r, mask, DoubleMaxVectorTests::abs); 1852 } 1853 1854 1855 1856 1857 1858 static double sqrt(double a) { 1859 return (double)(Math.sqrt((double)a)); 1860 } 1861 1862 1863 1864 @Test(dataProvider = "doubleUnaryOpProvider") 1865 static void sqrtDoubleMaxVectorTests(IntFunction<double[]> fa) { 1866 double[] a = fa.apply(SPECIES.length()); 1867 double[] r = fr.apply(SPECIES.length()); 1868 1869 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1870 for (int i = 0; i < a.length; i += SPECIES.length()) { 1871 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1872 av.sqrt().intoArray(r, i); 1873 } 1874 } 1875 1876 assertArraysEquals(a, r, DoubleMaxVectorTests::sqrt); 1877 } 1878 1879 1880 1881 @Test(dataProvider = "doubleUnaryOpMaskProvider") 1882 static void sqrtMaskedDoubleMaxVectorTests(IntFunction<double[]> fa, 1883 IntFunction<boolean[]> fm) { 1884 double[] a = fa.apply(SPECIES.length()); 1885 double[] r = fr.apply(SPECIES.length()); 1886 boolean[] mask = fm.apply(SPECIES.length()); 1887 VectorMask<Double> vmask = VectorMask.fromValues(SPECIES, mask); 1888 1889 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1890 for (int i = 0; i < a.length; i += SPECIES.length()) { 1891 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1892 av.sqrt(vmask).intoArray(r, i); 1893 } 1894 } 1895 1896 assertArraysEquals(a, r, mask, DoubleMaxVectorTests::sqrt); 1897 } 1898 1899 1900 static double[] gather(double a[], int ix, int[] b, int iy) { 1901 double[] res = new double[SPECIES.length()]; 1902 for (int i = 0; i < SPECIES.length(); i++) { 1903 int bi = iy + i; 1904 res[i] = a[b[bi] + ix]; 1905 } 1906 return res; 1907 } 1908 1909 @Test(dataProvider = "doubleUnaryOpIndexProvider") 1910 static void gatherDoubleMaxVectorTests(IntFunction<double[]> fa, BiFunction<Integer,Integer,int[]> fs) { 1911 double[] a = fa.apply(SPECIES.length()); 1912 int[] b = fs.apply(a.length, SPECIES.length()); 1913 double[] r = new double[a.length]; 1914 1915 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1916 for (int i = 0; i < a.length; i += SPECIES.length()) { 1917 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i, b, i); 1918 av.intoArray(r, i); 1919 } 1920 } 1921 1922 assertArraysEquals(a, b, r, DoubleMaxVectorTests::gather); 1923 } 1924 1925 1926 static double[] scatter(double a[], int ix, int[] b, int iy) { 1927 double[] res = new double[SPECIES.length()]; 1928 for (int i = 0; i < SPECIES.length(); i++) { 1929 int bi = iy + i; 1930 res[b[bi]] = a[i + ix]; 1931 } 1932 return res; 1933 } 1934 1935 @Test(dataProvider = "doubleUnaryOpIndexProvider") 1936 static void scatterDoubleMaxVectorTests(IntFunction<double[]> fa, BiFunction<Integer,Integer,int[]> fs) { 1937 double[] a = fa.apply(SPECIES.length()); 1938 int[] b = fs.apply(a.length, SPECIES.length()); 1939 double[] r = new double[a.length]; 1940 1941 for (int ic = 0; ic < INVOC_COUNT; ic++) { 1942 for (int i = 0; i < a.length; i += SPECIES.length()) { 1943 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i); 1944 av.intoArray(r, i, b, i); 1945 } 1946 } 1947 1948 assertArraysEquals(a, b, r, DoubleMaxVectorTests::scatter); 1949 } 1950 1951 } 1952