1 /* 2 * Copyright (c) 2017, 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. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have 23 * questions. 24 */ 25 package jdk.incubator.vector; 26 27 import java.nio.ByteBuffer; 28 import java.nio.FloatBuffer; 29 import java.nio.ByteOrder; 30 import java.util.Objects; 31 import java.util.function.IntUnaryOperator; 32 import java.util.function.Function; 33 import java.util.concurrent.ThreadLocalRandom; 34 35 import jdk.internal.misc.Unsafe; 36 import jdk.internal.vm.annotation.ForceInline; 37 import static jdk.incubator.vector.VectorIntrinsics.*; 38 39 40 /** 41 * A specialized {@link Vector} representing an ordered immutable sequence of 42 * {@code float} values. 43 */ 44 @SuppressWarnings("cast") 45 public abstract class FloatVector extends Vector<Float> { 46 47 FloatVector() {} 48 49 private static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_FLOAT_INDEX_SCALE); 50 51 // Unary operator 52 53 interface FUnOp { 54 float apply(int i, float a); 55 } 56 57 abstract FloatVector uOp(FUnOp f); 58 59 abstract FloatVector uOp(VectorMask<Float> m, FUnOp f); 60 61 // Binary operator 62 63 interface FBinOp { 64 float apply(int i, float a, float b); 65 } 66 67 abstract FloatVector bOp(Vector<Float> v, FBinOp f); 68 69 abstract FloatVector bOp(Vector<Float> v, VectorMask<Float> m, FBinOp f); 70 71 // Trinary operator 72 73 interface FTriOp { 74 float apply(int i, float a, float b, float c); 75 } 76 77 abstract FloatVector tOp(Vector<Float> v1, Vector<Float> v2, FTriOp f); 78 79 abstract FloatVector tOp(Vector<Float> v1, Vector<Float> v2, VectorMask<Float> m, FTriOp f); 80 81 // Reduction operator 82 83 abstract float rOp(float v, FBinOp f); 84 85 // Binary test 86 87 interface FBinTest { 88 boolean apply(int i, float a, float b); 89 } 90 91 abstract VectorMask<Float> bTest(Vector<Float> v, FBinTest f); 92 93 // Foreach 94 95 interface FUnCon { 96 void apply(int i, float a); 97 } 98 99 abstract void forEach(FUnCon f); 100 101 abstract void forEach(VectorMask<Float> m, FUnCon f); 102 103 // Static factories 104 105 /** 106 * Returns a vector where all lane elements are set to the default 107 * primitive value. 108 * 109 * @param species species of desired vector 110 * @return a zero vector of given species 111 */ 112 @ForceInline 113 @SuppressWarnings("unchecked") 114 public static FloatVector zero(VectorSpecies<Float> species) { 115 return VectorIntrinsics.broadcastCoerced((Class<FloatVector>) species.boxType(), float.class, species.length(), 116 Float.floatToIntBits(0.0f), species, 117 ((bits, s) -> ((FloatSpecies)s).op(i -> Float.intBitsToFloat((int)bits)))); 118 } 119 120 /** 121 * Loads a vector from a byte array starting at an offset. 122 * <p> 123 * Bytes are composed into primitive lane elements according to the 124 * native byte order of the underlying platform 125 * <p> 126 * This method behaves as if it returns the result of calling the 127 * byte buffer, offset, and mask accepting 128 * {@link #fromByteBuffer(VectorSpecies<Float>, ByteBuffer, int, VectorMask) method} as follows: 129 * <pre>{@code 130 * return this.fromByteBuffer(ByteBuffer.wrap(a), i, this.maskAllTrue()); 131 * }</pre> 132 * 133 * @param species species of desired vector 134 * @param a the byte array 135 * @param ix the offset into the array 136 * @return a vector loaded from a byte array 137 * @throws IndexOutOfBoundsException if {@code i < 0} or 138 * {@code i > a.length - (this.length() * this.elementSize() / Byte.SIZE)} 139 */ 140 @ForceInline 141 @SuppressWarnings("unchecked") 142 public static FloatVector fromByteArray(VectorSpecies<Float> species, byte[] a, int ix) { 143 Objects.requireNonNull(a); 144 ix = VectorIntrinsics.checkIndex(ix, a.length, species.bitSize() / Byte.SIZE); 145 return VectorIntrinsics.load((Class<FloatVector>) species.boxType(), float.class, species.length(), 146 a, ((long) ix) + Unsafe.ARRAY_BYTE_BASE_OFFSET, 147 a, ix, species, 148 (c, idx, s) -> { 149 ByteBuffer bbc = ByteBuffer.wrap(c, idx, a.length - idx).order(ByteOrder.nativeOrder()); 150 FloatBuffer tb = bbc.asFloatBuffer(); 151 return ((FloatSpecies)s).op(i -> tb.get()); 152 }); 153 } 154 155 /** 156 * Loads a vector from a byte array starting at an offset and using a 157 * mask. 158 * <p> 159 * Bytes are composed into primitive lane elements according to the 160 * native byte order of the underlying platform. 161 * <p> 162 * This method behaves as if it returns the result of calling the 163 * byte buffer, offset, and mask accepting 164 * {@link #fromByteBuffer(VectorSpecies<Float>, ByteBuffer, int, VectorMask) method} as follows: 165 * <pre>{@code 166 * return this.fromByteBuffer(ByteBuffer.wrap(a), i, m); 167 * }</pre> 168 * 169 * @param species species of desired vector 170 * @param a the byte array 171 * @param ix the offset into the array 172 * @param m the mask 173 * @return a vector loaded from a byte array 174 * @throws IndexOutOfBoundsException if {@code i < 0} or 175 * {@code i > a.length - (this.length() * this.elementSize() / Byte.SIZE)} 176 * @throws IndexOutOfBoundsException if the offset is {@code < 0}, 177 * or {@code > a.length}, 178 * for any vector lane index {@code N} where the mask at lane {@code N} 179 * is set 180 * {@code i >= a.length - (N * this.elementSize() / Byte.SIZE)} 181 */ 182 @ForceInline 183 public static FloatVector fromByteArray(VectorSpecies<Float> species, byte[] a, int ix, VectorMask<Float> m) { 184 return zero(species).blend(fromByteArray(species, a, ix), m); 185 } 186 187 /** 188 * Loads a vector from an array starting at offset. 189 * <p> 190 * For each vector lane, where {@code N} is the vector lane index, the 191 * array element at index {@code i + N} is placed into the 192 * resulting vector at lane index {@code N}. 193 * 194 * @param species species of desired vector 195 * @param a the array 196 * @param i the offset into the array 197 * @return the vector loaded from an array 198 * @throws IndexOutOfBoundsException if {@code i < 0}, or 199 * {@code i > a.length - this.length()} 200 */ 201 @ForceInline 202 @SuppressWarnings("unchecked") 203 public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int i){ 204 Objects.requireNonNull(a); 205 i = VectorIntrinsics.checkIndex(i, a.length, species.length()); 206 return VectorIntrinsics.load((Class<FloatVector>) species.boxType(), float.class, species.length(), 207 a, (((long) i) << ARRAY_SHIFT) + Unsafe.ARRAY_FLOAT_BASE_OFFSET, 208 a, i, species, 209 (c, idx, s) -> ((FloatSpecies)s).op(n -> c[idx + n])); 210 } 211 212 213 /** 214 * Loads a vector from an array starting at offset and using a mask. 215 * <p> 216 * For each vector lane, where {@code N} is the vector lane index, 217 * if the mask lane at index {@code N} is set then the array element at 218 * index {@code i + N} is placed into the resulting vector at lane index 219 * {@code N}, otherwise the default element value is placed into the 220 * resulting vector at lane index {@code N}. 221 * 222 * @param species species of desired vector 223 * @param a the array 224 * @param i the offset into the array 225 * @param m the mask 226 * @return the vector loaded from an array 227 * @throws IndexOutOfBoundsException if {@code i < 0}, or 228 * for any vector lane index {@code N} where the mask at lane {@code N} 229 * is set {@code i > a.length - N} 230 */ 231 @ForceInline 232 public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int i, VectorMask<Float> m) { 233 return zero(species).blend(fromArray(species, a, i), m); 234 } 235 236 /** 237 * Loads a vector from an array using indexes obtained from an index 238 * map. 239 * <p> 240 * For each vector lane, where {@code N} is the vector lane index, the 241 * array element at index {@code i + indexMap[j + N]} is placed into the 242 * resulting vector at lane index {@code N}. 243 * 244 * @param species species of desired vector 245 * @param a the array 246 * @param i the offset into the array, may be negative if relative 247 * indexes in the index map compensate to produce a value within the 248 * array bounds 249 * @param indexMap the index map 250 * @param j the offset into the index map 251 * @return the vector loaded from an array 252 * @throws IndexOutOfBoundsException if {@code j < 0}, or 253 * {@code j > indexMap.length - this.length()}, 254 * or for any vector lane index {@code N} the result of 255 * {@code i + indexMap[j + N]} is {@code < 0} or {@code >= a.length} 256 */ 257 @ForceInline 258 @SuppressWarnings("unchecked") 259 public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int i, int[] indexMap, int j) { 260 Objects.requireNonNull(a); 261 Objects.requireNonNull(indexMap); 262 263 264 // Index vector: vix[0:n] = k -> i + indexMap[j + k] 265 IntVector vix = IntVector.fromArray(IntVector.species(species.indexShape()), indexMap, j).add(i); 266 267 vix = VectorIntrinsics.checkIndex(vix, a.length); 268 269 return VectorIntrinsics.loadWithMap((Class<FloatVector>) species.boxType(), float.class, species.length(), 270 IntVector.species(species.indexShape()).boxType(), a, Unsafe.ARRAY_FLOAT_BASE_OFFSET, vix, 271 a, i, indexMap, j, species, 272 (float[] c, int idx, int[] iMap, int idy, VectorSpecies<Float> s) -> 273 ((FloatSpecies)s).op(n -> c[idx + iMap[idy+n]])); 274 } 275 276 /** 277 * Loads a vector from an array using indexes obtained from an index 278 * map and using a mask. 279 * <p> 280 * For each vector lane, where {@code N} is the vector lane index, 281 * if the mask lane at index {@code N} is set then the array element at 282 * index {@code i + indexMap[j + N]} is placed into the resulting vector 283 * at lane index {@code N}. 284 * 285 * @param species species of desired vector 286 * @param a the array 287 * @param i the offset into the array, may be negative if relative 288 * indexes in the index map compensate to produce a value within the 289 * array bounds 290 * @param m the mask 291 * @param indexMap the index map 292 * @param j the offset into the index map 293 * @return the vector loaded from an array 294 * @throws IndexOutOfBoundsException if {@code j < 0}, or 295 * {@code j > indexMap.length - this.length()}, 296 * or for any vector lane index {@code N} where the mask at lane 297 * {@code N} is set the result of {@code i + indexMap[j + N]} is 298 * {@code < 0} or {@code >= a.length} 299 */ 300 @ForceInline 301 @SuppressWarnings("unchecked") 302 public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int i, VectorMask<Float> m, int[] indexMap, int j) { 303 // @@@ This can result in out of bounds errors for unset mask lanes 304 return zero(species).blend(fromArray(species, a, i, indexMap, j), m); 305 } 306 307 308 /** 309 * Loads a vector from a {@link ByteBuffer byte buffer} starting at an 310 * offset into the byte buffer. 311 * <p> 312 * Bytes are composed into primitive lane elements according to the 313 * native byte order of the underlying platform. 314 * <p> 315 * This method behaves as if it returns the result of calling the 316 * byte buffer, offset, and mask accepting 317 * {@link #fromByteBuffer(VectorSpecies<Float>, ByteBuffer, int, VectorMask)} method} as follows: 318 * <pre>{@code 319 * return this.fromByteBuffer(b, i, this.maskAllTrue()) 320 * }</pre> 321 * 322 * @param species species of desired vector 323 * @param bb the byte buffer 324 * @param ix the offset into the byte buffer 325 * @return a vector loaded from a byte buffer 326 * @throws IndexOutOfBoundsException if the offset is {@code < 0}, 327 * or {@code > b.limit()}, 328 * or if there are fewer than 329 * {@code this.length() * this.elementSize() / Byte.SIZE} bytes 330 * remaining in the byte buffer from the given offset 331 */ 332 @ForceInline 333 @SuppressWarnings("unchecked") 334 public static FloatVector fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int ix) { 335 if (bb.order() != ByteOrder.nativeOrder()) { 336 throw new IllegalArgumentException(); 337 } 338 ix = VectorIntrinsics.checkIndex(ix, bb.limit(), species.bitSize() / Byte.SIZE); 339 return VectorIntrinsics.load((Class<FloatVector>) species.boxType(), float.class, species.length(), 340 U.getReference(bb, BYTE_BUFFER_HB), U.getLong(bb, BUFFER_ADDRESS) + ix, 341 bb, ix, species, 342 (c, idx, s) -> { 343 ByteBuffer bbc = c.duplicate().position(idx).order(ByteOrder.nativeOrder()); 344 FloatBuffer tb = bbc.asFloatBuffer(); 345 return ((FloatSpecies)s).op(i -> tb.get()); 346 }); 347 } 348 349 /** 350 * Loads a vector from a {@link ByteBuffer byte buffer} starting at an 351 * offset into the byte buffer and using a mask. 352 * <p> 353 * This method behaves as if the byte buffer is viewed as a primitive 354 * {@link java.nio.Buffer buffer} for the primitive element type, 355 * according to the native byte order of the underlying platform, and 356 * the returned vector is loaded with a mask from a primitive array 357 * obtained from the primitive buffer. 358 * The following pseudocode expresses the behaviour, where 359 * {@coce EBuffer} is the primitive buffer type, {@code e} is the 360 * primitive element type, and {@code ESpecies<S>} is the primitive 361 * species for {@code e}: 362 * <pre>{@code 363 * EBuffer eb = b.duplicate(). 364 * order(ByteOrder.nativeOrder()).position(i). 365 * asEBuffer(); 366 * e[] es = new e[this.length()]; 367 * for (int n = 0; n < t.length; n++) { 368 * if (m.isSet(n)) 369 * es[n] = eb.get(n); 370 * } 371 * Vector<E> r = ((ESpecies<S>)this).fromArray(es, 0, m); 372 * }</pre> 373 * 374 * @param species species of desired vector 375 * @param bb the byte buffer 376 * @param ix the offset into the byte buffer 377 * @param m the mask 378 * @return a vector loaded from a byte buffer 379 * @throws IndexOutOfBoundsException if the offset is {@code < 0}, 380 * or {@code > b.limit()}, 381 * for any vector lane index {@code N} where the mask at lane {@code N} 382 * is set 383 * {@code i >= b.limit() - (N * this.elementSize() / Byte.SIZE)} 384 */ 385 @ForceInline 386 public static FloatVector fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int ix, VectorMask<Float> m) { 387 return zero(species).blend(fromByteBuffer(species, bb, ix), m); 388 } 389 390 /** 391 * Returns a vector where all lane elements are set to the primitive 392 * value {@code e}. 393 * 394 * @param s species of the desired vector 395 * @param e the value 396 * @return a vector of vector where all lane elements are set to 397 * the primitive value {@code e} 398 */ 399 @ForceInline 400 @SuppressWarnings("unchecked") 401 public static FloatVector broadcast(VectorSpecies<Float> s, float e) { 402 return VectorIntrinsics.broadcastCoerced( 403 (Class<FloatVector>) s.boxType(), float.class, s.length(), 404 Float.floatToIntBits(e), s, 405 ((bits, sp) -> ((FloatSpecies)sp).op(i -> Float.intBitsToFloat((int)bits)))); 406 } 407 408 /** 409 * Returns a vector where each lane element is set to a given 410 * primitive value. 411 * <p> 412 * For each vector lane, where {@code N} is the vector lane index, the 413 * the primitive value at index {@code N} is placed into the resulting 414 * vector at lane index {@code N}. 415 * 416 * @param s species of the desired vector 417 * @param es the given primitive values 418 * @return a vector where each lane element is set to a given primitive 419 * value 420 * @throws IndexOutOfBoundsException if {@code es.length < this.length()} 421 */ 422 @ForceInline 423 @SuppressWarnings("unchecked") 424 public static FloatVector scalars(VectorSpecies<Float> s, float... es) { 425 Objects.requireNonNull(es); 426 int ix = VectorIntrinsics.checkIndex(0, es.length, s.length()); 427 return VectorIntrinsics.load((Class<FloatVector>) s.boxType(), float.class, s.length(), 428 es, Unsafe.ARRAY_FLOAT_BASE_OFFSET, 429 es, ix, s, 430 (c, idx, sp) -> ((FloatSpecies)sp).op(n -> c[idx + n])); 431 } 432 433 /** 434 * Returns a vector where the first lane element is set to the primtive 435 * value {@code e}, all other lane elements are set to the default 436 * value. 437 * 438 * @param s species of the desired vector 439 * @param e the value 440 * @return a vector where the first lane element is set to the primitive 441 * value {@code e} 442 */ 443 @ForceInline 444 public static final FloatVector single(VectorSpecies<Float> s, float e) { 445 return zero(s).with(0, e); 446 } 447 448 /** 449 * Returns a vector where each lane element is set to a randomly 450 * generated primitive value. 451 * 452 * The semantics are equivalent to calling 453 * {@link ThreadLocalRandom#nextFloat()} 454 * 455 * @param s species of the desired vector 456 * @return a vector where each lane elements is set to a randomly 457 * generated primitive value 458 */ 459 public static FloatVector random(VectorSpecies<Float> s) { 460 ThreadLocalRandom r = ThreadLocalRandom.current(); 461 return ((FloatSpecies)s).op(i -> r.nextFloat()); 462 } 463 464 // Ops 465 466 @Override 467 public abstract FloatVector add(Vector<Float> v); 468 469 /** 470 * Adds this vector to the broadcast of an input scalar. 471 * <p> 472 * This is a vector binary operation where the primitive addition operation 473 * ({@code +}) is applied to lane elements. 474 * 475 * @param s the input scalar 476 * @return the result of adding this vector to the broadcast of an input 477 * scalar 478 */ 479 public abstract FloatVector add(float s); 480 481 @Override 482 public abstract FloatVector add(Vector<Float> v, VectorMask<Float> m); 483 484 /** 485 * Adds this vector to broadcast of an input scalar, 486 * selecting lane elements controlled by a mask. 487 * <p> 488 * This is a vector binary operation where the primitive addition operation 489 * ({@code +}) is applied to lane elements. 490 * 491 * @param s the input scalar 492 * @param m the mask controlling lane selection 493 * @return the result of adding this vector to the broadcast of an input 494 * scalar 495 */ 496 public abstract FloatVector add(float s, VectorMask<Float> m); 497 498 @Override 499 public abstract FloatVector sub(Vector<Float> v); 500 501 /** 502 * Subtracts the broadcast of an input scalar from this vector. 503 * <p> 504 * This is a vector binary operation where the primitive subtraction 505 * operation ({@code -}) is applied to lane elements. 506 * 507 * @param s the input scalar 508 * @return the result of subtracting the broadcast of an input 509 * scalar from this vector 510 */ 511 public abstract FloatVector sub(float s); 512 513 @Override 514 public abstract FloatVector sub(Vector<Float> v, VectorMask<Float> m); 515 516 /** 517 * Subtracts the broadcast of an input scalar from this vector, selecting 518 * lane elements controlled by a mask. 519 * <p> 520 * This is a vector binary operation where the primitive subtraction 521 * operation ({@code -}) is applied to lane elements. 522 * 523 * @param s the input scalar 524 * @param m the mask controlling lane selection 525 * @return the result of subtracting the broadcast of an input 526 * scalar from this vector 527 */ 528 public abstract FloatVector sub(float s, VectorMask<Float> m); 529 530 @Override 531 public abstract FloatVector mul(Vector<Float> v); 532 533 /** 534 * Multiplies this vector with the broadcast of an input scalar. 535 * <p> 536 * This is a vector binary operation where the primitive multiplication 537 * operation ({@code *}) is applied to lane elements. 538 * 539 * @param s the input scalar 540 * @return the result of multiplying this vector with the broadcast of an 541 * input scalar 542 */ 543 public abstract FloatVector mul(float s); 544 545 @Override 546 public abstract FloatVector mul(Vector<Float> v, VectorMask<Float> m); 547 548 /** 549 * Multiplies this vector with the broadcast of an input scalar, selecting 550 * lane elements controlled by a mask. 551 * <p> 552 * This is a vector binary operation where the primitive multiplication 553 * operation ({@code *}) is applied to lane elements. 554 * 555 * @param s the input scalar 556 * @param m the mask controlling lane selection 557 * @return the result of multiplying this vector with the broadcast of an 558 * input scalar 559 */ 560 public abstract FloatVector mul(float s, VectorMask<Float> m); 561 562 @Override 563 public abstract FloatVector neg(); 564 565 @Override 566 public abstract FloatVector neg(VectorMask<Float> m); 567 568 @Override 569 public abstract FloatVector abs(); 570 571 @Override 572 public abstract FloatVector abs(VectorMask<Float> m); 573 574 @Override 575 public abstract FloatVector min(Vector<Float> v); 576 577 @Override 578 public abstract FloatVector min(Vector<Float> v, VectorMask<Float> m); 579 580 /** 581 * Returns the minimum of this vector and the broadcast of an input scalar. 582 * <p> 583 * This is a vector binary operation where the operation 584 * {@code (a, b) -> Math.min(a, b)} is applied to lane elements. 585 * 586 * @param s the input scalar 587 * @return the minimum of this vector and the broadcast of an input scalar 588 */ 589 public abstract FloatVector min(float s); 590 591 @Override 592 public abstract FloatVector max(Vector<Float> v); 593 594 @Override 595 public abstract FloatVector max(Vector<Float> v, VectorMask<Float> m); 596 597 /** 598 * Returns the maximum of this vector and the broadcast of an input scalar. 599 * <p> 600 * This is a vector binary operation where the operation 601 * {@code (a, b) -> Math.max(a, b)} is applied to lane elements. 602 * 603 * @param s the input scalar 604 * @return the maximum of this vector and the broadcast of an input scalar 605 */ 606 public abstract FloatVector max(float s); 607 608 @Override 609 public abstract VectorMask<Float> equal(Vector<Float> v); 610 611 /** 612 * Tests if this vector is equal to the broadcast of an input scalar. 613 * <p> 614 * This is a vector binary test operation where the primitive equals 615 * operation ({@code ==}) is applied to lane elements. 616 * 617 * @param s the input scalar 618 * @return the result mask of testing if this vector is equal to the 619 * broadcast of an input scalar 620 */ 621 public abstract VectorMask<Float> equal(float s); 622 623 @Override 624 public abstract VectorMask<Float> notEqual(Vector<Float> v); 625 626 /** 627 * Tests if this vector is not equal to the broadcast of an input scalar. 628 * <p> 629 * This is a vector binary test operation where the primitive not equals 630 * operation ({@code !=}) is applied to lane elements. 631 * 632 * @param s the input scalar 633 * @return the result mask of testing if this vector is not equal to the 634 * broadcast of an input scalar 635 */ 636 public abstract VectorMask<Float> notEqual(float s); 637 638 @Override 639 public abstract VectorMask<Float> lessThan(Vector<Float> v); 640 641 /** 642 * Tests if this vector is less than the broadcast of an input scalar. 643 * <p> 644 * This is a vector binary test operation where the primitive less than 645 * operation ({@code <}) is applied to lane elements. 646 * 647 * @param s the input scalar 648 * @return the mask result of testing if this vector is less than the 649 * broadcast of an input scalar 650 */ 651 public abstract VectorMask<Float> lessThan(float s); 652 653 @Override 654 public abstract VectorMask<Float> lessThanEq(Vector<Float> v); 655 656 /** 657 * Tests if this vector is less or equal to the broadcast of an input scalar. 658 * <p> 659 * This is a vector binary test operation where the primitive less than 660 * or equal to operation ({@code <=}) is applied to lane elements. 661 * 662 * @param s the input scalar 663 * @return the mask result of testing if this vector is less than or equal 664 * to the broadcast of an input scalar 665 */ 666 public abstract VectorMask<Float> lessThanEq(float s); 667 668 @Override 669 public abstract VectorMask<Float> greaterThan(Vector<Float> v); 670 671 /** 672 * Tests if this vector is greater than the broadcast of an input scalar. 673 * <p> 674 * This is a vector binary test operation where the primitive greater than 675 * operation ({@code >}) is applied to lane elements. 676 * 677 * @param s the input scalar 678 * @return the mask result of testing if this vector is greater than the 679 * broadcast of an input scalar 680 */ 681 public abstract VectorMask<Float> greaterThan(float s); 682 683 @Override 684 public abstract VectorMask<Float> greaterThanEq(Vector<Float> v); 685 686 /** 687 * Tests if this vector is greater than or equal to the broadcast of an 688 * input scalar. 689 * <p> 690 * This is a vector binary test operation where the primitive greater than 691 * or equal to operation ({@code >=}) is applied to lane elements. 692 * 693 * @param s the input scalar 694 * @return the mask result of testing if this vector is greater than or 695 * equal to the broadcast of an input scalar 696 */ 697 public abstract VectorMask<Float> greaterThanEq(float s); 698 699 @Override 700 public abstract FloatVector blend(Vector<Float> v, VectorMask<Float> m); 701 702 /** 703 * Blends the lane elements of this vector with those of the broadcast of an 704 * input scalar, selecting lanes controlled by a mask. 705 * <p> 706 * For each lane of the mask, at lane index {@code N}, if the mask lane 707 * is set then the lane element at {@code N} from the input vector is 708 * selected and placed into the resulting vector at {@code N}, 709 * otherwise the the lane element at {@code N} from this input vector is 710 * selected and placed into the resulting vector at {@code N}. 711 * 712 * @param s the input scalar 713 * @param m the mask controlling lane selection 714 * @return the result of blending the lane elements of this vector with 715 * those of the broadcast of an input scalar 716 */ 717 public abstract FloatVector blend(float s, VectorMask<Float> m); 718 719 @Override 720 public abstract FloatVector rearrange(Vector<Float> v, 721 VectorShuffle<Float> s, VectorMask<Float> m); 722 723 @Override 724 public abstract FloatVector rearrange(VectorShuffle<Float> m); 725 726 @Override 727 public abstract FloatVector reshape(VectorSpecies<Float> s); 728 729 @Override 730 public abstract FloatVector rotateEL(int i); 731 732 @Override 733 public abstract FloatVector rotateER(int i); 734 735 @Override 736 public abstract FloatVector shiftEL(int i); 737 738 @Override 739 public abstract FloatVector shiftER(int i); 740 741 /** 742 * Divides this vector by an input vector. 743 * <p> 744 * This is a vector binary operation where the primitive division 745 * operation ({@code /}) is applied to lane elements. 746 * 747 * @param v the input vector 748 * @return the result of dividing this vector by the input vector 749 */ 750 public abstract FloatVector div(Vector<Float> v); 751 752 /** 753 * Divides this vector by the broadcast of an input scalar. 754 * <p> 755 * This is a vector binary operation where the primitive division 756 * operation ({@code /}) is applied to lane elements. 757 * 758 * @param s the input scalar 759 * @return the result of dividing this vector by the broadcast of an input 760 * scalar 761 */ 762 public abstract FloatVector div(float s); 763 764 /** 765 * Divides this vector by an input vector, selecting lane elements 766 * controlled by a mask. 767 * <p> 768 * This is a vector binary operation where the primitive division 769 * operation ({@code /}) is applied to lane elements. 770 * 771 * @param v the input vector 772 * @param m the mask controlling lane selection 773 * @return the result of dividing this vector by the input vector 774 */ 775 public abstract FloatVector div(Vector<Float> v, VectorMask<Float> m); 776 777 /** 778 * Divides this vector by the broadcast of an input scalar, selecting lane 779 * elements controlled by a mask. 780 * <p> 781 * This is a vector binary operation where the primitive division 782 * operation ({@code /}) is applied to lane elements. 783 * 784 * @param s the input scalar 785 * @param m the mask controlling lane selection 786 * @return the result of dividing this vector by the broadcast of an input 787 * scalar 788 */ 789 public abstract FloatVector div(float s, VectorMask<Float> m); 790 791 /** 792 * Calculates the square root of this vector. 793 * <p> 794 * This is a vector unary operation where the {@link Math#sqrt} operation 795 * is applied to lane elements. 796 * 797 * @return the square root of this vector 798 */ 799 public abstract FloatVector sqrt(); 800 801 /** 802 * Calculates the square root of this vector, selecting lane elements 803 * controlled by a mask. 804 * <p> 805 * This is a vector unary operation where the {@link Math#sqrt} operation 806 * is applied to lane elements. 807 * 808 * @param m the mask controlling lane selection 809 * @return the square root of this vector 810 */ 811 public FloatVector sqrt(VectorMask<Float> m) { 812 return uOp(m, (i, a) -> (float) Math.sqrt((double) a)); 813 } 814 815 /** 816 * Calculates the trigonometric tangent of this vector. 817 * <p> 818 * This is a vector unary operation with same semantic definition as 819 * {@link Math#tan} operation applied to lane elements. 820 * The implementation is not required to return same 821 * results as {@link Math#tan}, but adheres to rounding, monotonicity, 822 * and special case semantics as defined in the {@link Math#tan} 823 * specifications. The computed result will be within 1 ulp of the 824 * exact result. 825 * 826 * @return the tangent of this vector 827 */ 828 public FloatVector tan() { 829 return uOp((i, a) -> (float) Math.tan((double) a)); 830 } 831 832 /** 833 * Calculates the trigonometric tangent of this vector, selecting lane 834 * elements controlled by a mask. 835 * <p> 836 * Semantics for rounding, monotonicity, and special cases are 837 * described in {@link FloatVector#tan} 838 * 839 * @param m the mask controlling lane selection 840 * @return the tangent of this vector 841 */ 842 public FloatVector tan(VectorMask<Float> m) { 843 return uOp(m, (i, a) -> (float) Math.tan((double) a)); 844 } 845 846 /** 847 * Calculates the hyperbolic tangent of this vector. 848 * <p> 849 * This is a vector unary operation with same semantic definition as 850 * {@link Math#tanh} operation applied to lane elements. 851 * The implementation is not required to return same 852 * results as {@link Math#tanh}, but adheres to rounding, monotonicity, 853 * and special case semantics as defined in the {@link Math#tanh} 854 * specifications. The computed result will be within 2.5 ulps of the 855 * exact result. 856 * 857 * @return the hyperbolic tangent of this vector 858 */ 859 public FloatVector tanh() { 860 return uOp((i, a) -> (float) Math.tanh((double) a)); 861 } 862 863 /** 864 * Calculates the hyperbolic tangent of this vector, selecting lane elements 865 * controlled by a mask. 866 * <p> 867 * Semantics for rounding, monotonicity, and special cases are 868 * described in {@link FloatVector#tanh} 869 * 870 * @param m the mask controlling lane selection 871 * @return the hyperbolic tangent of this vector 872 */ 873 public FloatVector tanh(VectorMask<Float> m) { 874 return uOp(m, (i, a) -> (float) Math.tanh((double) a)); 875 } 876 877 /** 878 * Calculates the trigonometric sine of this vector. 879 * <p> 880 * This is a vector unary operation with same semantic definition as 881 * {@link Math#sin} operation applied to lane elements. 882 * The implementation is not required to return same 883 * results as {@link Math#sin}, but adheres to rounding, monotonicity, 884 * and special case semantics as defined in the {@link Math#sin} 885 * specifications. The computed result will be within 1 ulp of the 886 * exact result. 887 * 888 * @return the sine of this vector 889 */ 890 public FloatVector sin() { 891 return uOp((i, a) -> (float) Math.sin((double) a)); 892 } 893 894 /** 895 * Calculates the trigonometric sine of this vector, selecting lane elements 896 * controlled by a mask. 897 * <p> 898 * Semantics for rounding, monotonicity, and special cases are 899 * described in {@link FloatVector#sin} 900 * 901 * @param m the mask controlling lane selection 902 * @return the sine of this vector 903 */ 904 public FloatVector sin(VectorMask<Float> m) { 905 return uOp(m, (i, a) -> (float) Math.sin((double) a)); 906 } 907 908 /** 909 * Calculates the hyperbolic sine of this vector. 910 * <p> 911 * This is a vector unary operation with same semantic definition as 912 * {@link Math#sinh} operation applied to lane elements. 913 * The implementation is not required to return same 914 * results as {@link Math#sinh}, but adheres to rounding, monotonicity, 915 * and special case semantics as defined in the {@link Math#sinh} 916 * specifications. The computed result will be within 2.5 ulps of the 917 * exact result. 918 * 919 * @return the hyperbolic sine of this vector 920 */ 921 public FloatVector sinh() { 922 return uOp((i, a) -> (float) Math.sinh((double) a)); 923 } 924 925 /** 926 * Calculates the hyperbolic sine of this vector, selecting lane elements 927 * controlled by a mask. 928 * <p> 929 * Semantics for rounding, monotonicity, and special cases are 930 * described in {@link FloatVector#sinh} 931 * 932 * @param m the mask controlling lane selection 933 * @return the hyperbolic sine of this vector 934 */ 935 public FloatVector sinh(VectorMask<Float> m) { 936 return uOp(m, (i, a) -> (float) Math.sinh((double) a)); 937 } 938 939 /** 940 * Calculates the trigonometric cosine of this vector. 941 * <p> 942 * This is a vector unary operation with same semantic definition as 943 * {@link Math#cos} operation applied to lane elements. 944 * The implementation is not required to return same 945 * results as {@link Math#cos}, but adheres to rounding, monotonicity, 946 * and special case semantics as defined in the {@link Math#cos} 947 * specifications. The computed result will be within 1 ulp of the 948 * exact result. 949 * 950 * @return the cosine of this vector 951 */ 952 public FloatVector cos() { 953 return uOp((i, a) -> (float) Math.cos((double) a)); 954 } 955 956 /** 957 * Calculates the trigonometric cosine of this vector, selecting lane 958 * elements controlled by a mask. 959 * <p> 960 * Semantics for rounding, monotonicity, and special cases are 961 * described in {@link FloatVector#cos} 962 * 963 * @param m the mask controlling lane selection 964 * @return the cosine of this vector 965 */ 966 public FloatVector cos(VectorMask<Float> m) { 967 return uOp(m, (i, a) -> (float) Math.cos((double) a)); 968 } 969 970 /** 971 * Calculates the hyperbolic cosine of this vector. 972 * <p> 973 * This is a vector unary operation with same semantic definition as 974 * {@link Math#cosh} operation applied to lane elements. 975 * The implementation is not required to return same 976 * results as {@link Math#cosh}, but adheres to rounding, monotonicity, 977 * and special case semantics as defined in the {@link Math#cosh} 978 * specifications. The computed result will be within 2.5 ulps of the 979 * exact result. 980 * 981 * @return the hyperbolic cosine of this vector 982 */ 983 public FloatVector cosh() { 984 return uOp((i, a) -> (float) Math.cosh((double) a)); 985 } 986 987 /** 988 * Calculates the hyperbolic cosine of this vector, selecting lane elements 989 * controlled by a mask. 990 * <p> 991 * Semantics for rounding, monotonicity, and special cases are 992 * described in {@link FloatVector#cosh} 993 * 994 * @param m the mask controlling lane selection 995 * @return the hyperbolic cosine of this vector 996 */ 997 public FloatVector cosh(VectorMask<Float> m) { 998 return uOp(m, (i, a) -> (float) Math.cosh((double) a)); 999 } 1000 1001 /** 1002 * Calculates the arc sine of this vector. 1003 * <p> 1004 * This is a vector unary operation with same semantic definition as 1005 * {@link Math#asin} operation applied to lane elements. 1006 * The implementation is not required to return same 1007 * results as {@link Math#asin}, but adheres to rounding, monotonicity, 1008 * and special case semantics as defined in the {@link Math#asin} 1009 * specifications. The computed result will be within 1 ulp of the 1010 * exact result. 1011 * 1012 * @return the arc sine of this vector 1013 */ 1014 public FloatVector asin() { 1015 return uOp((i, a) -> (float) Math.asin((double) a)); 1016 } 1017 1018 /** 1019 * Calculates the arc sine of this vector, selecting lane elements 1020 * controlled by a mask. 1021 * <p> 1022 * Semantics for rounding, monotonicity, and special cases are 1023 * described in {@link FloatVector#asin} 1024 * 1025 * @param m the mask controlling lane selection 1026 * @return the arc sine of this vector 1027 */ 1028 public FloatVector asin(VectorMask<Float> m) { 1029 return uOp(m, (i, a) -> (float) Math.asin((double) a)); 1030 } 1031 1032 /** 1033 * Calculates the arc cosine of this vector. 1034 * <p> 1035 * This is a vector unary operation with same semantic definition as 1036 * {@link Math#acos} operation applied to lane elements. 1037 * The implementation is not required to return same 1038 * results as {@link Math#acos}, but adheres to rounding, monotonicity, 1039 * and special case semantics as defined in the {@link Math#acos} 1040 * specifications. The computed result will be within 1 ulp of the 1041 * exact result. 1042 * 1043 * @return the arc cosine of this vector 1044 */ 1045 public FloatVector acos() { 1046 return uOp((i, a) -> (float) Math.acos((double) a)); 1047 } 1048 1049 /** 1050 * Calculates the arc cosine of this vector, selecting lane elements 1051 * controlled by a mask. 1052 * <p> 1053 * Semantics for rounding, monotonicity, and special cases are 1054 * described in {@link FloatVector#acos} 1055 * 1056 * @param m the mask controlling lane selection 1057 * @return the arc cosine of this vector 1058 */ 1059 public FloatVector acos(VectorMask<Float> m) { 1060 return uOp(m, (i, a) -> (float) Math.acos((double) a)); 1061 } 1062 1063 /** 1064 * Calculates the arc tangent of this vector. 1065 * <p> 1066 * This is a vector unary operation with same semantic definition as 1067 * {@link Math#atan} operation applied to lane elements. 1068 * The implementation is not required to return same 1069 * results as {@link Math#atan}, but adheres to rounding, monotonicity, 1070 * and special case semantics as defined in the {@link Math#atan} 1071 * specifications. The computed result will be within 1 ulp of the 1072 * exact result. 1073 * 1074 * @return the arc tangent of this vector 1075 */ 1076 public FloatVector atan() { 1077 return uOp((i, a) -> (float) Math.atan((double) a)); 1078 } 1079 1080 /** 1081 * Calculates the arc tangent of this vector, selecting lane elements 1082 * controlled by a mask. 1083 * <p> 1084 * Semantics for rounding, monotonicity, and special cases are 1085 * described in {@link FloatVector#atan} 1086 * 1087 * @param m the mask controlling lane selection 1088 * @return the arc tangent of this vector 1089 */ 1090 public FloatVector atan(VectorMask<Float> m) { 1091 return uOp(m, (i, a) -> (float) Math.atan((double) a)); 1092 } 1093 1094 /** 1095 * Calculates the arc tangent of this vector divided by an input vector. 1096 * <p> 1097 * This is a vector binary operation with same semantic definition as 1098 * {@link Math#atan2} operation applied to lane elements. 1099 * The implementation is not required to return same 1100 * results as {@link Math#atan2}, but adheres to rounding, monotonicity, 1101 * and special case semantics as defined in the {@link Math#atan2} 1102 * specifications. The computed result will be within 2 ulps of the 1103 * exact result. 1104 * 1105 * @param v the input vector 1106 * @return the arc tangent of this vector divided by the input vector 1107 */ 1108 public FloatVector atan2(Vector<Float> v) { 1109 return bOp(v, (i, a, b) -> (float) Math.atan2((double) a, (double) b)); 1110 } 1111 1112 /** 1113 * Calculates the arc tangent of this vector divided by the broadcast of an 1114 * an input scalar. 1115 * <p> 1116 * This is a vector binary operation with same semantic definition as 1117 * {@link Math#atan2} operation applied to lane elements. 1118 * The implementation is not required to return same 1119 * results as {@link Math#atan2}, but adheres to rounding, monotonicity, 1120 * and special case semantics as defined in the {@link Math#atan2} 1121 * specifications. The computed result will be within 1 ulp of the 1122 * exact result. 1123 * 1124 * @param s the input scalar 1125 * @return the arc tangent of this vector over the input vector 1126 */ 1127 public abstract FloatVector atan2(float s); 1128 1129 /** 1130 * Calculates the arc tangent of this vector divided by an input vector, 1131 * selecting lane elements controlled by a mask. 1132 * <p> 1133 * Semantics for rounding, monotonicity, and special cases are 1134 * described in {@link FloatVector#atan2} 1135 * 1136 * @param v the input vector 1137 * @param m the mask controlling lane selection 1138 * @return the arc tangent of this vector divided by the input vector 1139 */ 1140 public FloatVector atan2(Vector<Float> v, VectorMask<Float> m) { 1141 return bOp(v, m, (i, a, b) -> (float) Math.atan2((double) a, (double) b)); 1142 } 1143 1144 /** 1145 * Calculates the arc tangent of this vector divided by the broadcast of an 1146 * an input scalar, selecting lane elements controlled by a mask. 1147 * <p> 1148 * Semantics for rounding, monotonicity, and special cases are 1149 * described in {@link FloatVector#atan2} 1150 * 1151 * @param s the input scalar 1152 * @param m the mask controlling lane selection 1153 * @return the arc tangent of this vector over the input vector 1154 */ 1155 public abstract FloatVector atan2(float s, VectorMask<Float> m); 1156 1157 /** 1158 * Calculates the cube root of this vector. 1159 * <p> 1160 * This is a vector unary operation with same semantic definition as 1161 * {@link Math#cbrt} operation applied to lane elements. 1162 * The implementation is not required to return same 1163 * results as {@link Math#cbrt}, but adheres to rounding, monotonicity, 1164 * and special case semantics as defined in the {@link Math#cbrt} 1165 * specifications. The computed result will be within 1 ulp of the 1166 * exact result. 1167 * 1168 * @return the cube root of this vector 1169 */ 1170 public FloatVector cbrt() { 1171 return uOp((i, a) -> (float) Math.cbrt((double) a)); 1172 } 1173 1174 /** 1175 * Calculates the cube root of this vector, selecting lane elements 1176 * controlled by a mask. 1177 * <p> 1178 * Semantics for rounding, monotonicity, and special cases are 1179 * described in {@link FloatVector#cbrt} 1180 * 1181 * @param m the mask controlling lane selection 1182 * @return the cube root of this vector 1183 */ 1184 public FloatVector cbrt(VectorMask<Float> m) { 1185 return uOp(m, (i, a) -> (float) Math.cbrt((double) a)); 1186 } 1187 1188 /** 1189 * Calculates the natural logarithm of this vector. 1190 * <p> 1191 * This is a vector unary operation with same semantic definition as 1192 * {@link Math#log} operation applied to lane elements. 1193 * The implementation is not required to return same 1194 * results as {@link Math#log}, but adheres to rounding, monotonicity, 1195 * and special case semantics as defined in the {@link Math#log} 1196 * specifications. The computed result will be within 1 ulp of the 1197 * exact result. 1198 * 1199 * @return the natural logarithm of this vector 1200 */ 1201 public FloatVector log() { 1202 return uOp((i, a) -> (float) Math.log((double) a)); 1203 } 1204 1205 /** 1206 * Calculates the natural logarithm of this vector, selecting lane elements 1207 * controlled by a mask. 1208 * <p> 1209 * Semantics for rounding, monotonicity, and special cases are 1210 * described in {@link FloatVector#log} 1211 * 1212 * @param m the mask controlling lane selection 1213 * @return the natural logarithm of this vector 1214 */ 1215 public FloatVector log(VectorMask<Float> m) { 1216 return uOp(m, (i, a) -> (float) Math.log((double) a)); 1217 } 1218 1219 /** 1220 * Calculates the base 10 logarithm of this vector. 1221 * <p> 1222 * This is a vector unary operation with same semantic definition as 1223 * {@link Math#log10} operation applied to lane elements. 1224 * The implementation is not required to return same 1225 * results as {@link Math#log10}, but adheres to rounding, monotonicity, 1226 * and special case semantics as defined in the {@link Math#log10} 1227 * specifications. The computed result will be within 1 ulp of the 1228 * exact result. 1229 * 1230 * @return the base 10 logarithm of this vector 1231 */ 1232 public FloatVector log10() { 1233 return uOp((i, a) -> (float) Math.log10((double) a)); 1234 } 1235 1236 /** 1237 * Calculates the base 10 logarithm of this vector, selecting lane elements 1238 * controlled by a mask. 1239 * <p> 1240 * Semantics for rounding, monotonicity, and special cases are 1241 * described in {@link FloatVector#log10} 1242 * 1243 * @param m the mask controlling lane selection 1244 * @return the base 10 logarithm of this vector 1245 */ 1246 public FloatVector log10(VectorMask<Float> m) { 1247 return uOp(m, (i, a) -> (float) Math.log10((double) a)); 1248 } 1249 1250 /** 1251 * Calculates the natural logarithm of the sum of this vector and the 1252 * broadcast of {@code 1}. 1253 * <p> 1254 * This is a vector unary operation with same semantic definition as 1255 * {@link Math#log1p} operation applied to lane elements. 1256 * The implementation is not required to return same 1257 * results as {@link Math#log1p}, but adheres to rounding, monotonicity, 1258 * and special case semantics as defined in the {@link Math#log1p} 1259 * specifications. The computed result will be within 1 ulp of the 1260 * exact result. 1261 * 1262 * @return the natural logarithm of the sum of this vector and the broadcast 1263 * of {@code 1} 1264 */ 1265 public FloatVector log1p() { 1266 return uOp((i, a) -> (float) Math.log1p((double) a)); 1267 } 1268 1269 /** 1270 * Calculates the natural logarithm of the sum of this vector and the 1271 * broadcast of {@code 1}, selecting lane elements controlled by a mask. 1272 * <p> 1273 * Semantics for rounding, monotonicity, and special cases are 1274 * described in {@link FloatVector#log1p} 1275 * 1276 * @param m the mask controlling lane selection 1277 * @return the natural logarithm of the sum of this vector and the broadcast 1278 * of {@code 1} 1279 */ 1280 public FloatVector log1p(VectorMask<Float> m) { 1281 return uOp(m, (i, a) -> (float) Math.log1p((double) a)); 1282 } 1283 1284 /** 1285 * Calculates this vector raised to the power of an input vector. 1286 * <p> 1287 * This is a vector binary operation with same semantic definition as 1288 * {@link Math#pow} operation applied to lane elements. 1289 * The implementation is not required to return same 1290 * results as {@link Math#pow}, but adheres to rounding, monotonicity, 1291 * and special case semantics as defined in the {@link Math#pow} 1292 * specifications. The computed result will be within 1 ulp of the 1293 * exact result. 1294 * 1295 * @param v the input vector 1296 * @return this vector raised to the power of an input vector 1297 */ 1298 public FloatVector pow(Vector<Float> v) { 1299 return bOp(v, (i, a, b) -> (float) Math.pow((double) a, (double) b)); 1300 } 1301 1302 /** 1303 * Calculates this vector raised to the power of the broadcast of an input 1304 * scalar. 1305 * <p> 1306 * This is a vector binary operation with same semantic definition as 1307 * {@link Math#pow} operation applied to lane elements. 1308 * The implementation is not required to return same 1309 * results as {@link Math#pow}, but adheres to rounding, monotonicity, 1310 * and special case semantics as defined in the {@link Math#pow} 1311 * specifications. The computed result will be within 1 ulp of the 1312 * exact result. 1313 * 1314 * @param s the input scalar 1315 * @return this vector raised to the power of the broadcast of an input 1316 * scalar. 1317 */ 1318 public abstract FloatVector pow(float s); 1319 1320 /** 1321 * Calculates this vector raised to the power of an input vector, selecting 1322 * lane elements controlled by a mask. 1323 * <p> 1324 * Semantics for rounding, monotonicity, and special cases are 1325 * described in {@link FloatVector#pow} 1326 * 1327 * @param v the input vector 1328 * @param m the mask controlling lane selection 1329 * @return this vector raised to the power of an input vector 1330 */ 1331 public FloatVector pow(Vector<Float> v, VectorMask<Float> m) { 1332 return bOp(v, m, (i, a, b) -> (float) Math.pow((double) a, (double) b)); 1333 } 1334 1335 /** 1336 * Calculates this vector raised to the power of the broadcast of an input 1337 * scalar, selecting lane elements controlled by a mask. 1338 * <p> 1339 * Semantics for rounding, monotonicity, and special cases are 1340 * described in {@link FloatVector#pow} 1341 * 1342 * @param s the input scalar 1343 * @param m the mask controlling lane selection 1344 * @return this vector raised to the power of the broadcast of an input 1345 * scalar. 1346 */ 1347 public abstract FloatVector pow(float s, VectorMask<Float> m); 1348 1349 /** 1350 * Calculates the broadcast of Euler's number {@code e} raised to the power 1351 * of this vector. 1352 * <p> 1353 * This is a vector unary operation with same semantic definition as 1354 * {@link Math#exp} operation applied to lane elements. 1355 * The implementation is not required to return same 1356 * results as {@link Math#exp}, but adheres to rounding, monotonicity, 1357 * and special case semantics as defined in the {@link Math#exp} 1358 * specifications. The computed result will be within 1 ulp of the 1359 * exact result. 1360 * 1361 * @return the broadcast of Euler's number {@code e} raised to the power of 1362 * this vector 1363 */ 1364 public FloatVector exp() { 1365 return uOp((i, a) -> (float) Math.exp((double) a)); 1366 } 1367 1368 /** 1369 * Calculates the broadcast of Euler's number {@code e} raised to the power 1370 * of this vector, selecting lane elements controlled by a mask. 1371 * <p> 1372 * Semantics for rounding, monotonicity, and special cases are 1373 * described in {@link FloatVector#exp} 1374 * 1375 * @param m the mask controlling lane selection 1376 * @return the broadcast of Euler's number {@code e} raised to the power of 1377 * this vector 1378 */ 1379 public FloatVector exp(VectorMask<Float> m) { 1380 return uOp(m, (i, a) -> (float) Math.exp((double) a)); 1381 } 1382 1383 /** 1384 * Calculates the broadcast of Euler's number {@code e} raised to the power 1385 * of this vector minus the broadcast of {@code -1}. 1386 * More specifically as if the following (ignoring any differences in 1387 * numerical accuracy): 1388 * <pre>{@code 1389 * this.exp().sub(this.species().broadcast(1)) 1390 * }</pre> 1391 * <p> 1392 * This is a vector unary operation with same semantic definition as 1393 * {@link Math#expm1} operation applied to lane elements. 1394 * The implementation is not required to return same 1395 * results as {@link Math#expm1}, but adheres to rounding, monotonicity, 1396 * and special case semantics as defined in the {@link Math#expm1} 1397 * specifications. The computed result will be within 1 ulp of the 1398 * exact result. 1399 * 1400 * @return the broadcast of Euler's number {@code e} raised to the power of 1401 * this vector minus the broadcast of {@code -1} 1402 */ 1403 public FloatVector expm1() { 1404 return uOp((i, a) -> (float) Math.expm1((double) a)); 1405 } 1406 1407 /** 1408 * Calculates the broadcast of Euler's number {@code e} raised to the power 1409 * of this vector minus the broadcast of {@code -1}, selecting lane elements 1410 * controlled by a mask 1411 * More specifically as if the following (ignoring any differences in 1412 * numerical accuracy): 1413 * <pre>{@code 1414 * this.exp(m).sub(this.species().broadcast(1), m) 1415 * }</pre> 1416 * <p> 1417 * Semantics for rounding, monotonicity, and special cases are 1418 * described in {@link FloatVector#expm1} 1419 * 1420 * @param m the mask controlling lane selection 1421 * @return the broadcast of Euler's number {@code e} raised to the power of 1422 * this vector minus the broadcast of {@code -1} 1423 */ 1424 public FloatVector expm1(VectorMask<Float> m) { 1425 return uOp(m, (i, a) -> (float) Math.expm1((double) a)); 1426 } 1427 1428 /** 1429 * Calculates the product of this vector and a first input vector summed 1430 * with a second input vector. 1431 * More specifically as if the following (ignoring any differences in 1432 * numerical accuracy): 1433 * <pre>{@code 1434 * this.mul(v1).add(v2) 1435 * }</pre> 1436 * <p> 1437 * This is a vector ternary operation where the {@link Math#fma} operation 1438 * is applied to lane elements. 1439 * 1440 * @param v1 the first input vector 1441 * @param v2 the second input vector 1442 * @return the product of this vector and the first input vector summed with 1443 * the second input vector 1444 */ 1445 public abstract FloatVector fma(Vector<Float> v1, Vector<Float> v2); 1446 1447 /** 1448 * Calculates the product of this vector and the broadcast of a first input 1449 * scalar summed with the broadcast of a second input scalar. 1450 * More specifically as if the following: 1451 * <pre>{@code 1452 * this.fma(this.species().broadcast(s1), this.species().broadcast(s2)) 1453 * }</pre> 1454 * <p> 1455 * This is a vector ternary operation where the {@link Math#fma} operation 1456 * is applied to lane elements. 1457 * 1458 * @param s1 the first input scalar 1459 * @param s2 the second input scalar 1460 * @return the product of this vector and the broadcast of a first input 1461 * scalar summed with the broadcast of a second input scalar 1462 */ 1463 public abstract FloatVector fma(float s1, float s2); 1464 1465 /** 1466 * Calculates the product of this vector and a first input vector summed 1467 * with a second input vector, selecting lane elements controlled by a mask. 1468 * More specifically as if the following (ignoring any differences in 1469 * numerical accuracy): 1470 * <pre>{@code 1471 * this.mul(v1, m).add(v2, m) 1472 * }</pre> 1473 * <p> 1474 * This is a vector ternary operation where the {@link Math#fma} operation 1475 * is applied to lane elements. 1476 * 1477 * @param v1 the first input vector 1478 * @param v2 the second input vector 1479 * @param m the mask controlling lane selection 1480 * @return the product of this vector and the first input vector summed with 1481 * the second input vector 1482 */ 1483 public FloatVector fma(Vector<Float> v1, Vector<Float> v2, VectorMask<Float> m) { 1484 return tOp(v1, v2, m, (i, a, b, c) -> Math.fma(a, b, c)); 1485 } 1486 1487 /** 1488 * Calculates the product of this vector and the broadcast of a first input 1489 * scalar summed with the broadcast of a second input scalar, selecting lane 1490 * elements controlled by a mask 1491 * More specifically as if the following: 1492 * <pre>{@code 1493 * this.fma(this.species().broadcast(s1), this.species().broadcast(s2), m) 1494 * }</pre> 1495 * <p> 1496 * This is a vector ternary operation where the {@link Math#fma} operation 1497 * is applied to lane elements. 1498 * 1499 * @param s1 the first input scalar 1500 * @param s2 the second input scalar 1501 * @param m the mask controlling lane selection 1502 * @return the product of this vector and the broadcast of a first input 1503 * scalar summed with the broadcast of a second input scalar 1504 */ 1505 public abstract FloatVector fma(float s1, float s2, VectorMask<Float> m); 1506 1507 /** 1508 * Calculates square root of the sum of the squares of this vector and an 1509 * input vector. 1510 * More specifically as if the following (ignoring any differences in 1511 * numerical accuracy): 1512 * <pre>{@code 1513 * this.mul(this).add(v.mul(v)).sqrt() 1514 * }</pre> 1515 * <p> 1516 * This is a vector binary operation with same semantic definition as 1517 * {@link Math#hypot} operation applied to lane elements. 1518 * The implementation is not required to return same 1519 * results as {@link Math#hypot}, but adheres to rounding, monotonicity, 1520 * and special case semantics as defined in the {@link Math#hypot} 1521 * specifications. The computed result will be within 1 ulp of the 1522 * exact result. 1523 * 1524 * @param v the input vector 1525 * @return square root of the sum of the squares of this vector and an input 1526 * vector 1527 */ 1528 public FloatVector hypot(Vector<Float> v) { 1529 return bOp(v, (i, a, b) -> (float) Math.hypot((double) a, (double) b)); 1530 } 1531 1532 /** 1533 * Calculates square root of the sum of the squares of this vector and the 1534 * broadcast of an input scalar. 1535 * More specifically as if the following (ignoring any differences in 1536 * numerical accuracy): 1537 * <pre>{@code 1538 * this.mul(this).add(this.species().broadcast(v * v)).sqrt() 1539 * }</pre> 1540 * <p> 1541 * This is a vector binary operation with same semantic definition as 1542 * {@link Math#hypot} operation applied to lane elements. 1543 * The implementation is not required to return same 1544 * results as {@link Math#hypot}, but adheres to rounding, monotonicity, 1545 * and special case semantics as defined in the {@link Math#hypot} 1546 * specifications. The computed result will be within 1 ulp of the 1547 * exact result. 1548 * 1549 * @param s the input scalar 1550 * @return square root of the sum of the squares of this vector and the 1551 * broadcast of an input scalar 1552 */ 1553 public abstract FloatVector hypot(float s); 1554 1555 /** 1556 * Calculates square root of the sum of the squares of this vector and an 1557 * input vector, selecting lane elements controlled by a mask. 1558 * More specifically as if the following (ignoring any differences in 1559 * numerical accuracy): 1560 * <pre>{@code 1561 * this.mul(this, m).add(v.mul(v), m).sqrt(m) 1562 * }</pre> 1563 * <p> 1564 * Semantics for rounding, monotonicity, and special cases are 1565 * described in {@link FloatVector#hypot} 1566 * 1567 * @param v the input vector 1568 * @param m the mask controlling lane selection 1569 * @return square root of the sum of the squares of this vector and an input 1570 * vector 1571 */ 1572 public FloatVector hypot(Vector<Float> v, VectorMask<Float> m) { 1573 return bOp(v, m, (i, a, b) -> (float) Math.hypot((double) a, (double) b)); 1574 } 1575 1576 /** 1577 * Calculates square root of the sum of the squares of this vector and the 1578 * broadcast of an input scalar, selecting lane elements controlled by a 1579 * mask. 1580 * More specifically as if the following (ignoring any differences in 1581 * numerical accuracy): 1582 * <pre>{@code 1583 * this.mul(this, m).add(this.species().broadcast(v * v), m).sqrt(m) 1584 * }</pre> 1585 * <p> 1586 * Semantics for rounding, monotonicity, and special cases are 1587 * described in {@link FloatVector#hypot} 1588 * 1589 * @param s the input scalar 1590 * @param m the mask controlling lane selection 1591 * @return square root of the sum of the squares of this vector and the 1592 * broadcast of an input scalar 1593 */ 1594 public abstract FloatVector hypot(float s, VectorMask<Float> m); 1595 1596 1597 @Override 1598 public abstract void intoByteArray(byte[] a, int ix); 1599 1600 @Override 1601 public abstract void intoByteArray(byte[] a, int ix, VectorMask<Float> m); 1602 1603 @Override 1604 public abstract void intoByteBuffer(ByteBuffer bb, int ix); 1605 1606 @Override 1607 public abstract void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Float> m); 1608 1609 1610 // Type specific horizontal reductions 1611 /** 1612 * Adds all lane elements of this vector. 1613 * <p> 1614 * This is a vector reduction operation where the addition 1615 * operation ({@code +}) is applied to lane elements, 1616 * and the identity value is {@code 0.0}. 1617 * 1618 * <p>The value of a floating-point sum is a function both of the input values as well 1619 * as the order of addition operations. The order of addition operations of this method 1620 * is intentionally not defined to allow for JVM to generate optimal machine 1621 * code for the underlying platform at runtime. If the platform supports a vector 1622 * instruction to add all values in the vector, or if there is some other efficient machine 1623 * code sequence, then the JVM has the option of generating this machine code. Otherwise, 1624 * the default implementation of adding vectors sequentially from left to right is used. 1625 * For this reason, the output of this method may vary for the same input values. 1626 * 1627 * @return the addition of all the lane elements of this vector 1628 */ 1629 public abstract float addAll(); 1630 1631 /** 1632 * Adds all lane elements of this vector, selecting lane elements 1633 * controlled by a mask. 1634 * <p> 1635 * This is a vector reduction operation where the addition 1636 * operation ({@code +}) is applied to lane elements, 1637 * and the identity value is {@code 0.0}. 1638 * 1639 * <p>The value of a floating-point sum is a function both of the input values as well 1640 * as the order of addition operations. The order of addition operations of this method 1641 * is intentionally not defined to allow for JVM to generate optimal machine 1642 * code for the underlying platform at runtime. If the platform supports a vector 1643 * instruction to add all values in the vector, or if there is some other efficient machine 1644 * code sequence, then the JVM has the option of generating this machine code. Otherwise, 1645 * the default implementation of adding vectors sequentially from left to right is used. 1646 * For this reason, the output of this method may vary on the same input values. 1647 * 1648 * @param m the mask controlling lane selection 1649 * @return the addition of the selected lane elements of this vector 1650 */ 1651 public abstract float addAll(VectorMask<Float> m); 1652 1653 /** 1654 * Multiplies all lane elements of this vector. 1655 * <p> 1656 * This is a vector reduction operation where the 1657 * multiplication operation ({@code *}) is applied to lane elements, 1658 * and the identity value is {@code 1.0}. 1659 * 1660 * <p>The order of multiplication operations of this method 1661 * is intentionally not defined to allow for JVM to generate optimal machine 1662 * code for the underlying platform at runtime. If the platform supports a vector 1663 * instruction to multiply all values in the vector, or if there is some other efficient machine 1664 * code sequence, then the JVM has the option of generating this machine code. Otherwise, 1665 * the default implementation of multiplying vectors sequentially from left to right is used. 1666 * For this reason, the output of this method may vary on the same input values. 1667 * 1668 * @return the multiplication of all the lane elements of this vector 1669 */ 1670 public abstract float mulAll(); 1671 1672 /** 1673 * Multiplies all lane elements of this vector, selecting lane elements 1674 * controlled by a mask. 1675 * <p> 1676 * This is a vector reduction operation where the 1677 * multiplication operation ({@code *}) is applied to lane elements, 1678 * and the identity value is {@code 1.0}. 1679 * 1680 * <p>The order of multiplication operations of this method 1681 * is intentionally not defined to allow for JVM to generate optimal machine 1682 * code for the underlying platform at runtime. If the platform supports a vector 1683 * instruction to multiply all values in the vector, or if there is some other efficient machine 1684 * code sequence, then the JVM has the option of generating this machine code. Otherwise, 1685 * the default implementation of multiplying vectors sequentially from left to right is used. 1686 * For this reason, the output of this method may vary on the same input values. 1687 * 1688 * @param m the mask controlling lane selection 1689 * @return the multiplication of all the lane elements of this vector 1690 */ 1691 public abstract float mulAll(VectorMask<Float> m); 1692 1693 /** 1694 * Returns the minimum lane element of this vector. 1695 * <p> 1696 * This is an associative vector reduction operation where the operation 1697 * {@code (a, b) -> Math.min(a, b)} is applied to lane elements, 1698 * and the identity value is 1699 * {@link Float#POSITIVE_INFINITY}. 1700 * 1701 * @return the minimum lane element of this vector 1702 */ 1703 public abstract float minAll(); 1704 1705 /** 1706 * Returns the minimum lane element of this vector, selecting lane elements 1707 * controlled by a mask. 1708 * <p> 1709 * This is an associative vector reduction operation where the operation 1710 * {@code (a, b) -> Math.min(a, b)} is applied to lane elements, 1711 * and the identity value is 1712 * {@link Float#POSITIVE_INFINITY}. 1713 * 1714 * @param m the mask controlling lane selection 1715 * @return the minimum lane element of this vector 1716 */ 1717 public abstract float minAll(VectorMask<Float> m); 1718 1719 /** 1720 * Returns the maximum lane element of this vector. 1721 * <p> 1722 * This is an associative vector reduction operation where the operation 1723 * {@code (a, b) -> Math.max(a, b)} is applied to lane elements, 1724 * and the identity value is 1725 * {@link Float#NEGATIVE_INFINITY}. 1726 * 1727 * @return the maximum lane element of this vector 1728 */ 1729 public abstract float maxAll(); 1730 1731 /** 1732 * Returns the maximum lane element of this vector, selecting lane elements 1733 * controlled by a mask. 1734 * <p> 1735 * This is an associative vector reduction operation where the operation 1736 * {@code (a, b) -> Math.max(a, b)} is applied to lane elements, 1737 * and the identity value is 1738 * {@link Float#NEGATIVE_INFINITY}. 1739 * 1740 * @param m the mask controlling lane selection 1741 * @return the maximum lane element of this vector 1742 */ 1743 public abstract float maxAll(VectorMask<Float> m); 1744 1745 1746 // Type specific accessors 1747 1748 /** 1749 * Gets the lane element at lane index {@code i} 1750 * 1751 * @param i the lane index 1752 * @return the lane element at lane index {@code i} 1753 * @throws IllegalArgumentException if the index is is out of range 1754 * ({@code < 0 || >= length()}) 1755 */ 1756 public abstract float get(int i); 1757 1758 /** 1759 * Replaces the lane element of this vector at lane index {@code i} with 1760 * value {@code e}. 1761 * <p> 1762 * This is a cross-lane operation and behaves as if it returns the result 1763 * of blending this vector with an input vector that is the result of 1764 * broadcasting {@code e} and a mask that has only one lane set at lane 1765 * index {@code i}. 1766 * 1767 * @param i the lane index of the lane element to be replaced 1768 * @param e the value to be placed 1769 * @return the result of replacing the lane element of this vector at lane 1770 * index {@code i} with value {@code e}. 1771 * @throws IllegalArgumentException if the index is is out of range 1772 * ({@code < 0 || >= length()}) 1773 */ 1774 public abstract FloatVector with(int i, float e); 1775 1776 // Type specific extractors 1777 1778 /** 1779 * Returns an array containing the lane elements of this vector. 1780 * <p> 1781 * This method behaves as if it {@link #intoArray(float[], int)} stores} 1782 * this vector into an allocated array and returns the array as follows: 1783 * <pre>{@code 1784 * float[] a = new float[this.length()]; 1785 * this.intoArray(a, 0); 1786 * return a; 1787 * }</pre> 1788 * 1789 * @return an array containing the the lane elements of this vector 1790 */ 1791 @ForceInline 1792 public final float[] toArray() { 1793 float[] a = new float[species().length()]; 1794 intoArray(a, 0); 1795 return a; 1796 } 1797 1798 /** 1799 * Stores this vector into an array starting at offset. 1800 * <p> 1801 * For each vector lane, where {@code N} is the vector lane index, 1802 * the lane element at index {@code N} is stored into the array at index 1803 * {@code i + N}. 1804 * 1805 * @param a the array 1806 * @param i the offset into the array 1807 * @throws IndexOutOfBoundsException if {@code i < 0}, or 1808 * {@code i > a.length - this.length()} 1809 */ 1810 public abstract void intoArray(float[] a, int i); 1811 1812 /** 1813 * Stores this vector into an array starting at offset and using a mask. 1814 * <p> 1815 * For each vector lane, where {@code N} is the vector lane index, 1816 * if the mask lane at index {@code N} is set then the lane element at 1817 * index {@code N} is stored into the array index {@code i + N}. 1818 * 1819 * @param a the array 1820 * @param i the offset into the array 1821 * @param m the mask 1822 * @throws IndexOutOfBoundsException if {@code i < 0}, or 1823 * for any vector lane index {@code N} where the mask at lane {@code N} 1824 * is set {@code i >= a.length - N} 1825 */ 1826 public abstract void intoArray(float[] a, int i, VectorMask<Float> m); 1827 1828 /** 1829 * Stores this vector into an array using indexes obtained from an index 1830 * map. 1831 * <p> 1832 * For each vector lane, where {@code N} is the vector lane index, the 1833 * lane element at index {@code N} is stored into the array at index 1834 * {@code i + indexMap[j + N]}. 1835 * 1836 * @param a the array 1837 * @param i the offset into the array, may be negative if relative 1838 * indexes in the index map compensate to produce a value within the 1839 * array bounds 1840 * @param indexMap the index map 1841 * @param j the offset into the index map 1842 * @throws IndexOutOfBoundsException if {@code j < 0}, or 1843 * {@code j > indexMap.length - this.length()}, 1844 * or for any vector lane index {@code N} the result of 1845 * {@code i + indexMap[j + N]} is {@code < 0} or {@code >= a.length} 1846 */ 1847 public abstract void intoArray(float[] a, int i, int[] indexMap, int j); 1848 1849 /** 1850 * Stores this vector into an array using indexes obtained from an index 1851 * map and using a mask. 1852 * <p> 1853 * For each vector lane, where {@code N} is the vector lane index, 1854 * if the mask lane at index {@code N} is set then the lane element at 1855 * index {@code N} is stored into the array at index 1856 * {@code i + indexMap[j + N]}. 1857 * 1858 * @param a the array 1859 * @param i the offset into the array, may be negative if relative 1860 * indexes in the index map compensate to produce a value within the 1861 * array bounds 1862 * @param m the mask 1863 * @param indexMap the index map 1864 * @param j the offset into the index map 1865 * @throws IndexOutOfBoundsException if {@code j < 0}, or 1866 * {@code j > indexMap.length - this.length()}, 1867 * or for any vector lane index {@code N} where the mask at lane 1868 * {@code N} is set the result of {@code i + indexMap[j + N]} is 1869 * {@code < 0} or {@code >= a.length} 1870 */ 1871 public abstract void intoArray(float[] a, int i, VectorMask<Float> m, int[] indexMap, int j); 1872 // Species 1873 1874 @Override 1875 public abstract VectorSpecies<Float> species(); 1876 1877 /** 1878 * Class representing {@link FloatVector}'s of the same {@link VectorShape VectorShape}. 1879 */ 1880 static final class FloatSpecies extends AbstractSpecies<Float> { 1881 final Function<float[], FloatVector> vectorFactory; 1882 1883 private FloatSpecies(VectorShape shape, 1884 Class<?> boxType, 1885 Class<?> maskType, 1886 Function<float[], FloatVector> vectorFactory, 1887 Function<boolean[], VectorMask<Float>> maskFactory, 1888 Function<IntUnaryOperator, VectorShuffle<Float>> shuffleFromArrayFactory, 1889 fShuffleFromArray<Float> shuffleFromOpFactory) { 1890 super(shape, float.class, Float.SIZE, boxType, maskType, maskFactory, 1891 shuffleFromArrayFactory, shuffleFromOpFactory); 1892 this.vectorFactory = vectorFactory; 1893 } 1894 1895 interface FOp { 1896 float apply(int i); 1897 } 1898 1899 FloatVector op(FOp f) { 1900 float[] res = new float[length()]; 1901 for (int i = 0; i < length(); i++) { 1902 res[i] = f.apply(i); 1903 } 1904 return vectorFactory.apply(res); 1905 } 1906 1907 FloatVector op(VectorMask<Float> o, FOp f) { 1908 float[] res = new float[length()]; 1909 boolean[] mbits = ((AbstractMask<Float>)o).getBits(); 1910 for (int i = 0; i < length(); i++) { 1911 if (mbits[i]) { 1912 res[i] = f.apply(i); 1913 } 1914 } 1915 return vectorFactory.apply(res); 1916 } 1917 } 1918 1919 /** 1920 * Finds the preferred species for an element type of {@code float}. 1921 * <p> 1922 * A preferred species is a species chosen by the platform that has a 1923 * shape of maximal bit size. A preferred species for different element 1924 * types will have the same shape, and therefore vectors, masks, and 1925 * shuffles created from such species will be shape compatible. 1926 * 1927 * @return the preferred species for an element type of {@code float} 1928 */ 1929 private static FloatSpecies preferredSpecies() { 1930 return (FloatSpecies) VectorSpecies.ofPreferred(float.class); 1931 } 1932 1933 /** 1934 * Finds a species for an element type of {@code float} and shape. 1935 * 1936 * @param s the shape 1937 * @return a species for an element type of {@code float} and shape 1938 * @throws IllegalArgumentException if no such species exists for the shape 1939 */ 1940 static FloatSpecies species(VectorShape s) { 1941 Objects.requireNonNull(s); 1942 switch (s) { 1943 case S_64_BIT: return (FloatSpecies) SPECIES_64; 1944 case S_128_BIT: return (FloatSpecies) SPECIES_128; 1945 case S_256_BIT: return (FloatSpecies) SPECIES_256; 1946 case S_512_BIT: return (FloatSpecies) SPECIES_512; 1947 case S_Max_BIT: return (FloatSpecies) SPECIES_MAX; 1948 default: throw new IllegalArgumentException("Bad shape: " + s); 1949 } 1950 } 1951 1952 /** Species representing {@link FloatVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */ 1953 public static final VectorSpecies<Float> SPECIES_64 = new FloatSpecies(VectorShape.S_64_BIT, Float64Vector.class, Float64Vector.Float64Mask.class, 1954 Float64Vector::new, Float64Vector.Float64Mask::new, 1955 Float64Vector.Float64Shuffle::new, Float64Vector.Float64Shuffle::new); 1956 1957 /** Species representing {@link FloatVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */ 1958 public static final VectorSpecies<Float> SPECIES_128 = new FloatSpecies(VectorShape.S_128_BIT, Float128Vector.class, Float128Vector.Float128Mask.class, 1959 Float128Vector::new, Float128Vector.Float128Mask::new, 1960 Float128Vector.Float128Shuffle::new, Float128Vector.Float128Shuffle::new); 1961 1962 /** Species representing {@link FloatVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */ 1963 public static final VectorSpecies<Float> SPECIES_256 = new FloatSpecies(VectorShape.S_256_BIT, Float256Vector.class, Float256Vector.Float256Mask.class, 1964 Float256Vector::new, Float256Vector.Float256Mask::new, 1965 Float256Vector.Float256Shuffle::new, Float256Vector.Float256Shuffle::new); 1966 1967 /** Species representing {@link FloatVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */ 1968 public static final VectorSpecies<Float> SPECIES_512 = new FloatSpecies(VectorShape.S_512_BIT, Float512Vector.class, Float512Vector.Float512Mask.class, 1969 Float512Vector::new, Float512Vector.Float512Mask::new, 1970 Float512Vector.Float512Shuffle::new, Float512Vector.Float512Shuffle::new); 1971 1972 /** Species representing {@link FloatVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */ 1973 public static final VectorSpecies<Float> SPECIES_MAX = new FloatSpecies(VectorShape.S_Max_BIT, FloatMaxVector.class, FloatMaxVector.FloatMaxMask.class, 1974 FloatMaxVector::new, FloatMaxVector.FloatMaxMask::new, 1975 FloatMaxVector.FloatMaxShuffle::new, FloatMaxVector.FloatMaxShuffle::new); 1976 1977 /** 1978 * Preferred species for {@link FloatVector}s. 1979 * A preferred species is a species of maximal bit size for the platform. 1980 */ 1981 public static final VectorSpecies<Float> SPECIES_PREFERRED = (VectorSpecies<Float>) preferredSpecies(); 1982 }