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