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