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 #if[!byte] 29 import java.nio.$Type$Buffer; 30 #end[!byte] 31 import java.nio.ByteOrder; 32 import java.util.Objects; 33 import java.util.function.IntUnaryOperator; 34 import java.util.function.Function; 35 import java.util.concurrent.ThreadLocalRandom; 36 37 import jdk.internal.misc.Unsafe; 38 import jdk.internal.vm.annotation.ForceInline; 39 import static jdk.incubator.vector.VectorIntrinsics.*; 40 41 42 /** 43 * A specialized {@link Vector} representing an ordered immutable sequence of 44 * {@code $type$} values. 45 */ 46 @SuppressWarnings("cast") 47 public abstract class $abstractvectortype$ extends Vector<$Boxtype$> { 48 49 $abstractvectortype$() {} 50 51 private static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_$TYPE$_INDEX_SCALE); 52 53 // Unary operator 54 55 interface FUnOp { 56 $type$ apply(int i, $type$ a); 57 } 58 59 abstract $abstractvectortype$ uOp(FUnOp f); 60 61 abstract $abstractvectortype$ uOp(VectorMask<$Boxtype$> m, FUnOp f); 62 63 // Binary operator 64 65 interface FBinOp { 66 $type$ apply(int i, $type$ a, $type$ b); 67 } 68 69 abstract $abstractvectortype$ bOp(Vector<$Boxtype$> v, FBinOp f); 70 71 abstract $abstractvectortype$ bOp(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m, FBinOp f); 72 73 // Trinary operator 74 75 interface FTriOp { 76 $type$ apply(int i, $type$ a, $type$ b, $type$ c); 77 } 78 79 abstract $abstractvectortype$ tOp(Vector<$Boxtype$> v1, Vector<$Boxtype$> v2, FTriOp f); 80 81 abstract $abstractvectortype$ tOp(Vector<$Boxtype$> v1, Vector<$Boxtype$> v2, VectorMask<$Boxtype$> m, FTriOp f); 82 83 // Reduction operator 84 85 abstract $type$ rOp($type$ v, FBinOp f); 86 87 // Binary test 88 89 interface FBinTest { 90 boolean apply(int i, $type$ a, $type$ b); 91 } 92 93 abstract VectorMask<$Boxtype$> bTest(Vector<$Boxtype$> v, FBinTest f); 94 95 // Foreach 96 97 interface FUnCon { 98 void apply(int i, $type$ a); 99 } 100 101 abstract void forEach(FUnCon f); 102 103 abstract void forEach(VectorMask<$Boxtype$> m, FUnCon f); 104 105 // Static factories 106 107 /** 108 * Returns a vector where all lane elements are set to the default 109 * primitive value. 110 * 111 * @param species species of desired vector 112 * @return a zero vector of given species 113 */ 114 @ForceInline 115 @SuppressWarnings("unchecked") 116 public static $abstractvectortype$ zero(VectorSpecies<$Boxtype$> species) { 117 #if[FP] 118 return VectorIntrinsics.broadcastCoerced((Class<$Type$Vector>) species.vectorType(), $type$.class, species.length(), 119 $Type$.$type$To$Bitstype$Bits(0.0f), species, 120 ((bits, s) -> (($Type$Species)s).op(i -> $Type$.$bitstype$BitsTo$Type$(($bitstype$)bits)))); 121 #else[FP] 122 return VectorIntrinsics.broadcastCoerced((Class<$Type$Vector>) species.vectorType(), $type$.class, species.length(), 123 0, species, 124 ((bits, s) -> (($Type$Species)s).op(i -> ($type$)bits))); 125 #end[FP] 126 } 127 128 /** 129 * Loads a vector from a byte array starting at an offset. 130 * <p> 131 * Bytes are composed into primitive lane elements according to the 132 * native byte order of the underlying platform 133 * <p> 134 * This method behaves as if it returns the result of calling the 135 * byte buffer, offset, and mask accepting 136 * {@link #fromByteBuffer(VectorSpecies, ByteBuffer, int, VectorMask) method} as follows: 137 * <pre>{@code 138 * return fromByteBuffer(species, ByteBuffer.wrap(a), offset, VectorMask.allTrue()); 139 * }</pre> 140 * 141 * @param species species of desired vector 142 * @param a the byte array 143 * @param offset the offset into the array 144 * @return a vector loaded from a byte array 145 * @throws IndexOutOfBoundsException if {@code i < 0} or 146 * {@code offset > a.length - (species.length() * species.elementSize() / Byte.SIZE)} 147 */ 148 @ForceInline 149 @SuppressWarnings("unchecked") 150 public static $abstractvectortype$ fromByteArray(VectorSpecies<$Boxtype$> species, byte[] a, int offset) { 151 Objects.requireNonNull(a); 152 offset = VectorIntrinsics.checkIndex(offset, a.length, species.bitSize() / Byte.SIZE); 153 return VectorIntrinsics.load((Class<$abstractvectortype$>) species.vectorType(), $type$.class, species.length(), 154 a, ((long) offset) + Unsafe.ARRAY_BYTE_BASE_OFFSET, 155 a, offset, species, 156 (c, idx, s) -> { 157 ByteBuffer bbc = ByteBuffer.wrap(c, idx, a.length - idx).order(ByteOrder.nativeOrder()); 158 $Type$Buffer tb = bbc{#if[byte]?;:.as$Type$Buffer();} 159 return (($Type$Species)s).op(i -> tb.get()); 160 }); 161 } 162 163 /** 164 * Loads a vector from a byte array starting at an offset and using a 165 * mask. 166 * <p> 167 * Bytes are composed into primitive lane elements according to the 168 * native byte order of the underlying platform. 169 * <p> 170 * This method behaves as if it returns the result of calling the 171 * byte buffer, offset, and mask accepting 172 * {@link #fromByteBuffer(VectorSpecies, ByteBuffer, int, VectorMask) method} as follows: 173 * <pre>{@code 174 * return fromByteBuffer(species, ByteBuffer.wrap(a), offset, m); 175 * }</pre> 176 * 177 * @param species species of desired vector 178 * @param a the byte array 179 * @param offset the offset into the array 180 * @param m the mask 181 * @return a vector loaded from a byte array 182 * @throws IndexOutOfBoundsException if {@code offset < 0} or 183 * for any vector lane index {@code N} where the mask at lane {@code N} 184 * is set 185 * {@code offset >= a.length - (N * species.elementSize() / Byte.SIZE)} 186 */ 187 @ForceInline 188 public static $abstractvectortype$ fromByteArray(VectorSpecies<$Boxtype$> species, byte[] a, int offset, VectorMask<$Boxtype$> m) { 189 return zero(species).blend(fromByteArray(species, a, offset), m); 190 } 191 192 /** 193 * Loads a vector from an array starting at offset. 194 * <p> 195 * For each vector lane, where {@code N} is the vector lane index, the 196 * array element at index {@code offset + N} is placed into the 197 * resulting vector at lane index {@code N}. 198 * 199 * @param species species of desired vector 200 * @param a the array 201 * @param offset the offset into the array 202 * @return the vector loaded from an array 203 * @throws IndexOutOfBoundsException if {@code offset < 0}, or 204 * {@code offset > a.length - species.length()} 205 */ 206 @ForceInline 207 @SuppressWarnings("unchecked") 208 public static $abstractvectortype$ fromArray(VectorSpecies<$Boxtype$> species, $type$[] a, int offset){ 209 Objects.requireNonNull(a); 210 offset = VectorIntrinsics.checkIndex(offset, a.length, species.length()); 211 return VectorIntrinsics.load((Class<$abstractvectortype$>) species.vectorType(), $type$.class, species.length(), 212 a, (((long) offset) << ARRAY_SHIFT) + Unsafe.ARRAY_$TYPE$_BASE_OFFSET, 213 a, offset, species, 214 (c, idx, s) -> (($Type$Species)s).op(n -> c[idx + n])); 215 } 216 217 218 /** 219 * Loads a vector from an array starting at offset and using a mask. 220 * <p> 221 * For each vector lane, where {@code N} is the vector lane index, 222 * if the mask lane at index {@code N} is set then the array element at 223 * index {@code offset + N} is placed into the resulting vector at lane index 224 * {@code N}, otherwise the default element value is placed into the 225 * resulting vector at lane index {@code N}. 226 * 227 * @param species species of desired vector 228 * @param a the array 229 * @param offset the offset into the array 230 * @param m the mask 231 * @return the vector loaded from an array 232 * @throws IndexOutOfBoundsException if {@code offset < 0}, or 233 * for any vector lane index {@code N} where the mask at lane {@code N} 234 * is set {@code offset > a.length - N} 235 */ 236 @ForceInline 237 public static $abstractvectortype$ fromArray(VectorSpecies<$Boxtype$> species, $type$[] a, int offset, VectorMask<$Boxtype$> m) { 238 return zero(species).blend(fromArray(species, a, offset), m); 239 } 240 241 /** 242 * Loads a vector from an array using indexes obtained from an index 243 * map. 244 * <p> 245 * For each vector lane, where {@code N} is the vector lane index, the 246 * array element at index {@code a_offset + indexMap[i_offset + N]} is placed into the 247 * resulting vector at lane index {@code N}. 248 * 249 * @param species species of desired vector 250 * @param a the array 251 * @param a_offset the offset into the array, may be negative if relative 252 * indexes in the index map compensate to produce a value within the 253 * array bounds 254 * @param indexMap the index map 255 * @param i_offset the offset into the index map 256 * @return the vector loaded from an array 257 * @throws IndexOutOfBoundsException if {@code i_offset < 0}, or 258 * {@code i_offset > indexMap.length - species.length()}, 259 * or for any vector lane index {@code N} the result of 260 * {@code a_offset + indexMap[i_offset + N]} is {@code < 0} or {@code >= a.length} 261 */ 262 #if[byteOrShort] 263 public static $abstractvectortype$ fromArray(VectorSpecies<$Boxtype$> species, $type$[] a, int a_offset, int[] indexMap, int i_offset) { 264 return (($Type$Species)species).op(n -> a[a_offset + indexMap[i_offset + n]]); 265 } 266 #else[byteOrShort] 267 @ForceInline 268 @SuppressWarnings("unchecked") 269 public static $abstractvectortype$ fromArray(VectorSpecies<$Boxtype$> species, $type$[] a, int a_offset, int[] indexMap, int i_offset) { 270 Objects.requireNonNull(a); 271 Objects.requireNonNull(indexMap); 272 273 #if[longOrDouble] 274 if (species.length() == 1) { 275 return $abstractvectortype$.fromArray(species, a, a_offset + indexMap[i_offset]); 276 } 277 #end[longOrDouble] 278 279 // Index vector: vix[0:n] = k -> a_offset + indexMap[i_offset + k] 280 IntVector vix = IntVector.fromArray(IntVector.species(species.indexShape()), indexMap, i_offset).add(a_offset); 281 282 vix = VectorIntrinsics.checkIndex(vix, a.length); 283 284 return VectorIntrinsics.loadWithMap((Class<$abstractvectortype$>) species.vectorType(), $type$.class, species.length(), 285 IntVector.species(species.indexShape()).vectorType(), a, Unsafe.ARRAY_$TYPE$_BASE_OFFSET, vix, 286 a, a_offset, indexMap, i_offset, species, 287 ($type$[] c, int idx, int[] iMap, int idy, VectorSpecies<$Boxtype$> s) -> 288 (($Type$Species)s).op(n -> c[idx + iMap[idy+n]])); 289 } 290 291 #end[byteOrShort] 292 /** 293 * Loads a vector from an array using indexes obtained from an index 294 * map and using a mask. 295 * <p> 296 * For each vector lane, where {@code N} is the vector lane index, 297 * if the mask lane at index {@code N} is set then the array element at 298 * index {@code a_offset + indexMap[i_offset + N]} is placed into the resulting vector 299 * at lane index {@code N}. 300 * 301 * @param species species of desired vector 302 * @param a the array 303 * @param a_offset the offset into the array, may be negative if relative 304 * indexes in the index map compensate to produce a value within the 305 * array bounds 306 * @param m the mask 307 * @param indexMap the index map 308 * @param i_offset the offset into the index map 309 * @return the vector loaded from an array 310 * @throws IndexOutOfBoundsException if {@code i_offset < 0}, or 311 * {@code i_offset > indexMap.length - species.length()}, 312 * or for any vector lane index {@code N} where the mask at lane 313 * {@code N} is set the result of {@code a_offset + indexMap[i_offset + N]} is 314 * {@code < 0} or {@code >= a.length} 315 */ 316 #if[byteOrShort] 317 public static $abstractvectortype$ fromArray(VectorSpecies<$Boxtype$> species, $type$[] a, int a_offset, VectorMask<$Boxtype$> m, int[] indexMap, int i_offset) { 318 return (($Type$Species)species).op(m, n -> a[a_offset + indexMap[i_offset + n]]); 319 } 320 #else[byteOrShort] 321 @ForceInline 322 @SuppressWarnings("unchecked") 323 public static $abstractvectortype$ fromArray(VectorSpecies<$Boxtype$> species, $type$[] a, int a_offset, VectorMask<$Boxtype$> m, int[] indexMap, int i_offset) { 324 // @@@ This can result in out of bounds errors for unset mask lanes 325 return zero(species).blend(fromArray(species, a, a_offset, indexMap, i_offset), m); 326 } 327 328 #end[byteOrShort] 329 330 /** 331 * Loads a vector from a {@link ByteBuffer byte buffer} starting at an 332 * offset into the byte buffer. 333 * <p> 334 * Bytes are composed into primitive lane elements according to the 335 * native byte order of the underlying platform. 336 * <p> 337 * This method behaves as if it returns the result of calling the 338 * byte buffer, offset, and mask accepting 339 * {@link #fromByteBuffer(VectorSpecies, ByteBuffer, int, VectorMask)} method} as follows: 340 * <pre>{@code 341 * return fromByteBuffer(b, offset, VectorMask.allTrue()) 342 * }</pre> 343 * 344 * @param species species of desired vector 345 * @param bb the byte buffer 346 * @param offset the offset into the byte buffer 347 * @return a vector loaded from a byte buffer 348 * @throws IndexOutOfBoundsException if the offset is {@code < 0}, 349 * or {@code > b.limit()}, 350 * or if there are fewer than 351 * {@code species.length() * species.elementSize() / Byte.SIZE} bytes 352 * remaining in the byte buffer from the given offset 353 */ 354 @ForceInline 355 @SuppressWarnings("unchecked") 356 public static $abstractvectortype$ fromByteBuffer(VectorSpecies<$Boxtype$> species, ByteBuffer bb, int offset) { 357 if (bb.order() != ByteOrder.nativeOrder()) { 358 throw new IllegalArgumentException(); 359 } 360 offset = VectorIntrinsics.checkIndex(offset, bb.limit(), species.bitSize() / Byte.SIZE); 361 return VectorIntrinsics.load((Class<$abstractvectortype$>) species.vectorType(), $type$.class, species.length(), 362 U.getReference(bb, BYTE_BUFFER_HB), U.getLong(bb, BUFFER_ADDRESS) + offset, 363 bb, offset, species, 364 (c, idx, s) -> { 365 ByteBuffer bbc = c.duplicate().position(idx).order(ByteOrder.nativeOrder()); 366 $Type$Buffer tb = bbc{#if[byte]?;:.as$Type$Buffer();} 367 return (($Type$Species)s).op(i -> tb.get()); 368 }); 369 } 370 371 /** 372 * Loads a vector from a {@link ByteBuffer byte buffer} starting at an 373 * offset into the byte buffer and using a mask. 374 * <p> 375 * This method behaves as if the byte buffer is viewed as a primitive 376 * {@link java.nio.Buffer buffer} for the primitive element type, 377 * according to the native byte order of the underlying platform, and 378 * the returned vector is loaded with a mask from a primitive array 379 * obtained from the primitive buffer. 380 * The following pseudocode expresses the behaviour, where 381 * {@code EBuffer} is the primitive buffer type, {@code e} is the 382 * primitive element type, and {@code ESpecies} is the primitive 383 * species for {@code e}: 384 * <pre>{@code 385 * EBuffer eb = b.duplicate(). 386 * order(ByteOrder.nativeOrder()).position(offset). 387 * asEBuffer(); 388 * e[] es = new e[species.length()]; 389 * for (int n = 0; n < t.length; n++) { 390 * if (m.isSet(n)) 391 * es[n] = eb.get(n); 392 * } 393 * EVector r = EVector.fromArray(es, 0, m); 394 * }</pre> 395 * 396 * @param species species of desired vector 397 * @param bb the byte buffer 398 * @param offset the offset into the byte buffer 399 * @param m the mask 400 * @return a vector loaded from a byte buffer 401 * @throws IndexOutOfBoundsException if the offset is {@code < 0}, 402 * or {@code > b.limit()}, 403 * for any vector lane index {@code N} where the mask at lane {@code N} 404 * is set 405 * {@code offset >= b.limit() - (N * species.elementSize() / Byte.SIZE)} 406 */ 407 @ForceInline 408 public static $abstractvectortype$ fromByteBuffer(VectorSpecies<$Boxtype$> species, ByteBuffer bb, int offset, VectorMask<$Boxtype$> m) { 409 return zero(species).blend(fromByteBuffer(species, bb, offset), m); 410 } 411 412 /** 413 * Returns a vector where all lane elements are set to the primitive 414 * value {@code e}. 415 * 416 * @param species species of the desired vector 417 * @param e the value to be broadcasted 418 * @return a vector of vector where all lane elements are set to 419 * the primitive value {@code e} 420 */ 421 #if[FP] 422 @ForceInline 423 @SuppressWarnings("unchecked") 424 public static $abstractvectortype$ broadcast(VectorSpecies<$Boxtype$> species, $type$ e) { 425 return VectorIntrinsics.broadcastCoerced( 426 (Class<$abstractvectortype$>) species.vectorType(), $type$.class, species.length(), 427 $Type$.$type$To$Bitstype$Bits(e), species, 428 ((bits, sp) -> (($Type$Species)sp).op(i -> $Type$.$bitstype$BitsTo$Type$(($bitstype$)bits)))); 429 } 430 #else[FP] 431 @ForceInline 432 @SuppressWarnings("unchecked") 433 public static $abstractvectortype$ broadcast(VectorSpecies<$Boxtype$> species, $type$ e) { 434 return VectorIntrinsics.broadcastCoerced( 435 (Class<$abstractvectortype$>) species.vectorType(), $type$.class, species.length(), 436 e, species, 437 ((bits, sp) -> (($Type$Species)sp).op(i -> ($type$)bits))); 438 } 439 #end[FP] 440 441 /** 442 * Returns a vector where each lane element is set to given 443 * primitive values. 444 * <p> 445 * For each vector lane, where {@code N} is the vector lane index, the 446 * the primitive value at index {@code N} is placed into the resulting 447 * vector at lane index {@code N}. 448 * 449 * @param species species of the desired vector 450 * @param es the given primitive values 451 * @return a vector where each lane element is set to given primitive 452 * values 453 * @throws IndexOutOfBoundsException if {@code es.length < species.length()} 454 */ 455 @ForceInline 456 @SuppressWarnings("unchecked") 457 public static $abstractvectortype$ scalars(VectorSpecies<$Boxtype$> species, $type$... es) { 458 Objects.requireNonNull(es); 459 int ix = VectorIntrinsics.checkIndex(0, es.length, species.length()); 460 return VectorIntrinsics.load((Class<$abstractvectortype$>) species.vectorType(), $type$.class, species.length(), 461 es, Unsafe.ARRAY_$TYPE$_BASE_OFFSET, 462 es, ix, species, 463 (c, idx, sp) -> (($Type$Species)sp).op(n -> c[idx + n])); 464 } 465 466 /** 467 * Returns a vector where the first lane element is set to the primtive 468 * value {@code e}, all other lane elements are set to the default 469 * value. 470 * 471 * @param species species of the desired vector 472 * @param e the value 473 * @return a vector where the first lane element is set to the primitive 474 * value {@code e} 475 */ 476 @ForceInline 477 public static final $abstractvectortype$ single(VectorSpecies<$Boxtype$> species, $type$ e) { 478 return zero(species).with(0, e); 479 } 480 481 /** 482 * Returns a vector where each lane element is set to a randomly 483 * generated primitive value. 484 * 485 * The semantics are equivalent to calling 486 #if[byteOrShort] 487 * ($type$){@link ThreadLocalRandom#nextInt()} 488 #else[byteOrShort] 489 * {@link ThreadLocalRandom#next$Type$()} 490 #end[byteOrShort] 491 * 492 * @param species species of the desired vector 493 * @return a vector where each lane elements is set to a randomly 494 * generated primitive value 495 */ 496 #if[intOrLong] 497 public static $abstractvectortype$ random(VectorSpecies<$Boxtype$> species) { 498 ThreadLocalRandom r = ThreadLocalRandom.current(); 499 return (($Type$Species)species).op(i -> r.next$Type$()); 500 } 501 #else[intOrLong] 502 #if[FP] 503 public static $abstractvectortype$ random(VectorSpecies<$Boxtype$> species) { 504 ThreadLocalRandom r = ThreadLocalRandom.current(); 505 return (($Type$Species)species).op(i -> r.next$Type$()); 506 } 507 #else[FP] 508 public static $abstractvectortype$ random(VectorSpecies<$Boxtype$> species) { 509 ThreadLocalRandom r = ThreadLocalRandom.current(); 510 return (($Type$Species)species).op(i -> ($type$) r.nextInt()); 511 } 512 #end[FP] 513 #end[intOrLong] 514 515 // Ops 516 517 /** 518 * {@inheritDoc} 519 */ 520 @Override 521 public abstract $abstractvectortype$ add(Vector<$Boxtype$> v); 522 523 /** 524 * Adds this vector to the broadcast of an input scalar. 525 * <p> 526 * This is a lane-wise binary operation which applies the primitive addition operation 527 * ({@code +}) to each lane. 528 * 529 * @param s the input scalar 530 * @return the result of adding this vector to the broadcast of an input 531 * scalar 532 */ 533 public abstract $abstractvectortype$ add($type$ s); 534 535 /** 536 * {@inheritDoc} 537 */ 538 @Override 539 public abstract $abstractvectortype$ add(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m); 540 541 /** 542 * Adds this vector to broadcast of an input scalar, 543 * selecting lane elements controlled by a mask. 544 * <p> 545 * This is a lane-wise binary operation which applies the primitive addition operation 546 * ({@code +}) to each lane. 547 * 548 * @param s the input scalar 549 * @param m the mask controlling lane selection 550 * @return the result of adding this vector to the broadcast of an input 551 * scalar 552 */ 553 public abstract $abstractvectortype$ add($type$ s, VectorMask<$Boxtype$> m); 554 555 /** 556 * {@inheritDoc} 557 */ 558 @Override 559 public abstract $abstractvectortype$ sub(Vector<$Boxtype$> v); 560 561 /** 562 * Subtracts the broadcast of an input scalar from this vector. 563 * <p> 564 * This is a lane-wise binary operation which applies the primitive subtraction 565 * operation ({@code -}) to each lane. 566 * 567 * @param s the input scalar 568 * @return the result of subtracting the broadcast of an input 569 * scalar from this vector 570 */ 571 public abstract $abstractvectortype$ sub($type$ s); 572 573 /** 574 * {@inheritDoc} 575 */ 576 @Override 577 public abstract $abstractvectortype$ sub(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m); 578 579 /** 580 * Subtracts the broadcast of an input scalar from this vector, selecting 581 * lane elements controlled by a mask. 582 * <p> 583 * This is a lane-wise binary operation which applies the primitive subtraction 584 * operation ({@code -}) to each lane. 585 * 586 * @param s the input scalar 587 * @param m the mask controlling lane selection 588 * @return the result of subtracting the broadcast of an input 589 * scalar from this vector 590 */ 591 public abstract $abstractvectortype$ sub($type$ s, VectorMask<$Boxtype$> m); 592 593 /** 594 * {@inheritDoc} 595 */ 596 @Override 597 public abstract $abstractvectortype$ mul(Vector<$Boxtype$> v); 598 599 /** 600 * Multiplies this vector with the broadcast of an input scalar. 601 * <p> 602 * This is a lane-wise binary operation which applies the primitive multiplication 603 * operation ({@code *}) to each lane. 604 * 605 * @param s the input scalar 606 * @return the result of multiplying this vector with the broadcast of an 607 * input scalar 608 */ 609 public abstract $abstractvectortype$ mul($type$ s); 610 611 /** 612 * {@inheritDoc} 613 */ 614 @Override 615 public abstract $abstractvectortype$ mul(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m); 616 617 /** 618 * Multiplies this vector with the broadcast of an input scalar, selecting 619 * lane elements controlled by a mask. 620 * <p> 621 * This is a lane-wise binary operation which applies the primitive multiplication 622 * operation ({@code *}) to each lane. 623 * 624 * @param s the input scalar 625 * @param m the mask controlling lane selection 626 * @return the result of multiplying this vector with the broadcast of an 627 * input scalar 628 */ 629 public abstract $abstractvectortype$ mul($type$ s, VectorMask<$Boxtype$> m); 630 631 /** 632 * {@inheritDoc} 633 */ 634 @Override 635 public abstract $abstractvectortype$ neg(); 636 637 /** 638 * {@inheritDoc} 639 */ 640 @Override 641 public abstract $abstractvectortype$ neg(VectorMask<$Boxtype$> m); 642 643 /** 644 * {@inheritDoc} 645 */ 646 @Override 647 public abstract $abstractvectortype$ abs(); 648 649 /** 650 * {@inheritDoc} 651 */ 652 @Override 653 public abstract $abstractvectortype$ abs(VectorMask<$Boxtype$> m); 654 655 /** 656 * {@inheritDoc} 657 */ 658 @Override 659 public abstract $abstractvectortype$ min(Vector<$Boxtype$> v); 660 661 /** 662 * {@inheritDoc} 663 */ 664 @Override 665 public abstract $abstractvectortype$ min(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m); 666 667 /** 668 * Returns the minimum of this vector and the broadcast of an input scalar. 669 * <p> 670 * This is a lane-wise binary operation which applies the operation 671 * {@code (a, b) -> Math.min(a, b)} to each lane. 672 * 673 * @param s the input scalar 674 * @return the minimum of this vector and the broadcast of an input scalar 675 */ 676 public abstract $abstractvectortype$ min($type$ s); 677 678 /** 679 * {@inheritDoc} 680 */ 681 @Override 682 public abstract $abstractvectortype$ max(Vector<$Boxtype$> v); 683 684 /** 685 * {@inheritDoc} 686 */ 687 @Override 688 public abstract $abstractvectortype$ max(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m); 689 690 /** 691 * Returns the maximum of this vector and the broadcast of an input scalar. 692 * <p> 693 * This is a lane-wise binary operation which applies the operation 694 * {@code (a, b) -> Math.max(a, b)} to each lane. 695 * 696 * @param s the input scalar 697 * @return the maximum of this vector and the broadcast of an input scalar 698 */ 699 public abstract $abstractvectortype$ max($type$ s); 700 701 /** 702 * {@inheritDoc} 703 */ 704 @Override 705 public abstract VectorMask<$Boxtype$> equal(Vector<$Boxtype$> v); 706 707 /** 708 * Tests if this vector is equal to the broadcast of an input scalar. 709 * <p> 710 * This is a lane-wise binary test operation which applies the primitive equals 711 * operation ({@code ==}) each lane. 712 * 713 * @param s the input scalar 714 * @return the result mask of testing if this vector is equal to the 715 * broadcast of an input scalar 716 */ 717 public abstract VectorMask<$Boxtype$> equal($type$ s); 718 719 /** 720 * {@inheritDoc} 721 */ 722 @Override 723 public abstract VectorMask<$Boxtype$> notEqual(Vector<$Boxtype$> v); 724 725 /** 726 * Tests if this vector is not equal to the broadcast of an input scalar. 727 * <p> 728 * This is a lane-wise binary test operation which applies the primitive not equals 729 * operation ({@code !=}) to each lane. 730 * 731 * @param s the input scalar 732 * @return the result mask of testing if this vector is not equal to the 733 * broadcast of an input scalar 734 */ 735 public abstract VectorMask<$Boxtype$> notEqual($type$ s); 736 737 /** 738 * {@inheritDoc} 739 */ 740 @Override 741 public abstract VectorMask<$Boxtype$> lessThan(Vector<$Boxtype$> v); 742 743 /** 744 * Tests if this vector is less than the broadcast of an input scalar. 745 * <p> 746 * This is a lane-wise binary test operation which applies the primitive less than 747 * operation ({@code <}) to each lane. 748 * 749 * @param s the input scalar 750 * @return the mask result of testing if this vector is less than the 751 * broadcast of an input scalar 752 */ 753 public abstract VectorMask<$Boxtype$> lessThan($type$ s); 754 755 /** 756 * {@inheritDoc} 757 */ 758 @Override 759 public abstract VectorMask<$Boxtype$> lessThanEq(Vector<$Boxtype$> v); 760 761 /** 762 * Tests if this vector is less or equal to the broadcast of an input scalar. 763 * <p> 764 * This is a lane-wise binary test operation which applies the primitive less than 765 * or equal to operation ({@code <=}) to each lane. 766 * 767 * @param s the input scalar 768 * @return the mask result of testing if this vector is less than or equal 769 * to the broadcast of an input scalar 770 */ 771 public abstract VectorMask<$Boxtype$> lessThanEq($type$ s); 772 773 /** 774 * {@inheritDoc} 775 */ 776 @Override 777 public abstract VectorMask<$Boxtype$> greaterThan(Vector<$Boxtype$> v); 778 779 /** 780 * Tests if this vector is greater than the broadcast of an input scalar. 781 * <p> 782 * This is a lane-wise binary test operation which applies the primitive greater than 783 * operation ({@code >}) to each lane. 784 * 785 * @param s the input scalar 786 * @return the mask result of testing if this vector is greater than the 787 * broadcast of an input scalar 788 */ 789 public abstract VectorMask<$Boxtype$> greaterThan($type$ s); 790 791 /** 792 * {@inheritDoc} 793 */ 794 @Override 795 public abstract VectorMask<$Boxtype$> greaterThanEq(Vector<$Boxtype$> v); 796 797 /** 798 * Tests if this vector is greater than or equal to the broadcast of an 799 * input scalar. 800 * <p> 801 * This is a lane-wise binary test operation which applies the primitive greater than 802 * or equal to operation ({@code >=}) to each lane. 803 * 804 * @param s the input scalar 805 * @return the mask result of testing if this vector is greater than or 806 * equal to the broadcast of an input scalar 807 */ 808 public abstract VectorMask<$Boxtype$> greaterThanEq($type$ s); 809 810 /** 811 * {@inheritDoc} 812 */ 813 @Override 814 public abstract $abstractvectortype$ blend(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m); 815 816 /** 817 * Blends the lane elements of this vector with those of the broadcast of an 818 * input scalar, selecting lanes controlled by a mask. 819 * <p> 820 * For each lane of the mask, at lane index {@code N}, if the mask lane 821 * is set then the lane element at {@code N} from the input vector is 822 * selected and placed into the resulting vector at {@code N}, 823 * otherwise the the lane element at {@code N} from this input vector is 824 * selected and placed into the resulting vector at {@code N}. 825 * 826 * @param s the input scalar 827 * @param m the mask controlling lane selection 828 * @return the result of blending the lane elements of this vector with 829 * those of the broadcast of an input scalar 830 */ 831 public abstract $abstractvectortype$ blend($type$ s, VectorMask<$Boxtype$> m); 832 833 /** 834 * {@inheritDoc} 835 */ 836 @Override 837 public abstract $abstractvectortype$ rearrange(Vector<$Boxtype$> v, 838 VectorShuffle<$Boxtype$> s, VectorMask<$Boxtype$> m); 839 840 /** 841 * {@inheritDoc} 842 */ 843 @Override 844 public abstract $abstractvectortype$ rearrange(VectorShuffle<$Boxtype$> m); 845 846 /** 847 * {@inheritDoc} 848 */ 849 @Override 850 public abstract $abstractvectortype$ reshape(VectorSpecies<$Boxtype$> s); 851 852 /** 853 * {@inheritDoc} 854 */ 855 @Override 856 public abstract $abstractvectortype$ rotateLanesLeft(int i); 857 858 /** 859 * {@inheritDoc} 860 */ 861 @Override 862 public abstract $abstractvectortype$ rotateLanesRight(int i); 863 864 /** 865 * {@inheritDoc} 866 */ 867 @Override 868 public abstract $abstractvectortype$ shiftLanesLeft(int i); 869 870 /** 871 * {@inheritDoc} 872 */ 873 @Override 874 public abstract $abstractvectortype$ shiftLanesRight(int i); 875 876 #if[FP] 877 /** 878 * Divides this vector by an input vector. 879 * <p> 880 * This is a lane-wise binary operation which applies the primitive division 881 * operation ({@code /}) to each lane. 882 * 883 * @param v the input vector 884 * @return the result of dividing this vector by the input vector 885 */ 886 public abstract $abstractvectortype$ div(Vector<$Boxtype$> v); 887 888 /** 889 * Divides this vector by the broadcast of an input scalar. 890 * <p> 891 * This is a lane-wise binary operation which applies the primitive division 892 * operation ({@code /}) to each lane. 893 * 894 * @param s the input scalar 895 * @return the result of dividing this vector by the broadcast of an input 896 * scalar 897 */ 898 public abstract $abstractvectortype$ div($type$ s); 899 900 /** 901 * Divides this vector by an input vector, selecting lane elements 902 * controlled by a mask. 903 * <p> 904 * This is a lane-wise binary operation which applies the primitive division 905 * operation ({@code /}) to each lane. 906 * 907 * @param v the input vector 908 * @param m the mask controlling lane selection 909 * @return the result of dividing this vector by the input vector 910 */ 911 public abstract $abstractvectortype$ div(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m); 912 913 /** 914 * Divides this vector by the broadcast of an input scalar, selecting lane 915 * elements controlled by a mask. 916 * <p> 917 * This is a lane-wise binary operation which applies the primitive division 918 * operation ({@code /}) to each lane. 919 * 920 * @param s the input scalar 921 * @param m the mask controlling lane selection 922 * @return the result of dividing this vector by the broadcast of an input 923 * scalar 924 */ 925 public abstract $abstractvectortype$ div($type$ s, VectorMask<$Boxtype$> m); 926 927 /** 928 * Calculates the square root of this vector. 929 * <p> 930 * This is a lane-wise unary operation which applies the {@link Math#sqrt} operation 931 * to each lane. 932 * 933 * @return the square root of this vector 934 */ 935 public abstract $abstractvectortype$ sqrt(); 936 937 /** 938 * Calculates the square root of this vector, selecting lane elements 939 * controlled by a mask. 940 * <p> 941 * This is a lane-wise unary operation which applies the {@link Math#sqrt} operation 942 * to each lane. 943 * 944 * @param m the mask controlling lane selection 945 * @return the square root of this vector 946 */ 947 public $abstractvectortype$ sqrt(VectorMask<$Boxtype$> m) { 948 return uOp(m, (i, a) -> ($type$) Math.sqrt((double) a)); 949 } 950 951 /** 952 * Calculates the trigonometric tangent of this vector. 953 * <p> 954 * This is a lane-wise unary operation with same semantic definition as 955 * {@link Math#tan} operation applied to each lane. 956 * The implementation is not required to return same 957 * results as {@link Math#tan}, but adheres to rounding, monotonicity, 958 * and special case semantics as defined in the {@link Math#tan} 959 * specifications. The computed result will be within 1 ulp of the 960 * exact result. 961 * 962 * @return the tangent of this vector 963 */ 964 public $abstractvectortype$ tan() { 965 return uOp((i, a) -> ($type$) Math.tan((double) a)); 966 } 967 968 /** 969 * Calculates the trigonometric tangent of this vector, selecting lane 970 * elements controlled by a mask. 971 * <p> 972 * Semantics for rounding, monotonicity, and special cases are 973 * described in {@link $abstractvectortype$#tan} 974 * 975 * @param m the mask controlling lane selection 976 * @return the tangent of this vector 977 */ 978 public $abstractvectortype$ tan(VectorMask<$Boxtype$> m) { 979 return uOp(m, (i, a) -> ($type$) Math.tan((double) a)); 980 } 981 982 /** 983 * Calculates the hyperbolic tangent of this vector. 984 * <p> 985 * This is a lane-wise unary operation with same semantic definition as 986 * {@link Math#tanh} operation applied to each lane. 987 * The implementation is not required to return same 988 * results as {@link Math#tanh}, but adheres to rounding, monotonicity, 989 * and special case semantics as defined in the {@link Math#tanh} 990 * specifications. The computed result will be within 2.5 ulps of the 991 * exact result. 992 * 993 * @return the hyperbolic tangent of this vector 994 */ 995 public $abstractvectortype$ tanh() { 996 return uOp((i, a) -> ($type$) Math.tanh((double) a)); 997 } 998 999 /** 1000 * Calculates the hyperbolic tangent of this vector, selecting lane elements 1001 * controlled by a mask. 1002 * <p> 1003 * Semantics for rounding, monotonicity, and special cases are 1004 * described in {@link $abstractvectortype$#tanh} 1005 * 1006 * @param m the mask controlling lane selection 1007 * @return the hyperbolic tangent of this vector 1008 */ 1009 public $abstractvectortype$ tanh(VectorMask<$Boxtype$> m) { 1010 return uOp(m, (i, a) -> ($type$) Math.tanh((double) a)); 1011 } 1012 1013 /** 1014 * Calculates the trigonometric sine of this vector. 1015 * <p> 1016 * This is a lane-wise unary operation with same semantic definition as 1017 * {@link Math#sin} operation applied to each lane. 1018 * The implementation is not required to return same 1019 * results as {@link Math#sin}, but adheres to rounding, monotonicity, 1020 * and special case semantics as defined in the {@link Math#sin} 1021 * specifications. The computed result will be within 1 ulp of the 1022 * exact result. 1023 * 1024 * @return the sine of this vector 1025 */ 1026 public $abstractvectortype$ sin() { 1027 return uOp((i, a) -> ($type$) Math.sin((double) a)); 1028 } 1029 1030 /** 1031 * Calculates the trigonometric sine of this vector, selecting lane elements 1032 * controlled by a mask. 1033 * <p> 1034 * Semantics for rounding, monotonicity, and special cases are 1035 * described in {@link $abstractvectortype$#sin} 1036 * 1037 * @param m the mask controlling lane selection 1038 * @return the sine of this vector 1039 */ 1040 public $abstractvectortype$ sin(VectorMask<$Boxtype$> m) { 1041 return uOp(m, (i, a) -> ($type$) Math.sin((double) a)); 1042 } 1043 1044 /** 1045 * Calculates the hyperbolic sine of this vector. 1046 * <p> 1047 * This is a lane-wise unary operation with same semantic definition as 1048 * {@link Math#sinh} operation applied to each lane. 1049 * The implementation is not required to return same 1050 * results as {@link Math#sinh}, but adheres to rounding, monotonicity, 1051 * and special case semantics as defined in the {@link Math#sinh} 1052 * specifications. The computed result will be within 2.5 ulps of the 1053 * exact result. 1054 * 1055 * @return the hyperbolic sine of this vector 1056 */ 1057 public $abstractvectortype$ sinh() { 1058 return uOp((i, a) -> ($type$) Math.sinh((double) a)); 1059 } 1060 1061 /** 1062 * Calculates the hyperbolic sine of this vector, selecting lane elements 1063 * controlled by a mask. 1064 * <p> 1065 * Semantics for rounding, monotonicity, and special cases are 1066 * described in {@link $abstractvectortype$#sinh} 1067 * 1068 * @param m the mask controlling lane selection 1069 * @return the hyperbolic sine of this vector 1070 */ 1071 public $abstractvectortype$ sinh(VectorMask<$Boxtype$> m) { 1072 return uOp(m, (i, a) -> ($type$) Math.sinh((double) a)); 1073 } 1074 1075 /** 1076 * Calculates the trigonometric cosine of this vector. 1077 * <p> 1078 * This is a lane-wise unary operation with same semantic definition as 1079 * {@link Math#cos} operation applied to each lane. 1080 * The implementation is not required to return same 1081 * results as {@link Math#cos}, but adheres to rounding, monotonicity, 1082 * and special case semantics as defined in the {@link Math#cos} 1083 * specifications. The computed result will be within 1 ulp of the 1084 * exact result. 1085 * 1086 * @return the cosine of this vector 1087 */ 1088 public $abstractvectortype$ cos() { 1089 return uOp((i, a) -> ($type$) Math.cos((double) a)); 1090 } 1091 1092 /** 1093 * Calculates the trigonometric cosine of this vector, selecting lane 1094 * elements controlled by a mask. 1095 * <p> 1096 * Semantics for rounding, monotonicity, and special cases are 1097 * described in {@link $abstractvectortype$#cos} 1098 * 1099 * @param m the mask controlling lane selection 1100 * @return the cosine of this vector 1101 */ 1102 public $abstractvectortype$ cos(VectorMask<$Boxtype$> m) { 1103 return uOp(m, (i, a) -> ($type$) Math.cos((double) a)); 1104 } 1105 1106 /** 1107 * Calculates the hyperbolic cosine of this vector. 1108 * <p> 1109 * This is a lane-wise unary operation with same semantic definition as 1110 * {@link Math#cosh} operation applied to each lane. 1111 * The implementation is not required to return same 1112 * results as {@link Math#cosh}, but adheres to rounding, monotonicity, 1113 * and special case semantics as defined in the {@link Math#cosh} 1114 * specifications. The computed result will be within 2.5 ulps of the 1115 * exact result. 1116 * 1117 * @return the hyperbolic cosine of this vector 1118 */ 1119 public $abstractvectortype$ cosh() { 1120 return uOp((i, a) -> ($type$) Math.cosh((double) a)); 1121 } 1122 1123 /** 1124 * Calculates the hyperbolic cosine of this vector, selecting lane elements 1125 * controlled by a mask. 1126 * <p> 1127 * Semantics for rounding, monotonicity, and special cases are 1128 * described in {@link $abstractvectortype$#cosh} 1129 * 1130 * @param m the mask controlling lane selection 1131 * @return the hyperbolic cosine of this vector 1132 */ 1133 public $abstractvectortype$ cosh(VectorMask<$Boxtype$> m) { 1134 return uOp(m, (i, a) -> ($type$) Math.cosh((double) a)); 1135 } 1136 1137 /** 1138 * Calculates the arc sine of this vector. 1139 * <p> 1140 * This is a lane-wise unary operation with same semantic definition as 1141 * {@link Math#asin} operation applied to each lane. 1142 * The implementation is not required to return same 1143 * results as {@link Math#asin}, but adheres to rounding, monotonicity, 1144 * and special case semantics as defined in the {@link Math#asin} 1145 * specifications. The computed result will be within 1 ulp of the 1146 * exact result. 1147 * 1148 * @return the arc sine of this vector 1149 */ 1150 public $abstractvectortype$ asin() { 1151 return uOp((i, a) -> ($type$) Math.asin((double) a)); 1152 } 1153 1154 /** 1155 * Calculates the arc sine of this vector, selecting lane elements 1156 * controlled by a mask. 1157 * <p> 1158 * Semantics for rounding, monotonicity, and special cases are 1159 * described in {@link $abstractvectortype$#asin} 1160 * 1161 * @param m the mask controlling lane selection 1162 * @return the arc sine of this vector 1163 */ 1164 public $abstractvectortype$ asin(VectorMask<$Boxtype$> m) { 1165 return uOp(m, (i, a) -> ($type$) Math.asin((double) a)); 1166 } 1167 1168 /** 1169 * Calculates the arc cosine of this vector. 1170 * <p> 1171 * This is a lane-wise unary operation with same semantic definition as 1172 * {@link Math#acos} operation applied to each lane. 1173 * The implementation is not required to return same 1174 * results as {@link Math#acos}, but adheres to rounding, monotonicity, 1175 * and special case semantics as defined in the {@link Math#acos} 1176 * specifications. The computed result will be within 1 ulp of the 1177 * exact result. 1178 * 1179 * @return the arc cosine of this vector 1180 */ 1181 public $abstractvectortype$ acos() { 1182 return uOp((i, a) -> ($type$) Math.acos((double) a)); 1183 } 1184 1185 /** 1186 * Calculates the arc cosine of this vector, selecting lane elements 1187 * controlled by a mask. 1188 * <p> 1189 * Semantics for rounding, monotonicity, and special cases are 1190 * described in {@link $abstractvectortype$#acos} 1191 * 1192 * @param m the mask controlling lane selection 1193 * @return the arc cosine of this vector 1194 */ 1195 public $abstractvectortype$ acos(VectorMask<$Boxtype$> m) { 1196 return uOp(m, (i, a) -> ($type$) Math.acos((double) a)); 1197 } 1198 1199 /** 1200 * Calculates the arc tangent of this vector. 1201 * <p> 1202 * This is a lane-wise unary operation with same semantic definition as 1203 * {@link Math#atan} operation applied to each lane. 1204 * The implementation is not required to return same 1205 * results as {@link Math#atan}, but adheres to rounding, monotonicity, 1206 * and special case semantics as defined in the {@link Math#atan} 1207 * specifications. The computed result will be within 1 ulp of the 1208 * exact result. 1209 * 1210 * @return the arc tangent of this vector 1211 */ 1212 public $abstractvectortype$ atan() { 1213 return uOp((i, a) -> ($type$) Math.atan((double) a)); 1214 } 1215 1216 /** 1217 * Calculates the arc tangent of this vector, selecting lane elements 1218 * controlled by a mask. 1219 * <p> 1220 * Semantics for rounding, monotonicity, and special cases are 1221 * described in {@link $abstractvectortype$#atan} 1222 * 1223 * @param m the mask controlling lane selection 1224 * @return the arc tangent of this vector 1225 */ 1226 public $abstractvectortype$ atan(VectorMask<$Boxtype$> m) { 1227 return uOp(m, (i, a) -> ($type$) Math.atan((double) a)); 1228 } 1229 1230 /** 1231 * Calculates the arc tangent of this vector divided by an input vector. 1232 * <p> 1233 * This is a lane-wise binary operation with same semantic definition as 1234 * {@link Math#atan2} operation applied to each lane. 1235 * The implementation is not required to return same 1236 * results as {@link Math#atan2}, but adheres to rounding, monotonicity, 1237 * and special case semantics as defined in the {@link Math#atan2} 1238 * specifications. The computed result will be within 2 ulps of the 1239 * exact result. 1240 * 1241 * @param v the input vector 1242 * @return the arc tangent of this vector divided by the input vector 1243 */ 1244 public $abstractvectortype$ atan2(Vector<$Boxtype$> v) { 1245 return bOp(v, (i, a, b) -> ($type$) Math.atan2((double) a, (double) b)); 1246 } 1247 1248 /** 1249 * Calculates the arc tangent of this vector divided by the broadcast of an 1250 * an input scalar. 1251 * <p> 1252 * This is a lane-wise binary operation with same semantic definition as 1253 * {@link Math#atan2} operation applied to each lane. 1254 * The implementation is not required to return same 1255 * results as {@link Math#atan2}, but adheres to rounding, monotonicity, 1256 * and special case semantics as defined in the {@link Math#atan2} 1257 * specifications. The computed result will be within 1 ulp of the 1258 * exact result. 1259 * 1260 * @param s the input scalar 1261 * @return the arc tangent of this vector over the input vector 1262 */ 1263 public abstract $abstractvectortype$ atan2($type$ s); 1264 1265 /** 1266 * Calculates the arc tangent of this vector divided by an input vector, 1267 * selecting lane elements controlled by a mask. 1268 * <p> 1269 * Semantics for rounding, monotonicity, and special cases are 1270 * described in {@link $abstractvectortype$#atan2} 1271 * 1272 * @param v the input vector 1273 * @param m the mask controlling lane selection 1274 * @return the arc tangent of this vector divided by the input vector 1275 */ 1276 public $abstractvectortype$ atan2(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 1277 return bOp(v, m, (i, a, b) -> ($type$) Math.atan2((double) a, (double) b)); 1278 } 1279 1280 /** 1281 * Calculates the arc tangent of this vector divided by the broadcast of an 1282 * an input scalar, selecting lane elements controlled by a mask. 1283 * <p> 1284 * Semantics for rounding, monotonicity, and special cases are 1285 * described in {@link $abstractvectortype$#atan2} 1286 * 1287 * @param s the input scalar 1288 * @param m the mask controlling lane selection 1289 * @return the arc tangent of this vector over the input vector 1290 */ 1291 public abstract $abstractvectortype$ atan2($type$ s, VectorMask<$Boxtype$> m); 1292 1293 /** 1294 * Calculates the cube root of this vector. 1295 * <p> 1296 * This is a lane-wise unary operation with same semantic definition as 1297 * {@link Math#cbrt} operation applied to each lane. 1298 * The implementation is not required to return same 1299 * results as {@link Math#cbrt}, but adheres to rounding, monotonicity, 1300 * and special case semantics as defined in the {@link Math#cbrt} 1301 * specifications. The computed result will be within 1 ulp of the 1302 * exact result. 1303 * 1304 * @return the cube root of this vector 1305 */ 1306 public $abstractvectortype$ cbrt() { 1307 return uOp((i, a) -> ($type$) Math.cbrt((double) a)); 1308 } 1309 1310 /** 1311 * Calculates the cube root of this vector, selecting lane elements 1312 * controlled by a mask. 1313 * <p> 1314 * Semantics for rounding, monotonicity, and special cases are 1315 * described in {@link $abstractvectortype$#cbrt} 1316 * 1317 * @param m the mask controlling lane selection 1318 * @return the cube root of this vector 1319 */ 1320 public $abstractvectortype$ cbrt(VectorMask<$Boxtype$> m) { 1321 return uOp(m, (i, a) -> ($type$) Math.cbrt((double) a)); 1322 } 1323 1324 /** 1325 * Calculates the natural logarithm of this vector. 1326 * <p> 1327 * This is a lane-wise unary operation with same semantic definition as 1328 * {@link Math#log} operation applied to each lane. 1329 * The implementation is not required to return same 1330 * results as {@link Math#log}, but adheres to rounding, monotonicity, 1331 * and special case semantics as defined in the {@link Math#log} 1332 * specifications. The computed result will be within 1 ulp of the 1333 * exact result. 1334 * 1335 * @return the natural logarithm of this vector 1336 */ 1337 public $abstractvectortype$ log() { 1338 return uOp((i, a) -> ($type$) Math.log((double) a)); 1339 } 1340 1341 /** 1342 * Calculates the natural logarithm of this vector, selecting lane elements 1343 * controlled by a mask. 1344 * <p> 1345 * Semantics for rounding, monotonicity, and special cases are 1346 * described in {@link $abstractvectortype$#log} 1347 * 1348 * @param m the mask controlling lane selection 1349 * @return the natural logarithm of this vector 1350 */ 1351 public $abstractvectortype$ log(VectorMask<$Boxtype$> m) { 1352 return uOp(m, (i, a) -> ($type$) Math.log((double) a)); 1353 } 1354 1355 /** 1356 * Calculates the base 10 logarithm of this vector. 1357 * <p> 1358 * This is a lane-wise unary operation with same semantic definition as 1359 * {@link Math#log10} operation applied to each lane. 1360 * The implementation is not required to return same 1361 * results as {@link Math#log10}, but adheres to rounding, monotonicity, 1362 * and special case semantics as defined in the {@link Math#log10} 1363 * specifications. The computed result will be within 1 ulp of the 1364 * exact result. 1365 * 1366 * @return the base 10 logarithm of this vector 1367 */ 1368 public $abstractvectortype$ log10() { 1369 return uOp((i, a) -> ($type$) Math.log10((double) a)); 1370 } 1371 1372 /** 1373 * Calculates the base 10 logarithm of this vector, selecting lane elements 1374 * controlled by a mask. 1375 * <p> 1376 * Semantics for rounding, monotonicity, and special cases are 1377 * described in {@link $abstractvectortype$#log10} 1378 * 1379 * @param m the mask controlling lane selection 1380 * @return the base 10 logarithm of this vector 1381 */ 1382 public $abstractvectortype$ log10(VectorMask<$Boxtype$> m) { 1383 return uOp(m, (i, a) -> ($type$) Math.log10((double) a)); 1384 } 1385 1386 /** 1387 * Calculates the natural logarithm of the sum of this vector and the 1388 * broadcast of {@code 1}. 1389 * <p> 1390 * This is a lane-wise unary operation with same semantic definition as 1391 * {@link Math#log1p} operation applied to each lane. 1392 * The implementation is not required to return same 1393 * results as {@link Math#log1p}, but adheres to rounding, monotonicity, 1394 * and special case semantics as defined in the {@link Math#log1p} 1395 * specifications. The computed result will be within 1 ulp of the 1396 * exact result. 1397 * 1398 * @return the natural logarithm of the sum of this vector and the broadcast 1399 * of {@code 1} 1400 */ 1401 public $abstractvectortype$ log1p() { 1402 return uOp((i, a) -> ($type$) Math.log1p((double) a)); 1403 } 1404 1405 /** 1406 * Calculates the natural logarithm of the sum of this vector and the 1407 * broadcast of {@code 1}, selecting lane elements controlled by a mask. 1408 * <p> 1409 * Semantics for rounding, monotonicity, and special cases are 1410 * described in {@link $abstractvectortype$#log1p} 1411 * 1412 * @param m the mask controlling lane selection 1413 * @return the natural logarithm of the sum of this vector and the broadcast 1414 * of {@code 1} 1415 */ 1416 public $abstractvectortype$ log1p(VectorMask<$Boxtype$> m) { 1417 return uOp(m, (i, a) -> ($type$) Math.log1p((double) a)); 1418 } 1419 1420 /** 1421 * Calculates this vector raised to the power of an input vector. 1422 * <p> 1423 * This is a lane-wise binary operation with same semantic definition as 1424 * {@link Math#pow} operation applied to each lane. 1425 * The implementation is not required to return same 1426 * results as {@link Math#pow}, but adheres to rounding, monotonicity, 1427 * and special case semantics as defined in the {@link Math#pow} 1428 * specifications. The computed result will be within 1 ulp of the 1429 * exact result. 1430 * 1431 * @param v the input vector 1432 * @return this vector raised to the power of an input vector 1433 */ 1434 public $abstractvectortype$ pow(Vector<$Boxtype$> v) { 1435 return bOp(v, (i, a, b) -> ($type$) Math.pow((double) a, (double) b)); 1436 } 1437 1438 /** 1439 * Calculates this vector raised to the power of the broadcast of an input 1440 * scalar. 1441 * <p> 1442 * This is a lane-wise binary operation with same semantic definition as 1443 * {@link Math#pow} operation applied to each lane. 1444 * The implementation is not required to return same 1445 * results as {@link Math#pow}, but adheres to rounding, monotonicity, 1446 * and special case semantics as defined in the {@link Math#pow} 1447 * specifications. The computed result will be within 1 ulp of the 1448 * exact result. 1449 * 1450 * @param s the input scalar 1451 * @return this vector raised to the power of the broadcast of an input 1452 * scalar. 1453 */ 1454 public abstract $abstractvectortype$ pow($type$ s); 1455 1456 /** 1457 * Calculates this vector raised to the power of an input vector, selecting 1458 * lane elements controlled by a mask. 1459 * <p> 1460 * Semantics for rounding, monotonicity, and special cases are 1461 * described in {@link $abstractvectortype$#pow} 1462 * 1463 * @param v the input vector 1464 * @param m the mask controlling lane selection 1465 * @return this vector raised to the power of an input vector 1466 */ 1467 public $abstractvectortype$ pow(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 1468 return bOp(v, m, (i, a, b) -> ($type$) Math.pow((double) a, (double) b)); 1469 } 1470 1471 /** 1472 * Calculates this vector raised to the power of the broadcast of an input 1473 * scalar, selecting lane elements controlled by a mask. 1474 * <p> 1475 * Semantics for rounding, monotonicity, and special cases are 1476 * described in {@link $abstractvectortype$#pow} 1477 * 1478 * @param s the input scalar 1479 * @param m the mask controlling lane selection 1480 * @return this vector raised to the power of the broadcast of an input 1481 * scalar. 1482 */ 1483 public abstract $abstractvectortype$ pow($type$ s, VectorMask<$Boxtype$> m); 1484 1485 /** 1486 * Calculates the broadcast of Euler's number {@code e} raised to the power 1487 * of this vector. 1488 * <p> 1489 * This is a lane-wise unary operation with same semantic definition as 1490 * {@link Math#exp} operation applied to each lane. 1491 * The implementation is not required to return same 1492 * results as {@link Math#exp}, but adheres to rounding, monotonicity, 1493 * and special case semantics as defined in the {@link Math#exp} 1494 * specifications. The computed result will be within 1 ulp of the 1495 * exact result. 1496 * 1497 * @return the broadcast of Euler's number {@code e} raised to the power of 1498 * this vector 1499 */ 1500 public $abstractvectortype$ exp() { 1501 return uOp((i, a) -> ($type$) Math.exp((double) a)); 1502 } 1503 1504 /** 1505 * Calculates the broadcast of Euler's number {@code e} raised to the power 1506 * of this vector, selecting lane elements controlled by a mask. 1507 * <p> 1508 * Semantics for rounding, monotonicity, and special cases are 1509 * described in {@link $abstractvectortype$#exp} 1510 * 1511 * @param m the mask controlling lane selection 1512 * @return the broadcast of Euler's number {@code e} raised to the power of 1513 * this vector 1514 */ 1515 public $abstractvectortype$ exp(VectorMask<$Boxtype$> m) { 1516 return uOp(m, (i, a) -> ($type$) Math.exp((double) a)); 1517 } 1518 1519 /** 1520 * Calculates the broadcast of Euler's number {@code e} raised to the power 1521 * of this vector minus the broadcast of {@code -1}. 1522 * More specifically as if the following (ignoring any differences in 1523 * numerical accuracy): 1524 * <pre>{@code 1525 * this.exp().sub(EVector.broadcast(this.species(), 1)) 1526 * }</pre> 1527 * <p> 1528 * This is a lane-wise unary operation with same semantic definition as 1529 * {@link Math#expm1} operation applied to each lane. 1530 * The implementation is not required to return same 1531 * results as {@link Math#expm1}, but adheres to rounding, monotonicity, 1532 * and special case semantics as defined in the {@link Math#expm1} 1533 * specifications. The computed result will be within 1 ulp of the 1534 * exact result. 1535 * 1536 * @return the broadcast of Euler's number {@code e} raised to the power of 1537 * this vector minus the broadcast of {@code -1} 1538 */ 1539 public $abstractvectortype$ expm1() { 1540 return uOp((i, a) -> ($type$) Math.expm1((double) a)); 1541 } 1542 1543 /** 1544 * Calculates the broadcast of Euler's number {@code e} raised to the power 1545 * of this vector minus the broadcast of {@code -1}, selecting lane elements 1546 * controlled by a mask 1547 * More specifically as if the following (ignoring any differences in 1548 * numerical accuracy): 1549 * <pre>{@code 1550 * this.exp(m).sub(EVector.broadcast(this.species(), 1), m) 1551 * }</pre> 1552 * <p> 1553 * Semantics for rounding, monotonicity, and special cases are 1554 * described in {@link $abstractvectortype$#expm1} 1555 * 1556 * @param m the mask controlling lane selection 1557 * @return the broadcast of Euler's number {@code e} raised to the power of 1558 * this vector minus the broadcast of {@code -1} 1559 */ 1560 public $abstractvectortype$ expm1(VectorMask<$Boxtype$> m) { 1561 return uOp(m, (i, a) -> ($type$) Math.expm1((double) a)); 1562 } 1563 1564 /** 1565 * Calculates the product of this vector and a first input vector summed 1566 * with a second input vector. 1567 * More specifically as if the following (ignoring any differences in 1568 * numerical accuracy): 1569 * <pre>{@code 1570 * this.mul(v1).add(v2) 1571 * }</pre> 1572 * <p> 1573 * This is a lane-wise ternary operation which applies the {@link Math#fma} operation 1574 * to each lane. 1575 * 1576 * @param v1 the first input vector 1577 * @param v2 the second input vector 1578 * @return the product of this vector and the first input vector summed with 1579 * the second input vector 1580 */ 1581 public abstract $abstractvectortype$ fma(Vector<$Boxtype$> v1, Vector<$Boxtype$> v2); 1582 1583 /** 1584 * Calculates the product of this vector and the broadcast of a first input 1585 * scalar summed with the broadcast of a second input scalar. 1586 * More specifically as if the following: 1587 * <pre>{@code 1588 * this.fma(EVector.broadcast(this.species(), s1), EVector.broadcast(this.species(), s2)) 1589 * }</pre> 1590 * <p> 1591 * This is a lane-wise ternary operation which applies the {@link Math#fma} operation 1592 * to each lane. 1593 * 1594 * @param s1 the first input scalar 1595 * @param s2 the second input scalar 1596 * @return the product of this vector and the broadcast of a first input 1597 * scalar summed with the broadcast of a second input scalar 1598 */ 1599 public abstract $abstractvectortype$ fma($type$ s1, $type$ s2); 1600 1601 /** 1602 * Calculates the product of this vector and a first input vector summed 1603 * with a second input vector, selecting lane elements controlled by a mask. 1604 * More specifically as if the following (ignoring any differences in 1605 * numerical accuracy): 1606 * <pre>{@code 1607 * this.mul(v1, m).add(v2, m) 1608 * }</pre> 1609 * <p> 1610 * This is a lane-wise ternary operation which applies the {@link Math#fma} operation 1611 * to each lane. 1612 * 1613 * @param v1 the first input vector 1614 * @param v2 the second input vector 1615 * @param m the mask controlling lane selection 1616 * @return the product of this vector and the first input vector summed with 1617 * the second input vector 1618 */ 1619 public $abstractvectortype$ fma(Vector<$Boxtype$> v1, Vector<$Boxtype$> v2, VectorMask<$Boxtype$> m) { 1620 return tOp(v1, v2, m, (i, a, b, c) -> Math.fma(a, b, c)); 1621 } 1622 1623 /** 1624 * Calculates the product of this vector and the broadcast of a first input 1625 * scalar summed with the broadcast of a second input scalar, selecting lane 1626 * elements controlled by a mask 1627 * More specifically as if the following: 1628 * <pre>{@code 1629 * this.fma(EVector.broadcast(this.species(), s1), EVector.broadcast(this.species(), s2), m) 1630 * }</pre> 1631 * <p> 1632 * This is a lane-wise ternary operation which applies the {@link Math#fma} operation 1633 * to each lane. 1634 * 1635 * @param s1 the first input scalar 1636 * @param s2 the second input scalar 1637 * @param m the mask controlling lane selection 1638 * @return the product of this vector and the broadcast of a first input 1639 * scalar summed with the broadcast of a second input scalar 1640 */ 1641 public abstract $abstractvectortype$ fma($type$ s1, $type$ s2, VectorMask<$Boxtype$> m); 1642 1643 /** 1644 * Calculates square root of the sum of the squares of this vector and an 1645 * input vector. 1646 * More specifically as if the following (ignoring any differences in 1647 * numerical accuracy): 1648 * <pre>{@code 1649 * this.mul(this).add(v.mul(v)).sqrt() 1650 * }</pre> 1651 * <p> 1652 * This is a lane-wise binary operation with same semantic definition as 1653 * {@link Math#hypot} operation applied to each lane. 1654 * The implementation is not required to return same 1655 * results as {@link Math#hypot}, but adheres to rounding, monotonicity, 1656 * and special case semantics as defined in the {@link Math#hypot} 1657 * specifications. The computed result will be within 1 ulp of the 1658 * exact result. 1659 * 1660 * @param v the input vector 1661 * @return square root of the sum of the squares of this vector and an input 1662 * vector 1663 */ 1664 public $abstractvectortype$ hypot(Vector<$Boxtype$> v) { 1665 return bOp(v, (i, a, b) -> ($type$) Math.hypot((double) a, (double) b)); 1666 } 1667 1668 /** 1669 * Calculates square root of the sum of the squares of this vector and the 1670 * broadcast of an input scalar. 1671 * More specifically as if the following (ignoring any differences in 1672 * numerical accuracy): 1673 * <pre>{@code 1674 * this.mul(this).add(EVector.broadcast(this.species(), s * s)).sqrt() 1675 * }</pre> 1676 * <p> 1677 * This is a lane-wise binary operation with same semantic definition as 1678 * {@link Math#hypot} operation applied to each. 1679 * The implementation is not required to return same 1680 * results as {@link Math#hypot}, but adheres to rounding, monotonicity, 1681 * and special case semantics as defined in the {@link Math#hypot} 1682 * specifications. The computed result will be within 1 ulp of the 1683 * exact result. 1684 * 1685 * @param s the input scalar 1686 * @return square root of the sum of the squares of this vector and the 1687 * broadcast of an input scalar 1688 */ 1689 public abstract $abstractvectortype$ hypot($type$ s); 1690 1691 /** 1692 * Calculates square root of the sum of the squares of this vector and an 1693 * input vector, selecting lane elements controlled by a mask. 1694 * More specifically as if the following (ignoring any differences in 1695 * numerical accuracy): 1696 * <pre>{@code 1697 * this.mul(this, m).add(v.mul(v), m).sqrt(m) 1698 * }</pre> 1699 * <p> 1700 * Semantics for rounding, monotonicity, and special cases are 1701 * described in {@link $abstractvectortype$#hypot} 1702 * 1703 * @param v the input vector 1704 * @param m the mask controlling lane selection 1705 * @return square root of the sum of the squares of this vector and an input 1706 * vector 1707 */ 1708 public $abstractvectortype$ hypot(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 1709 return bOp(v, m, (i, a, b) -> ($type$) Math.hypot((double) a, (double) b)); 1710 } 1711 1712 /** 1713 * Calculates square root of the sum of the squares of this vector and the 1714 * broadcast of an input scalar, selecting lane elements controlled by a 1715 * mask. 1716 * More specifically as if the following (ignoring any differences in 1717 * numerical accuracy): 1718 * <pre>{@code 1719 * this.mul(this, m).add(EVector.broadcast(this.species(), s * s), m).sqrt(m) 1720 * }</pre> 1721 * <p> 1722 * Semantics for rounding, monotonicity, and special cases are 1723 * described in {@link $abstractvectortype$#hypot} 1724 * 1725 * @param s the input scalar 1726 * @param m the mask controlling lane selection 1727 * @return square root of the sum of the squares of this vector and the 1728 * broadcast of an input scalar 1729 */ 1730 public abstract $abstractvectortype$ hypot($type$ s, VectorMask<$Boxtype$> m); 1731 #end[FP] 1732 1733 #if[BITWISE] 1734 1735 /** 1736 * Bitwise ANDs this vector with an input vector. 1737 * <p> 1738 * This is a lane-wise binary operation which applies the primitive bitwise AND 1739 * operation ({@code &}) to each lane. 1740 * 1741 * @param v the input vector 1742 * @return the bitwise AND of this vector with the input vector 1743 */ 1744 public abstract $abstractvectortype$ and(Vector<$Boxtype$> v); 1745 1746 /** 1747 * Bitwise ANDs this vector with the broadcast of an input scalar. 1748 * <p> 1749 * This is a lane-wise binary operation which applies the primitive bitwise AND 1750 * operation ({@code &}) to each lane. 1751 * 1752 * @param s the input scalar 1753 * @return the bitwise AND of this vector with the broadcast of an input 1754 * scalar 1755 */ 1756 public abstract $abstractvectortype$ and($type$ s); 1757 1758 /** 1759 * Bitwise ANDs this vector with an input vector, selecting lane elements 1760 * controlled by a mask. 1761 * <p> 1762 * This is a lane-wise binary operation which applies the primitive bitwise AND 1763 * operation ({@code &}) to each lane. 1764 * 1765 * @param v the input vector 1766 * @param m the mask controlling lane selection 1767 * @return the bitwise AND of this vector with the input vector 1768 */ 1769 public abstract $abstractvectortype$ and(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m); 1770 1771 /** 1772 * Bitwise ANDs this vector with the broadcast of an input scalar, selecting 1773 * lane elements controlled by a mask. 1774 * <p> 1775 * This is a lane-wise binary operation which applies the primitive bitwise AND 1776 * operation ({@code &}) to each lane. 1777 * 1778 * @param s the input scalar 1779 * @param m the mask controlling lane selection 1780 * @return the bitwise AND of this vector with the broadcast of an input 1781 * scalar 1782 */ 1783 public abstract $abstractvectortype$ and($type$ s, VectorMask<$Boxtype$> m); 1784 1785 /** 1786 * Bitwise ORs this vector with an input vector. 1787 * <p> 1788 * This is a lane-wise binary operation which applies the primitive bitwise OR 1789 * operation ({@code |}) to each lane. 1790 * 1791 * @param v the input vector 1792 * @return the bitwise OR of this vector with the input vector 1793 */ 1794 public abstract $abstractvectortype$ or(Vector<$Boxtype$> v); 1795 1796 /** 1797 * Bitwise ORs this vector with the broadcast of an input scalar. 1798 * <p> 1799 * This is a lane-wise binary operation which applies the primitive bitwise OR 1800 * operation ({@code |}) to each lane. 1801 * 1802 * @param s the input scalar 1803 * @return the bitwise OR of this vector with the broadcast of an input 1804 * scalar 1805 */ 1806 public abstract $abstractvectortype$ or($type$ s); 1807 1808 /** 1809 * Bitwise ORs this vector with an input vector, selecting lane elements 1810 * controlled by a mask. 1811 * <p> 1812 * This is a lane-wise binary operation which applies the primitive bitwise OR 1813 * operation ({@code |}) to each lane. 1814 * 1815 * @param v the input vector 1816 * @param m the mask controlling lane selection 1817 * @return the bitwise OR of this vector with the input vector 1818 */ 1819 public abstract $abstractvectortype$ or(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m); 1820 1821 /** 1822 * Bitwise ORs this vector with the broadcast of an input scalar, selecting 1823 * lane elements controlled by a mask. 1824 * <p> 1825 * This is a lane-wise binary operation which applies the primitive bitwise OR 1826 * operation ({@code |}) to each lane. 1827 * 1828 * @param s the input scalar 1829 * @param m the mask controlling lane selection 1830 * @return the bitwise OR of this vector with the broadcast of an input 1831 * scalar 1832 */ 1833 public abstract $abstractvectortype$ or($type$ s, VectorMask<$Boxtype$> m); 1834 1835 /** 1836 * Bitwise XORs this vector with an input vector. 1837 * <p> 1838 * This is a lane-wise binary operation which applies the primitive bitwise XOR 1839 * operation ({@code ^}) to each lane. 1840 * 1841 * @param v the input vector 1842 * @return the bitwise XOR of this vector with the input vector 1843 */ 1844 public abstract $abstractvectortype$ xor(Vector<$Boxtype$> v); 1845 1846 /** 1847 * Bitwise XORs this vector with the broadcast of an input scalar. 1848 * <p> 1849 * This is a lane-wise binary operation which applies the primitive bitwise XOR 1850 * operation ({@code ^}) to each lane. 1851 * 1852 * @param s the input scalar 1853 * @return the bitwise XOR of this vector with the broadcast of an input 1854 * scalar 1855 */ 1856 public abstract $abstractvectortype$ xor($type$ s); 1857 1858 /** 1859 * Bitwise XORs this vector with an input vector, selecting lane elements 1860 * controlled by a mask. 1861 * <p> 1862 * This is a lane-wise binary operation which applies the primitive bitwise XOR 1863 * operation ({@code ^}) to each lane. 1864 * 1865 * @param v the input vector 1866 * @param m the mask controlling lane selection 1867 * @return the bitwise XOR of this vector with the input vector 1868 */ 1869 public abstract $abstractvectortype$ xor(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m); 1870 1871 /** 1872 * Bitwise XORs this vector with the broadcast of an input scalar, selecting 1873 * lane elements controlled by a mask. 1874 * <p> 1875 * This is a lane-wise binary operation which applies the primitive bitwise XOR 1876 * operation ({@code ^}) to each lane. 1877 * 1878 * @param s the input scalar 1879 * @param m the mask controlling lane selection 1880 * @return the bitwise XOR of this vector with the broadcast of an input 1881 * scalar 1882 */ 1883 public abstract $abstractvectortype$ xor($type$ s, VectorMask<$Boxtype$> m); 1884 1885 /** 1886 * Bitwise NOTs this vector. 1887 * <p> 1888 * This is a lane-wise unary operation which applies the primitive bitwise NOT 1889 * operation ({@code ~}) to each lane. 1890 * 1891 * @return the bitwise NOT of this vector 1892 */ 1893 public abstract $abstractvectortype$ not(); 1894 1895 /** 1896 * Bitwise NOTs this vector, selecting lane elements controlled by a mask. 1897 * <p> 1898 * This is a lane-wise unary operation which applies the primitive bitwise NOT 1899 * operation ({@code ~}) to each lane. 1900 * 1901 * @param m the mask controlling lane selection 1902 * @return the bitwise NOT of this vector 1903 */ 1904 public abstract $abstractvectortype$ not(VectorMask<$Boxtype$> m); 1905 1906 /** 1907 * Logically left shifts this vector by the broadcast of an input scalar. 1908 * <p> 1909 * This is a lane-wise binary operation which applies the primitive logical left shift 1910 * operation ({@code <<}) to each lane to left shift the 1911 * element by shift value as specified by the input scalar. 1912 #if[byte] 1913 * Only the 3 lowest-order bits of shift value are used. It is as if the shift value 1914 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 1915 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 1916 #end[byte] 1917 #if[short] 1918 * Only the 4 lowest-order bits of shift value are used. It is as if the shift value 1919 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 1920 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 1921 #end[short] 1922 * 1923 * @param s the input scalar; the number of the bits to left shift 1924 * @return the result of logically left shifting this vector by the 1925 * broadcast of an input scalar 1926 */ 1927 public abstract $abstractvectortype$ shiftLeft(int s); 1928 1929 /** 1930 * Logically left shifts this vector by the broadcast of an input scalar, 1931 * selecting lane elements controlled by a mask. 1932 * <p> 1933 * This is a lane-wise binary operation which applies the primitive logical left shift 1934 * operation ({@code <<}) to each lane to left shift the 1935 * element by shift value as specified by the input scalar. 1936 #if[byte] 1937 * Only the 3 lowest-order bits of shift value are used. It is as if the shift value 1938 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 1939 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 1940 #end[byte] 1941 #if[short] 1942 * Only the 4 lowest-order bits of shift value are used. It is as if the shift value 1943 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 1944 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 1945 #end[short] 1946 * 1947 * @param s the input scalar; the number of the bits to left shift 1948 * @param m the mask controlling lane selection 1949 * @return the result of logically left shifting this vector by the 1950 * broadcast of an input scalar 1951 */ 1952 public abstract $abstractvectortype$ shiftLeft(int s, VectorMask<$Boxtype$> m); 1953 1954 /** 1955 * Logically left shifts this vector by an input vector. 1956 * <p> 1957 * This is a lane-wise binary operation which applies the primitive logical left shift 1958 * operation ({@code <<}) to each lane. For each lane of this vector, the 1959 * shift value is the corresponding lane of input vector. 1960 #if[byte] 1961 * Only the 3 lowest-order bits of shift value are used. It is as if the shift value 1962 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 1963 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 1964 #end[byte] 1965 #if[short] 1966 * Only the 4 lowest-order bits of shift value are used. It is as if the shift value 1967 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 1968 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 1969 #end[short] 1970 * 1971 * @param v the input vector 1972 * @return the result of logically left shifting this vector by the input 1973 * vector 1974 */ 1975 public abstract $abstractvectortype$ shiftLeft(Vector<$Boxtype$> v); 1976 1977 /** 1978 * Logically left shifts this vector by an input vector, selecting lane 1979 * elements controlled by a mask. 1980 * <p> 1981 * This is a lane-wise binary operation which applies the primitive logical left shift 1982 * operation ({@code <<}) to each lane. For each lane of this vector, the 1983 * shift value is the corresponding lane of input vector. 1984 #if[byte] 1985 * Only the 3 lowest-order bits of shift value are used. It is as if the shift value 1986 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 1987 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 1988 #end[byte] 1989 #if[short] 1990 * Only the 4 lowest-order bits of shift value are used. It is as if the shift value 1991 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 1992 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 1993 #end[short] 1994 * 1995 * @param v the input vector 1996 * @param m the mask controlling lane selection 1997 * @return the result of logically left shifting this vector by the input 1998 * vector 1999 */ 2000 public $abstractvectortype$ shiftLeft(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 2001 return blend(shiftLeft(v), m); 2002 } 2003 2004 // logical, or unsigned, shift right 2005 2006 /** 2007 * Logically right shifts (or unsigned right shifts) this vector by the 2008 * broadcast of an input scalar. 2009 * <p> 2010 * This is a lane-wise binary operation which applies the primitive logical right shift 2011 * operation ({@code >>>}) to each lane to logically right shift the 2012 * element by shift value as specified by the input scalar. 2013 #if[byte] 2014 * Only the 3 lowest-order bits of shift value are used. It is as if the shift value 2015 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 2016 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 2017 #end[byte] 2018 #if[short] 2019 * Only the 4 lowest-order bits of shift value are used. It is as if the shift value 2020 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 2021 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 2022 #end[short] 2023 * 2024 * @param s the input scalar; the number of the bits to right shift 2025 * @return the result of logically right shifting this vector by the 2026 * broadcast of an input scalar 2027 */ 2028 public abstract $abstractvectortype$ shiftRight(int s); 2029 2030 /** 2031 * Logically right shifts (or unsigned right shifts) this vector by the 2032 * broadcast of an input scalar, selecting lane elements controlled by a 2033 * mask. 2034 * <p> 2035 * This is a lane-wise binary operation which applies the primitive logical right shift 2036 * operation ({@code >>}) to each lane to logically right shift the 2037 * element by shift value as specified by the input scalar. 2038 #if[byte] 2039 * Only the 3 lowest-order bits of shift value are used. It is as if the shift value 2040 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 2041 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 2042 #end[byte] 2043 #if[short] 2044 * Only the 4 lowest-order bits of shift value are used. It is as if the shift value 2045 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 2046 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 2047 #end[short] 2048 * 2049 * @param s the input scalar; the number of the bits to right shift 2050 * @param m the mask controlling lane selection 2051 * @return the result of logically right shifting this vector by the 2052 * broadcast of an input scalar 2053 */ 2054 public abstract $abstractvectortype$ shiftRight(int s, VectorMask<$Boxtype$> m); 2055 2056 /** 2057 * Logically right shifts (or unsigned right shifts) this vector by an 2058 * input vector. 2059 * <p> 2060 * This is a lane-wise binary operation which applies the primitive logical right shift 2061 * operation ({@code >>>}) to each lane. For each lane of this vector, the 2062 * shift value is the corresponding lane of input vector. 2063 #if[byte] 2064 * Only the 3 lowest-order bits of shift value are used. It is as if the shift value 2065 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 2066 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 2067 #end[byte] 2068 #if[short] 2069 * Only the 4 lowest-order bits of shift value are used. It is as if the shift value 2070 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 2071 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 2072 #end[short] 2073 * 2074 * @param v the input vector 2075 * @return the result of logically right shifting this vector by the 2076 * input vector 2077 */ 2078 public abstract $abstractvectortype$ shiftRight(Vector<$Boxtype$> v); 2079 2080 /** 2081 * Logically right shifts (or unsigned right shifts) this vector by an 2082 * input vector, selecting lane elements controlled by a mask. 2083 * <p> 2084 * This is a lane-wise binary operation which applies the primitive logical right shift 2085 * operation ({@code >>>}) to each lane. For each lane of this vector, the 2086 * shift value is the corresponding lane of input vector. 2087 #if[byte] 2088 * Only the 3 lowest-order bits of shift value are used. It is as if the shift value 2089 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 2090 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 2091 #end[byte] 2092 #if[short] 2093 * Only the 4 lowest-order bits of shift value are used. It is as if the shift value 2094 * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 2095 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 2096 #end[short] 2097 * 2098 * @param v the input vector 2099 * @param m the mask controlling lane selection 2100 * @return the result of logically right shifting this vector by the 2101 * input vector 2102 */ 2103 public $abstractvectortype$ shiftRight(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 2104 return blend(shiftRight(v), m); 2105 } 2106 2107 /** 2108 * Arithmetically right shifts (or signed right shifts) this vector by the 2109 * broadcast of an input scalar. 2110 * <p> 2111 * This is a lane-wise binary operation which applies the primitive arithmetic right 2112 * shift operation ({@code >>}) to each lane to arithmetically 2113 * right shift the element by shift value as specified by the input scalar. 2114 #if[byte] 2115 * Only the 3 lowest-order bits of shift value are used. It is as if the shift 2116 * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 2117 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 2118 #end[byte] 2119 #if[short] 2120 * Only the 4 lowest-order bits of shift value are used. It is as if the shift 2121 * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 2122 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 2123 #end[short] 2124 * 2125 * @param s the input scalar; the number of the bits to right shift 2126 * @return the result of arithmetically right shifting this vector by the 2127 * broadcast of an input scalar 2128 */ 2129 public abstract $abstractvectortype$ shiftArithmeticRight(int s); 2130 2131 /** 2132 * Arithmetically right shifts (or signed right shifts) this vector by the 2133 * broadcast of an input scalar, selecting lane elements controlled by a 2134 * mask. 2135 * <p> 2136 * This is a lane-wise binary operation which applies the primitive arithmetic right 2137 * shift operation ({@code >>}) to each lane to arithmetically 2138 * right shift the element by shift value as specified by the input scalar. 2139 #if[byte] 2140 * Only the 3 lowest-order bits of shift value are used. It is as if the shift 2141 * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 2142 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 2143 #end[byte] 2144 #if[short] 2145 * Only the 4 lowest-order bits of shift value are used. It is as if the shift 2146 * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 2147 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 2148 #end[short] 2149 * 2150 * @param s the input scalar; the number of the bits to right shift 2151 * @param m the mask controlling lane selection 2152 * @return the result of arithmetically right shifting this vector by the 2153 * broadcast of an input scalar 2154 */ 2155 public abstract $abstractvectortype$ shiftArithmeticRight(int s, VectorMask<$Boxtype$> m); 2156 2157 /** 2158 * Arithmetically right shifts (or signed right shifts) this vector by an 2159 * input vector. 2160 * <p> 2161 * This is a lane-wise binary operation which applies the primitive arithmetic right 2162 * shift operation ({@code >>}) to each lane. For each lane of this vector, the 2163 * shift value is the corresponding lane of input vector. 2164 #if[byte] 2165 * Only the 3 lowest-order bits of shift value are used. It is as if the shift 2166 * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 2167 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 2168 #end[byte] 2169 #if[short] 2170 * Only the 4 lowest-order bits of shift value are used. It is as if the shift 2171 * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 2172 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 2173 #end[short] 2174 * 2175 * @param v the input vector 2176 * @return the result of arithmetically right shifting this vector by the 2177 * input vector 2178 */ 2179 public abstract $abstractvectortype$ shiftArithmeticRight(Vector<$Boxtype$> v); 2180 2181 /** 2182 * Arithmetically right shifts (or signed right shifts) this vector by an 2183 * input vector, selecting lane elements controlled by a mask. 2184 * <p> 2185 * This is a lane-wise binary operation which applies the primitive arithmetic right 2186 * shift operation ({@code >>}) to each lane. For each lane of this vector, the 2187 * shift value is the corresponding lane of input vector. 2188 #if[byte] 2189 * Only the 3 lowest-order bits of shift value are used. It is as if the shift 2190 * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0x7. 2191 * The shift distance actually used is therefore always in the range 0 to 7, inclusive. 2192 #end[byte] 2193 #if[short] 2194 * Only the 4 lowest-order bits of shift value are used. It is as if the shift 2195 * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF. 2196 * The shift distance actually used is therefore always in the range 0 to 15, inclusive. 2197 #end[short] 2198 * 2199 * @param v the input vector 2200 * @param m the mask controlling lane selection 2201 * @return the result of arithmetically right shifting this vector by the 2202 * input vector 2203 */ 2204 public $abstractvectortype$ shiftArithmeticRight(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 2205 return blend(shiftArithmeticRight(v), m); 2206 } 2207 2208 /** 2209 * Rotates left this vector by the broadcast of an input scalar. 2210 * <p> 2211 #if[intOrLong] 2212 * This is a lane-wise binary operation which applies the operation 2213 * {@link $Wideboxtype$#rotateLeft} to each lane and where 2214 * lane elements of this vector apply to the first argument, and lane 2215 * elements of the broadcast vector apply to the second argument (the 2216 * rotation distance). 2217 #end[intOrLong] 2218 #if[byte] 2219 * This is a lane-wise binary operation which produces the result of rotating left the two's 2220 * complement binary representation of each lane of first operand (this vector) by input scalar. 2221 * Rotation by any multiple of 8 is a no-op, so only the 3 lowest-order bits of input value are used. 2222 * It is as if the input value were subjected to a bitwise logical 2223 * AND operator ({@code &}) with the mask value 0x7. 2224 #end[byte] 2225 #if[short] 2226 * This is a lane-wise binary operation which produces the result of rotating left the two's 2227 * complement binary representation of each lane of first operand (this vector) by input scalar. 2228 * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. 2229 * It is as if the input value were subjected to a bitwise logical 2230 * AND operator ({@code &}) with the mask value 0xF. 2231 #end[short] 2232 * 2233 * @param s the input scalar; the number of the bits to rotate left 2234 * @return the result of rotating left this vector by the broadcast of an 2235 * input scalar 2236 */ 2237 @ForceInline 2238 public final $abstractvectortype$ rotateLeft(int s) { 2239 return shiftLeft(s).or(shiftRight(-s)); 2240 } 2241 2242 /** 2243 * Rotates left this vector by the broadcast of an input scalar, selecting 2244 * lane elements controlled by a mask. 2245 * <p> 2246 #if[intOrLong] 2247 * This is a lane-wise binary operation which applies the operation 2248 * {@link $Wideboxtype$#rotateLeft} to each lane and where 2249 * lane elements of this vector apply to the first argument, and lane 2250 * elements of the broadcast vector apply to the second argument (the 2251 * rotation distance). 2252 #end[intOrLong] 2253 #if[byte] 2254 * This is a lane-wise binary operation which produces the result of rotating left the two's 2255 * complement binary representation of each lane of first operand (this vector) by input scalar. 2256 * Rotation by any multiple of 8 is a no-op, so only the 3 lowest-order bits of input value are used. 2257 * It is as if the input value were subjected to a bitwise logical 2258 * AND operator ({@code &}) with the mask value 0x7. 2259 #end[byte] 2260 #if[short] 2261 * This is a lane-wise binary operation which produces the result of rotating left the two's 2262 * complement binary representation of each lane of first operand (this vector) by input scalar. 2263 * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. 2264 * It is as if the input value were subjected to a bitwise logical 2265 * AND operator ({@code &}) with the mask value 0xF. 2266 #end[short] 2267 * 2268 * @param s the input scalar; the number of the bits to rotate left 2269 * @param m the mask controlling lane selection 2270 * @return the result of rotating left this vector by the broadcast of an 2271 * input scalar 2272 */ 2273 @ForceInline 2274 public final $abstractvectortype$ rotateLeft(int s, VectorMask<$Boxtype$> m) { 2275 return shiftLeft(s, m).or(shiftRight(-s, m), m); 2276 } 2277 2278 /** 2279 * Rotates right this vector by the broadcast of an input scalar. 2280 * <p> 2281 #if[intOrLong] 2282 * This is a lane-wise binary operation which applies the operation 2283 * {@link $Wideboxtype$#rotateRight} to each lane and where 2284 * lane elements of this vector apply to the first argument, and lane 2285 * elements of the broadcast vector apply to the second argument (the 2286 * rotation distance). 2287 #end[intOrLong] 2288 #if[byte] 2289 * This is a lane-wise binary operation which produces the result of rotating right the two's 2290 * complement binary representation of each lane of first operand (this vector) by input scalar. 2291 * Rotation by any multiple of 8 is a no-op, so only the 3 lowest-order bits of input value are used. 2292 * It is as if the input value were subjected to a bitwise logical 2293 * AND operator ({@code &}) with the mask value 0x7. 2294 #end[byte] 2295 #if[short] 2296 * This is a lane-wise binary operation which produces the result of rotating right the two's 2297 * complement binary representation of each lane of first operand (this vector) by input scalar. 2298 * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. 2299 * It is as if the input value were subjected to a bitwise logical 2300 * AND operator ({@code &}) with the mask value 0xF. 2301 #end[short] 2302 * 2303 * @param s the input scalar; the number of the bits to rotate right 2304 * @return the result of rotating right this vector by the broadcast of an 2305 * input scalar 2306 */ 2307 @ForceInline 2308 public final $abstractvectortype$ rotateRight(int s) { 2309 return shiftRight(s).or(shiftLeft(-s)); 2310 } 2311 2312 /** 2313 * Rotates right this vector by the broadcast of an input scalar, selecting 2314 * lane elements controlled by a mask. 2315 * <p> 2316 #if[intOrLong] 2317 * This is a lane-wise binary operation which applies the operation 2318 * {@link $Wideboxtype$#rotateRight} to each lane and where 2319 * lane elements of this vector apply to the first argument, and lane 2320 * elements of the broadcast vector apply to the second argument (the 2321 * rotation distance). 2322 #end[intOrLong] 2323 #if[byte] 2324 * This is a lane-wise binary operation which produces the result of rotating right the two's 2325 * complement binary representation of each lane of first operand (this vector) by input scalar. 2326 * Rotation by any multiple of 8 is a no-op, so only the 3 lowest-order bits of input value are used. 2327 * It is as if the input value were subjected to a bitwise logical 2328 * AND operator ({@code &}) with the mask value 0x7. 2329 #end[byte] 2330 #if[short] 2331 * This is a lane-wise binary operation which produces the result of rotating right the two's 2332 * complement binary representation of each lane of first operand (this vector) by input scalar. 2333 * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. 2334 * It is as if the input value were subjected to a bitwise logical 2335 * AND operator ({@code &}) with the mask value 0xF. 2336 #end[short] 2337 * 2338 * @param s the input scalar; the number of the bits to rotate right 2339 * @param m the mask controlling lane selection 2340 * @return the result of rotating right this vector by the broadcast of an 2341 * input scalar 2342 */ 2343 @ForceInline 2344 public final $abstractvectortype$ rotateRight(int s, VectorMask<$Boxtype$> m) { 2345 return shiftRight(s, m).or(shiftLeft(-s, m), m); 2346 } 2347 #end[BITWISE] 2348 2349 /** 2350 * {@inheritDoc} 2351 */ 2352 @Override 2353 public abstract void intoByteArray(byte[] a, int ix); 2354 2355 /** 2356 * {@inheritDoc} 2357 */ 2358 @Override 2359 public abstract void intoByteArray(byte[] a, int ix, VectorMask<$Boxtype$> m); 2360 2361 /** 2362 * {@inheritDoc} 2363 */ 2364 @Override 2365 public abstract void intoByteBuffer(ByteBuffer bb, int ix); 2366 2367 /** 2368 * {@inheritDoc} 2369 */ 2370 @Override 2371 public abstract void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<$Boxtype$> m); 2372 2373 2374 // Type specific horizontal reductions 2375 /** 2376 * Adds all lane elements of this vector. 2377 * <p> 2378 #if[FP] 2379 * This is a cross-lane reduction operation which applies the addition 2380 * operation ({@code +}) to lane elements, 2381 * and the identity value is {@code 0.0}. 2382 * 2383 * <p>The value of a floating-point sum is a function both of the input values as well 2384 * as the order of addition operations. The order of addition operations of this method 2385 * is intentionally not defined to allow for JVM to generate optimal machine 2386 * code for the underlying platform at runtime. If the platform supports a vector 2387 * instruction to add all values in the vector, or if there is some other efficient machine 2388 * code sequence, then the JVM has the option of generating this machine code. Otherwise, 2389 * the default implementation of adding vectors sequentially from left to right is used. 2390 * For this reason, the output of this method may vary for the same input values. 2391 #else[FP] 2392 * This is an associative cross-lane reduction operation which applies the addition 2393 * operation ({@code +}) to lane elements, 2394 * and the identity value is {@code 0}. 2395 #end[FP] 2396 * 2397 * @return the addition of all the lane elements of this vector 2398 */ 2399 public abstract $type$ addLanes(); 2400 2401 /** 2402 * Adds all lane elements of this vector, selecting lane elements 2403 * controlled by a mask. 2404 * <p> 2405 #if[FP] 2406 * This is a cross-lane reduction operation which applies the addition 2407 * operation ({@code +}) to lane elements, 2408 * and the identity value is {@code 0.0}. 2409 * 2410 * <p>The value of a floating-point sum is a function both of the input values as well 2411 * as the order of addition operations. The order of addition operations of this method 2412 * is intentionally not defined to allow for JVM to generate optimal machine 2413 * code for the underlying platform at runtime. If the platform supports a vector 2414 * instruction to add all values in the vector, or if there is some other efficient machine 2415 * code sequence, then the JVM has the option of generating this machine code. Otherwise, 2416 * the default implementation of adding vectors sequentially from left to right is used. 2417 * For this reason, the output of this method may vary on the same input values. 2418 #else[FP] 2419 * This is an associative cross-lane reduction operation which applies the addition 2420 * operation ({@code +}) to lane elements, 2421 * and the identity value is {@code 0}. 2422 #end[FP] 2423 * 2424 * @param m the mask controlling lane selection 2425 * @return the addition of the selected lane elements of this vector 2426 */ 2427 public abstract $type$ addLanes(VectorMask<$Boxtype$> m); 2428 2429 /** 2430 * Multiplies all lane elements of this vector. 2431 * <p> 2432 #if[FP] 2433 * This is a cross-lane reduction operation which applies the 2434 * multiplication operation ({@code *}) to lane elements, 2435 * and the identity value is {@code 1.0}. 2436 * 2437 * <p>The order of multiplication operations of this method 2438 * is intentionally not defined to allow for JVM to generate optimal machine 2439 * code for the underlying platform at runtime. If the platform supports a vector 2440 * instruction to multiply all values in the vector, or if there is some other efficient machine 2441 * code sequence, then the JVM has the option of generating this machine code. Otherwise, 2442 * the default implementation of multiplying vectors sequentially from left to right is used. 2443 * For this reason, the output of this method may vary on the same input values. 2444 #else[FP] 2445 * This is an associative cross-lane reduction operation which applies the 2446 * multiplication operation ({@code *}) to lane elements, 2447 * and the identity value is {@code 1}. 2448 #end[FP] 2449 * 2450 * @return the multiplication of all the lane elements of this vector 2451 */ 2452 public abstract $type$ mulLanes(); 2453 2454 /** 2455 * Multiplies all lane elements of this vector, selecting lane elements 2456 * controlled by a mask. 2457 * <p> 2458 #if[FP] 2459 * This is a cross-lane reduction operation which applies the 2460 * multiplication operation ({@code *}) to lane elements, 2461 * and the identity value is {@code 1.0}. 2462 * 2463 * <p>The order of multiplication operations of this method 2464 * is intentionally not defined to allow for JVM to generate optimal machine 2465 * code for the underlying platform at runtime. If the platform supports a vector 2466 * instruction to multiply all values in the vector, or if there is some other efficient machine 2467 * code sequence, then the JVM has the option of generating this machine code. Otherwise, 2468 * the default implementation of multiplying vectors sequentially from left to right is used. 2469 * For this reason, the output of this method may vary on the same input values. 2470 #else[FP] 2471 * This is an associative cross-lane reduction operation which applies the 2472 * multiplication operation ({@code *}) to lane elements, 2473 * and the identity value is {@code 1}. 2474 #end[FP] 2475 * 2476 * @param m the mask controlling lane selection 2477 * @return the multiplication of all the lane elements of this vector 2478 */ 2479 public abstract $type$ mulLanes(VectorMask<$Boxtype$> m); 2480 2481 /** 2482 * Returns the minimum lane element of this vector. 2483 * <p> 2484 * This is an associative cross-lane reduction operation which applies the operation 2485 * {@code (a, b) -> Math.min(a, b)} to lane elements, 2486 * and the identity value is 2487 #if[FP] 2488 * {@link $Boxtype$#POSITIVE_INFINITY}. 2489 #else[FP] 2490 * {@link $Boxtype$#MAX_VALUE}. 2491 #end[FP] 2492 * 2493 * @return the minimum lane element of this vector 2494 */ 2495 public abstract $type$ minLanes(); 2496 2497 /** 2498 * Returns the minimum lane element of this vector, selecting lane elements 2499 * controlled by a mask. 2500 * <p> 2501 * This is an associative cross-lane reduction operation which applies the operation 2502 * {@code (a, b) -> Math.min(a, b)} to lane elements, 2503 * and the identity value is 2504 #if[FP] 2505 * {@link $Boxtype$#POSITIVE_INFINITY}. 2506 #else[FP] 2507 * {@link $Boxtype$#MAX_VALUE}. 2508 #end[FP] 2509 * 2510 * @param m the mask controlling lane selection 2511 * @return the minimum lane element of this vector 2512 */ 2513 public abstract $type$ minLanes(VectorMask<$Boxtype$> m); 2514 2515 /** 2516 * Returns the maximum lane element of this vector. 2517 * <p> 2518 * This is an associative cross-lane reduction operation which applies the operation 2519 * {@code (a, b) -> Math.max(a, b)} to lane elements, 2520 * and the identity value is 2521 #if[FP] 2522 * {@link $Boxtype$#NEGATIVE_INFINITY}. 2523 #else[FP] 2524 * {@link $Boxtype$#MIN_VALUE}. 2525 #end[FP] 2526 * 2527 * @return the maximum lane element of this vector 2528 */ 2529 public abstract $type$ maxLanes(); 2530 2531 /** 2532 * Returns the maximum lane element of this vector, selecting lane elements 2533 * controlled by a mask. 2534 * <p> 2535 * This is an associative cross-lane reduction operation which applies the operation 2536 * {@code (a, b) -> Math.max(a, b)} to lane elements, 2537 * and the identity value is 2538 #if[FP] 2539 * {@link $Boxtype$#NEGATIVE_INFINITY}. 2540 #else[FP] 2541 * {@link $Boxtype$#MIN_VALUE}. 2542 #end[FP] 2543 * 2544 * @param m the mask controlling lane selection 2545 * @return the maximum lane element of this vector 2546 */ 2547 public abstract $type$ maxLanes(VectorMask<$Boxtype$> m); 2548 2549 #if[BITWISE] 2550 /** 2551 * Logically ORs all lane elements of this vector. 2552 * <p> 2553 * This is an associative cross-lane reduction operation which applies the logical OR 2554 * operation ({@code |}) to lane elements, 2555 * and the identity value is {@code 0}. 2556 * 2557 * @return the logical OR all the lane elements of this vector 2558 */ 2559 public abstract $type$ orLanes(); 2560 2561 /** 2562 * Logically ORs all lane elements of this vector, selecting lane elements 2563 * controlled by a mask. 2564 * <p> 2565 * This is an associative cross-lane reduction operation which applies the logical OR 2566 * operation ({@code |}) to lane elements, 2567 * and the identity value is {@code 0}. 2568 * 2569 * @param m the mask controlling lane selection 2570 * @return the logical OR all the lane elements of this vector 2571 */ 2572 public abstract $type$ orLanes(VectorMask<$Boxtype$> m); 2573 2574 /** 2575 * Logically ANDs all lane elements of this vector. 2576 * <p> 2577 * This is an associative cross-lane reduction operation which applies the logical AND 2578 * operation ({@code |}) to lane elements, 2579 * and the identity value is {@code -1}. 2580 * 2581 * @return the logical AND all the lane elements of this vector 2582 */ 2583 public abstract $type$ andLanes(); 2584 2585 /** 2586 * Logically ANDs all lane elements of this vector, selecting lane elements 2587 * controlled by a mask. 2588 * <p> 2589 * This is an associative cross-lane reduction operation which applies the logical AND 2590 * operation ({@code |}) to lane elements, 2591 * and the identity value is {@code -1}. 2592 * 2593 * @param m the mask controlling lane selection 2594 * @return the logical AND all the lane elements of this vector 2595 */ 2596 public abstract $type$ andLanes(VectorMask<$Boxtype$> m); 2597 2598 /** 2599 * Logically XORs all lane elements of this vector. 2600 * <p> 2601 * This is an associative cross-lane reduction operation which applies the logical XOR 2602 * operation ({@code ^}) to lane elements, 2603 * and the identity value is {@code 0}. 2604 * 2605 * @return the logical XOR all the lane elements of this vector 2606 */ 2607 public abstract $type$ xorLanes(); 2608 2609 /** 2610 * Logically XORs all lane elements of this vector, selecting lane elements 2611 * controlled by a mask. 2612 * <p> 2613 * This is an associative cross-lane reduction operation which applies the logical XOR 2614 * operation ({@code ^}) to lane elements, 2615 * and the identity value is {@code 0}. 2616 * 2617 * @param m the mask controlling lane selection 2618 * @return the logical XOR all the lane elements of this vector 2619 */ 2620 public abstract $type$ xorLanes(VectorMask<$Boxtype$> m); 2621 #end[BITWISE] 2622 2623 // Type specific accessors 2624 2625 /** 2626 * Gets the lane element at lane index {@code i} 2627 * 2628 * @param i the lane index 2629 * @return the lane element at lane index {@code i} 2630 * @throws IllegalArgumentException if the index is is out of range 2631 * ({@code < 0 || >= length()}) 2632 */ 2633 public abstract $type$ lane(int i); 2634 2635 /** 2636 * Replaces the lane element of this vector at lane index {@code i} with 2637 * value {@code e}. 2638 * <p> 2639 * This is a cross-lane operation and behaves as if it returns the result 2640 * of blending this vector with an input vector that is the result of 2641 * broadcasting {@code e} and a mask that has only one lane set at lane 2642 * index {@code i}. 2643 * 2644 * @param i the lane index of the lane element to be replaced 2645 * @param e the value to be placed 2646 * @return the result of replacing the lane element of this vector at lane 2647 * index {@code i} with value {@code e}. 2648 * @throws IllegalArgumentException if the index is is out of range 2649 * ({@code < 0 || >= length()}) 2650 */ 2651 public abstract $abstractvectortype$ with(int i, $type$ e); 2652 2653 // Type specific extractors 2654 2655 /** 2656 * Returns an array containing the lane elements of this vector. 2657 * <p> 2658 * This method behaves as if it {@link #intoArray($type$[], int)} stores} 2659 * this vector into an allocated array and returns the array as follows: 2660 * <pre>{@code 2661 * $type$[] a = new $type$[this.length()]; 2662 * this.intoArray(a, 0); 2663 * return a; 2664 * }</pre> 2665 * 2666 * @return an array containing the the lane elements of this vector 2667 */ 2668 @ForceInline 2669 public final $type$[] toArray() { 2670 $type$[] a = new $type$[species().length()]; 2671 intoArray(a, 0); 2672 return a; 2673 } 2674 2675 /** 2676 * Stores this vector into an array starting at offset. 2677 * <p> 2678 * For each vector lane, where {@code N} is the vector lane index, 2679 * the lane element at index {@code N} is stored into the array at index 2680 * {@code offset + N}. 2681 * 2682 * @param a the array 2683 * @param offset the offset into the array 2684 * @throws IndexOutOfBoundsException if {@code offset < 0}, or 2685 * {@code offset > a.length - this.length()} 2686 */ 2687 public abstract void intoArray($type$[] a, int offset); 2688 2689 /** 2690 * Stores this vector into an array starting at offset and using a mask. 2691 * <p> 2692 * For each vector lane, where {@code N} is the vector lane index, 2693 * if the mask lane at index {@code N} is set then the lane element at 2694 * index {@code N} is stored into the array index {@code offset + N}. 2695 * 2696 * @param a the array 2697 * @param offset the offset into the array 2698 * @param m the mask 2699 * @throws IndexOutOfBoundsException if {@code offset < 0}, or 2700 * for any vector lane index {@code N} where the mask at lane {@code N} 2701 * is set {@code offset >= a.length - N} 2702 */ 2703 public abstract void intoArray($type$[] a, int offset, VectorMask<$Boxtype$> m); 2704 2705 /** 2706 * Stores this vector into an array using indexes obtained from an index 2707 * map. 2708 * <p> 2709 * For each vector lane, where {@code N} is the vector lane index, the 2710 * lane element at index {@code N} is stored into the array at index 2711 * {@code a_offset + indexMap[i_offset + N]}. 2712 * 2713 * @param a the array 2714 * @param a_offset the offset into the array, may be negative if relative 2715 * indexes in the index map compensate to produce a value within the 2716 * array bounds 2717 * @param indexMap the index map 2718 * @param i_offset the offset into the index map 2719 * @throws IndexOutOfBoundsException if {@code i_offset < 0}, or 2720 * {@code i_offset > indexMap.length - this.length()}, 2721 * or for any vector lane index {@code N} the result of 2722 * {@code a_offset + indexMap[i_offset + N]} is {@code < 0} or {@code >= a.length} 2723 */ 2724 #if[byteOrShort] 2725 public void intoArray($type$[] a, int a_offset, int[] indexMap, int i_offset) { 2726 forEach((n, e) -> a[a_offset + indexMap[i_offset + n]] = e); 2727 } 2728 #else[byteOrShort] 2729 public abstract void intoArray($type$[] a, int a_offset, int[] indexMap, int i_offset); 2730 #end[byteOrShort] 2731 2732 /** 2733 * Stores this vector into an array using indexes obtained from an index 2734 * map and using a mask. 2735 * <p> 2736 * For each vector lane, where {@code N} is the vector lane index, 2737 * if the mask lane at index {@code N} is set then the lane element at 2738 * index {@code N} is stored into the array at index 2739 * {@code a_offset + indexMap[i_offset + N]}. 2740 * 2741 * @param a the array 2742 * @param a_offset the offset into the array, may be negative if relative 2743 * indexes in the index map compensate to produce a value within the 2744 * array bounds 2745 * @param m the mask 2746 * @param indexMap the index map 2747 * @param i_offset the offset into the index map 2748 * @throws IndexOutOfBoundsException if {@code j < 0}, or 2749 * {@code i_offset > indexMap.length - this.length()}, 2750 * or for any vector lane index {@code N} where the mask at lane 2751 * {@code N} is set the result of {@code a_offset + indexMap[i_offset + N]} is 2752 * {@code < 0} or {@code >= a.length} 2753 */ 2754 #if[byteOrShort] 2755 public void intoArray($type$[] a, int a_offset, VectorMask<$Boxtype$> m, int[] indexMap, int i_offset) { 2756 forEach(m, (n, e) -> a[a_offset + indexMap[i_offset + n]] = e); 2757 } 2758 #else[byteOrShort] 2759 public abstract void intoArray($type$[] a, int a_offset, VectorMask<$Boxtype$> m, int[] indexMap, int i_offset); 2760 #end[byteOrShort] 2761 // Species 2762 2763 /** 2764 * {@inheritDoc} 2765 */ 2766 @Override 2767 public abstract VectorSpecies<$Boxtype$> species(); 2768 2769 /** 2770 * Class representing {@link $abstractvectortype$}'s of the same {@link VectorShape VectorShape}. 2771 */ 2772 static final class $Type$Species extends AbstractSpecies<$Boxtype$> { 2773 final Function<$type$[], $Type$Vector> vectorFactory; 2774 2775 private $Type$Species(VectorShape shape, 2776 Class<?> vectorType, 2777 Class<?> maskType, 2778 Function<$type$[], $Type$Vector> vectorFactory, 2779 Function<boolean[], VectorMask<$Boxtype$>> maskFactory, 2780 Function<IntUnaryOperator, VectorShuffle<$Boxtype$>> shuffleFromArrayFactory, 2781 fShuffleFromArray<$Boxtype$> shuffleFromOpFactory) { 2782 super(shape, $type$.class, $Boxtype$.SIZE, vectorType, maskType, maskFactory, 2783 shuffleFromArrayFactory, shuffleFromOpFactory); 2784 this.vectorFactory = vectorFactory; 2785 } 2786 2787 interface FOp { 2788 $type$ apply(int i); 2789 } 2790 2791 $Type$Vector op(FOp f) { 2792 $type$[] res = new $type$[length()]; 2793 for (int i = 0; i < length(); i++) { 2794 res[i] = f.apply(i); 2795 } 2796 return vectorFactory.apply(res); 2797 } 2798 2799 $Type$Vector op(VectorMask<$Boxtype$> o, FOp f) { 2800 $type$[] res = new $type$[length()]; 2801 boolean[] mbits = ((AbstractMask<$Boxtype$>)o).getBits(); 2802 for (int i = 0; i < length(); i++) { 2803 if (mbits[i]) { 2804 res[i] = f.apply(i); 2805 } 2806 } 2807 return vectorFactory.apply(res); 2808 } 2809 } 2810 2811 /** 2812 * Finds the preferred species for an element type of {@code $type$}. 2813 * <p> 2814 * A preferred species is a species chosen by the platform that has a 2815 * shape of maximal bit size. A preferred species for different element 2816 * types will have the same shape, and therefore vectors, masks, and 2817 * shuffles created from such species will be shape compatible. 2818 * 2819 * @return the preferred species for an element type of {@code $type$} 2820 */ 2821 private static $Type$Species preferredSpecies() { 2822 return ($Type$Species) VectorSpecies.ofPreferred($type$.class); 2823 } 2824 2825 /** 2826 * Finds a species for an element type of {@code $type$} and shape. 2827 * 2828 * @param s the shape 2829 * @return a species for an element type of {@code $type$} and shape 2830 * @throws IllegalArgumentException if no such species exists for the shape 2831 */ 2832 static $Type$Species species(VectorShape s) { 2833 Objects.requireNonNull(s); 2834 switch (s) { 2835 case S_64_BIT: return ($Type$Species) SPECIES_64; 2836 case S_128_BIT: return ($Type$Species) SPECIES_128; 2837 case S_256_BIT: return ($Type$Species) SPECIES_256; 2838 case S_512_BIT: return ($Type$Species) SPECIES_512; 2839 case S_Max_BIT: return ($Type$Species) SPECIES_MAX; 2840 default: throw new IllegalArgumentException("Bad shape: " + s); 2841 } 2842 } 2843 2844 /** Species representing {@link $Type$Vector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */ 2845 public static final VectorSpecies<$Boxtype$> SPECIES_64 = new $Type$Species(VectorShape.S_64_BIT, $Type$64Vector.class, $Type$64Vector.$Type$64Mask.class, 2846 $Type$64Vector::new, $Type$64Vector.$Type$64Mask::new, 2847 $Type$64Vector.$Type$64Shuffle::new, $Type$64Vector.$Type$64Shuffle::new); 2848 2849 /** Species representing {@link $Type$Vector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */ 2850 public static final VectorSpecies<$Boxtype$> SPECIES_128 = new $Type$Species(VectorShape.S_128_BIT, $Type$128Vector.class, $Type$128Vector.$Type$128Mask.class, 2851 $Type$128Vector::new, $Type$128Vector.$Type$128Mask::new, 2852 $Type$128Vector.$Type$128Shuffle::new, $Type$128Vector.$Type$128Shuffle::new); 2853 2854 /** Species representing {@link $Type$Vector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */ 2855 public static final VectorSpecies<$Boxtype$> SPECIES_256 = new $Type$Species(VectorShape.S_256_BIT, $Type$256Vector.class, $Type$256Vector.$Type$256Mask.class, 2856 $Type$256Vector::new, $Type$256Vector.$Type$256Mask::new, 2857 $Type$256Vector.$Type$256Shuffle::new, $Type$256Vector.$Type$256Shuffle::new); 2858 2859 /** Species representing {@link $Type$Vector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */ 2860 public static final VectorSpecies<$Boxtype$> SPECIES_512 = new $Type$Species(VectorShape.S_512_BIT, $Type$512Vector.class, $Type$512Vector.$Type$512Mask.class, 2861 $Type$512Vector::new, $Type$512Vector.$Type$512Mask::new, 2862 $Type$512Vector.$Type$512Shuffle::new, $Type$512Vector.$Type$512Shuffle::new); 2863 2864 /** Species representing {@link $Type$Vector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */ 2865 public static final VectorSpecies<$Boxtype$> SPECIES_MAX = new $Type$Species(VectorShape.S_Max_BIT, $Type$MaxVector.class, $Type$MaxVector.$Type$MaxMask.class, 2866 $Type$MaxVector::new, $Type$MaxVector.$Type$MaxMask::new, 2867 $Type$MaxVector.$Type$MaxShuffle::new, $Type$MaxVector.$Type$MaxShuffle::new); 2868 2869 /** 2870 * Preferred species for {@link $Type$Vector}s. 2871 * A preferred species is a species of maximal bit size for the platform. 2872 */ 2873 public static final VectorSpecies<$Boxtype$> SPECIES_PREFERRED = (VectorSpecies<$Boxtype$>) preferredSpecies(); 2874 }