1 /*
2 * Copyright (c) 2017, 2021, 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 any
23 * questions.
24 */
25 package jdk.incubator.vector;
26
27 import java.nio.ByteBuffer;
28 import java.util.Arrays;
29 import java.util.Objects;
30 import java.util.function.IntUnaryOperator;
31
32 import jdk.internal.vm.annotation.ForceInline;
33 import jdk.internal.vm.vector.VectorSupport;
34
35 import static jdk.internal.vm.vector.VectorSupport.*;
36
37 import static jdk.incubator.vector.VectorOperators.*;
38
39 // -- This file was mechanically generated: Do not edit! -- //
40
41 @SuppressWarnings("cast") // warning: redundant cast
42 final class DoubleMaxVector extends DoubleVector {
43 static final DoubleSpecies VSPECIES =
44 (DoubleSpecies) DoubleVector.SPECIES_MAX;
45
46 static final VectorShape VSHAPE =
47 VSPECIES.vectorShape();
48
49 static final Class<DoubleMaxVector> VCLASS = DoubleMaxVector.class;
50
51 static final int VSIZE = VSPECIES.vectorBitSize();
52
53 static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM
54
55 static final Class<Double> ETYPE = double.class; // used by the JVM
56
57 DoubleMaxVector(double[] v) {
58 super(v);
59 }
60
61 // For compatibility as DoubleMaxVector::new,
62 // stored into species.vectorFactory.
63 DoubleMaxVector(Object v) {
64 this((double[]) v);
65 }
66
67 static final DoubleMaxVector ZERO = new DoubleMaxVector(new double[VLENGTH]);
68 static final DoubleMaxVector IOTA = new DoubleMaxVector(VSPECIES.iotaArray());
69
70 static {
71 // Warm up a few species caches.
72 // If we do this too much we will
73 // get NPEs from bootstrap circularity.
74 VSPECIES.dummyVector();
75 VSPECIES.withLanes(LaneType.BYTE);
76 }
77
78 // Specialized extractors
79
80 @ForceInline
81 final @Override
82 public DoubleSpecies vspecies() {
83 // ISSUE: This should probably be a @Stable
84 // field inside AbstractVector, rather than
85 // a megamorphic method.
86 return VSPECIES;
87 }
88
89 @ForceInline
90 @Override
91 public final Class<Double> elementType() { return double.class; }
92
93 @ForceInline
94 @Override
95 public final int elementSize() { return Double.SIZE; }
96
97 @ForceInline
98 @Override
99 public final VectorShape shape() { return VSHAPE; }
100
101 @ForceInline
102 @Override
103 public final int length() { return VLENGTH; }
104
105 @ForceInline
106 @Override
107 public final int bitSize() { return VSIZE; }
108
109 @ForceInline
110 @Override
111 public final int byteSize() { return VSIZE / Byte.SIZE; }
112
113 /*package-private*/
114 @ForceInline
115 final @Override
116 double[] vec() {
117 return (double[])getPayload();
118 }
119
120 // Virtualized constructors
121
122 @Override
123 @ForceInline
124 public final DoubleMaxVector broadcast(double e) {
125 return (DoubleMaxVector) super.broadcastTemplate(e); // specialize
126 }
127
128 @Override
129 @ForceInline
130 public final DoubleMaxVector broadcast(long e) {
131 return (DoubleMaxVector) super.broadcastTemplate(e); // specialize
132 }
133
134 @Override
135 @ForceInline
136 DoubleMaxMask maskFromArray(boolean[] bits) {
137 return new DoubleMaxMask(bits);
138 }
139
140 @Override
141 @ForceInline
142 DoubleMaxShuffle iotaShuffle() { return DoubleMaxShuffle.IOTA; }
143
144 @ForceInline
145 DoubleMaxShuffle iotaShuffle(int start, int step, boolean wrap) {
146 if (wrap) {
147 return (DoubleMaxShuffle)VectorSupport.shuffleIota(ETYPE, DoubleMaxShuffle.class, VSPECIES, VLENGTH, start, step, 1,
148 (l, lstart, lstep, s) -> s.shuffleFromOp(i -> (VectorIntrinsics.wrapToRange(i*lstep + lstart, l))));
149 } else {
150 return (DoubleMaxShuffle)VectorSupport.shuffleIota(ETYPE, DoubleMaxShuffle.class, VSPECIES, VLENGTH, start, step, 0,
151 (l, lstart, lstep, s) -> s.shuffleFromOp(i -> (i*lstep + lstart)));
152 }
153 }
154
155 @Override
156 @ForceInline
157 DoubleMaxShuffle shuffleFromBytes(byte[] reorder) { return new DoubleMaxShuffle(reorder); }
158
159 @Override
160 @ForceInline
161 DoubleMaxShuffle shuffleFromArray(int[] indexes, int i) { return new DoubleMaxShuffle(indexes, i); }
162
163 @Override
164 @ForceInline
165 DoubleMaxShuffle shuffleFromOp(IntUnaryOperator fn) { return new DoubleMaxShuffle(fn); }
166
167 // Make a vector of the same species but the given elements:
168 @ForceInline
169 final @Override
170 DoubleMaxVector vectorFactory(double[] vec) {
171 return new DoubleMaxVector(vec);
172 }
173
174 @ForceInline
175 final @Override
176 ByteMaxVector asByteVectorRaw() {
177 return (ByteMaxVector) super.asByteVectorRawTemplate(); // specialize
178 }
179
180 @ForceInline
181 final @Override
182 AbstractVector<?> asVectorRaw(LaneType laneType) {
183 return super.asVectorRawTemplate(laneType); // specialize
184 }
185
186 // Unary operator
187
188 @ForceInline
189 final @Override
190 DoubleMaxVector uOp(FUnOp f) {
191 return (DoubleMaxVector) super.uOpTemplate(f); // specialize
192 }
193
194 @ForceInline
195 final @Override
196 DoubleMaxVector uOp(VectorMask<Double> m, FUnOp f) {
197 return (DoubleMaxVector)
198 super.uOpTemplate((DoubleMaxMask)m, f); // specialize
199 }
200
201 // Binary operator
202
203 @ForceInline
204 final @Override
205 DoubleMaxVector bOp(Vector<Double> v, FBinOp f) {
206 return (DoubleMaxVector) super.bOpTemplate((DoubleMaxVector)v, f); // specialize
207 }
208
209 @ForceInline
210 final @Override
211 DoubleMaxVector bOp(Vector<Double> v,
212 VectorMask<Double> m, FBinOp f) {
213 return (DoubleMaxVector)
214 super.bOpTemplate((DoubleMaxVector)v, (DoubleMaxMask)m,
215 f); // specialize
216 }
217
218 // Ternary operator
219
220 @ForceInline
221 final @Override
222 DoubleMaxVector tOp(Vector<Double> v1, Vector<Double> v2, FTriOp f) {
223 return (DoubleMaxVector)
224 super.tOpTemplate((DoubleMaxVector)v1, (DoubleMaxVector)v2,
225 f); // specialize
226 }
227
228 @ForceInline
229 final @Override
230 DoubleMaxVector tOp(Vector<Double> v1, Vector<Double> v2,
231 VectorMask<Double> m, FTriOp f) {
232 return (DoubleMaxVector)
233 super.tOpTemplate((DoubleMaxVector)v1, (DoubleMaxVector)v2,
234 (DoubleMaxMask)m, f); // specialize
235 }
236
237 @ForceInline
238 final @Override
239 double rOp(double v, VectorMask<Double> m, FBinOp f) {
240 return super.rOpTemplate(v, m, f); // specialize
241 }
242
243 @Override
244 @ForceInline
245 public final <F>
246 Vector<F> convertShape(VectorOperators.Conversion<Double,F> conv,
247 VectorSpecies<F> rsp, int part) {
248 return super.convertShapeTemplate(conv, rsp, part); // specialize
249 }
250
251 @Override
252 @ForceInline
253 public final <F>
254 Vector<F> reinterpretShape(VectorSpecies<F> toSpecies, int part) {
255 return super.reinterpretShapeTemplate(toSpecies, part); // specialize
256 }
257
258 // Specialized algebraic operations:
259
260 // The following definition forces a specialized version of this
261 // crucial method into the v-table of this class. A call to add()
262 // will inline to a call to lanewise(ADD,), at which point the JIT
263 // intrinsic will have the opcode of ADD, plus all the metadata
264 // for this particular class, enabling it to generate precise
265 // code.
266 //
267 // There is probably no benefit to the JIT to specialize the
268 // masked or broadcast versions of the lanewise method.
269
270 @Override
271 @ForceInline
272 public DoubleMaxVector lanewise(Unary op) {
273 return (DoubleMaxVector) super.lanewiseTemplate(op); // specialize
274 }
275
276 @Override
277 @ForceInline
278 public DoubleMaxVector lanewise(Unary op, VectorMask<Double> m) {
279 return (DoubleMaxVector) super.lanewiseTemplate(op, DoubleMaxMask.class, (DoubleMaxMask) m); // specialize
280 }
281
282 @Override
283 @ForceInline
284 public DoubleMaxVector lanewise(Binary op, Vector<Double> v) {
285 return (DoubleMaxVector) super.lanewiseTemplate(op, v); // specialize
286 }
287
288 @Override
289 @ForceInline
290 public DoubleMaxVector lanewise(Binary op, Vector<Double> v, VectorMask<Double> m) {
291 return (DoubleMaxVector) super.lanewiseTemplate(op, DoubleMaxMask.class, v, (DoubleMaxMask) m); // specialize
292 }
293
294
295 /*package-private*/
296 @Override
297 @ForceInline
298 public final
299 DoubleMaxVector
300 lanewise(Ternary op, Vector<Double> v1, Vector<Double> v2) {
301 return (DoubleMaxVector) super.lanewiseTemplate(op, v1, v2); // specialize
302 }
303
304 @Override
305 @ForceInline
306 public final
307 DoubleMaxVector
308 lanewise(Ternary op, Vector<Double> v1, Vector<Double> v2, VectorMask<Double> m) {
309 return (DoubleMaxVector) super.lanewiseTemplate(op, DoubleMaxMask.class, v1, v2, (DoubleMaxMask) m); // specialize
310 }
311
312 @Override
313 @ForceInline
314 public final
315 DoubleMaxVector addIndex(int scale) {
316 return (DoubleMaxVector) super.addIndexTemplate(scale); // specialize
317 }
318
319 // Type specific horizontal reductions
320
321 @Override
322 @ForceInline
323 public final double reduceLanes(VectorOperators.Associative op) {
324 return super.reduceLanesTemplate(op); // specialized
325 }
326
327 @Override
328 @ForceInline
329 public final double reduceLanes(VectorOperators.Associative op,
330 VectorMask<Double> m) {
331 return super.reduceLanesTemplate(op, DoubleMaxMask.class, (DoubleMaxMask) m); // specialized
332 }
333
334 @Override
335 @ForceInline
336 public final long reduceLanesToLong(VectorOperators.Associative op) {
337 return (long) super.reduceLanesTemplate(op); // specialized
338 }
339
340 @Override
341 @ForceInline
342 public final long reduceLanesToLong(VectorOperators.Associative op,
343 VectorMask<Double> m) {
344 return (long) super.reduceLanesTemplate(op, DoubleMaxMask.class, (DoubleMaxMask) m); // specialized
345 }
346
347 @ForceInline
348 public VectorShuffle<Double> toShuffle() {
349 return super.toShuffleTemplate(DoubleMaxShuffle.class); // specialize
350 }
351
352 // Specialized unary testing
353
354 @Override
355 @ForceInline
356 public final DoubleMaxMask test(Test op) {
357 return super.testTemplate(DoubleMaxMask.class, op); // specialize
358 }
359
360 // Specialized comparisons
361
362 @Override
363 @ForceInline
364 public final DoubleMaxMask compare(Comparison op, Vector<Double> v) {
365 return super.compareTemplate(DoubleMaxMask.class, op, v); // specialize
366 }
367
368 @Override
369 @ForceInline
370 public final DoubleMaxMask compare(Comparison op, double s) {
371 return super.compareTemplate(DoubleMaxMask.class, op, s); // specialize
372 }
373
374 @Override
375 @ForceInline
376 public final DoubleMaxMask compare(Comparison op, long s) {
377 return super.compareTemplate(DoubleMaxMask.class, op, s); // specialize
378 }
379
380 @Override
381 @ForceInline
382 public final DoubleMaxMask compare(Comparison op, Vector<Double> v, VectorMask<Double> m) {
383 return super.compareTemplate(DoubleMaxMask.class, op, v, (DoubleMaxMask) m);
384 }
385
386
387 @Override
388 @ForceInline
389 public DoubleMaxVector blend(Vector<Double> v, VectorMask<Double> m) {
390 return (DoubleMaxVector)
391 super.blendTemplate(DoubleMaxMask.class,
392 (DoubleMaxVector) v,
393 (DoubleMaxMask) m); // specialize
394 }
395
396 @Override
397 @ForceInline
398 public DoubleMaxVector slice(int origin, Vector<Double> v) {
399 return (DoubleMaxVector) super.sliceTemplate(origin, v); // specialize
400 }
401
402 @Override
403 @ForceInline
404 public DoubleMaxVector slice(int origin) {
405 return (DoubleMaxVector) super.sliceTemplate(origin); // specialize
406 }
407
408 @Override
409 @ForceInline
410 public DoubleMaxVector unslice(int origin, Vector<Double> w, int part) {
411 return (DoubleMaxVector) super.unsliceTemplate(origin, w, part); // specialize
412 }
413
414 @Override
415 @ForceInline
416 public DoubleMaxVector unslice(int origin, Vector<Double> w, int part, VectorMask<Double> m) {
417 return (DoubleMaxVector)
418 super.unsliceTemplate(DoubleMaxMask.class,
419 origin, w, part,
420 (DoubleMaxMask) m); // specialize
421 }
422
423 @Override
424 @ForceInline
425 public DoubleMaxVector unslice(int origin) {
426 return (DoubleMaxVector) super.unsliceTemplate(origin); // specialize
427 }
428
429 @Override
430 @ForceInline
431 public DoubleMaxVector rearrange(VectorShuffle<Double> s) {
432 return (DoubleMaxVector)
433 super.rearrangeTemplate(DoubleMaxShuffle.class,
434 (DoubleMaxShuffle) s); // specialize
435 }
436
437 @Override
438 @ForceInline
439 public DoubleMaxVector rearrange(VectorShuffle<Double> shuffle,
440 VectorMask<Double> m) {
441 return (DoubleMaxVector)
442 super.rearrangeTemplate(DoubleMaxShuffle.class,
443 DoubleMaxMask.class,
444 (DoubleMaxShuffle) shuffle,
445 (DoubleMaxMask) m); // specialize
446 }
447
448 @Override
449 @ForceInline
450 public DoubleMaxVector rearrange(VectorShuffle<Double> s,
451 Vector<Double> v) {
452 return (DoubleMaxVector)
453 super.rearrangeTemplate(DoubleMaxShuffle.class,
454 (DoubleMaxShuffle) s,
455 (DoubleMaxVector) v); // specialize
456 }
457
458 @Override
459 @ForceInline
460 public DoubleMaxVector selectFrom(Vector<Double> v) {
461 return (DoubleMaxVector)
462 super.selectFromTemplate((DoubleMaxVector) v); // specialize
463 }
464
465 @Override
466 @ForceInline
467 public DoubleMaxVector selectFrom(Vector<Double> v,
468 VectorMask<Double> m) {
469 return (DoubleMaxVector)
470 super.selectFromTemplate((DoubleMaxVector) v,
471 (DoubleMaxMask) m); // specialize
472 }
473
474
475 @ForceInline
476 @Override
477 public double lane(int i) {
478 if (i < 0 || i >= VLENGTH) {
479 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH);
480 }
481 long bits = laneHelper(i);
482 return Double.longBitsToDouble(bits);
483 }
484
485 public long laneHelper(int i) {
486 return (long) VectorSupport.extract(
487 VCLASS, ETYPE, VLENGTH,
488 this, i,
489 (vec, ix) -> {
490 double[] vecarr = vec.vec();
491 return (long)Double.doubleToLongBits(vecarr[ix]);
492 });
493 }
494
495 @ForceInline
496 @Override
497 public DoubleMaxVector withLane(int i, double e) {
498 if (i < 0 || i >= VLENGTH) {
499 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + VLENGTH);
500 }
501 return withLaneHelper(i, e);
502 }
503
504 public DoubleMaxVector withLaneHelper(int i, double e) {
505 return VectorSupport.insert(
506 VCLASS, ETYPE, VLENGTH,
507 this, i, (long)Double.doubleToLongBits(e),
508 (v, ix, bits) -> {
509 double[] res = v.vec().clone();
510 res[ix] = Double.longBitsToDouble((long)bits);
511 return v.vectorFactory(res);
512 });
513 }
514
515 // Mask
516
517 static final class DoubleMaxMask extends AbstractMask<Double> {
518 static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM
519 static final Class<Double> ETYPE = double.class; // used by the JVM
520
521 DoubleMaxMask(boolean[] bits) {
522 this(bits, 0);
523 }
524
525 DoubleMaxMask(boolean[] bits, int offset) {
526 super(prepare(bits, offset));
527 }
528
529 DoubleMaxMask(boolean val) {
530 super(prepare(val));
531 }
532
533 private static boolean[] prepare(boolean[] bits, int offset) {
534 boolean[] newBits = new boolean[VSPECIES.laneCount()];
535 for (int i = 0; i < newBits.length; i++) {
536 newBits[i] = bits[offset + i];
537 }
538 return newBits;
539 }
540
541 private static boolean[] prepare(boolean val) {
542 boolean[] bits = new boolean[VSPECIES.laneCount()];
543 Arrays.fill(bits, val);
544 return bits;
545 }
546
547 @ForceInline
548 final @Override
549 public DoubleSpecies vspecies() {
550 // ISSUE: This should probably be a @Stable
551 // field inside AbstractMask, rather than
552 // a megamorphic method.
553 return VSPECIES;
554 }
555
556 @ForceInline
557 boolean[] getBits() {
558 return (boolean[])getPayload();
559 }
560
561 @Override
562 DoubleMaxMask uOp(MUnOp f) {
563 boolean[] res = new boolean[vspecies().laneCount()];
564 boolean[] bits = getBits();
565 for (int i = 0; i < res.length; i++) {
566 res[i] = f.apply(i, bits[i]);
567 }
568 return new DoubleMaxMask(res);
569 }
570
571 @Override
572 DoubleMaxMask bOp(VectorMask<Double> m, MBinOp f) {
573 boolean[] res = new boolean[vspecies().laneCount()];
574 boolean[] bits = getBits();
575 boolean[] mbits = ((DoubleMaxMask)m).getBits();
576 for (int i = 0; i < res.length; i++) {
577 res[i] = f.apply(i, bits[i], mbits[i]);
578 }
579 return new DoubleMaxMask(res);
580 }
581
582 @ForceInline
583 @Override
584 public final
585 DoubleMaxVector toVector() {
586 return (DoubleMaxVector) super.toVectorTemplate(); // specialize
587 }
588
589 /**
590 * Helper function for lane-wise mask conversions.
591 * This function kicks in after intrinsic failure.
592 */
593 @ForceInline
594 private final <E>
595 VectorMask<E> defaultMaskCast(AbstractSpecies<E> dsp) {
596 if (length() != dsp.laneCount())
597 throw new IllegalArgumentException("VectorMask length and species length differ");
598 boolean[] maskArray = toArray();
599 return dsp.maskFactory(maskArray).check(dsp);
600 }
601
602 @Override
603 @ForceInline
604 public <E> VectorMask<E> cast(VectorSpecies<E> dsp) {
605 AbstractSpecies<E> species = (AbstractSpecies<E>) dsp;
606 if (length() != species.laneCount())
607 throw new IllegalArgumentException("VectorMask length and species length differ");
608
609 return VectorSupport.convert(VectorSupport.VECTOR_OP_CAST,
610 this.getClass(), ETYPE, VLENGTH,
611 species.maskType(), species.elementType(), VLENGTH,
612 this, species,
613 (m, s) -> s.maskFactory(m.toArray()).check(s));
614 }
615
616 @Override
617 @ForceInline
618 public DoubleMaxMask eq(VectorMask<Double> mask) {
619 Objects.requireNonNull(mask);
620 DoubleMaxMask m = (DoubleMaxMask)mask;
621 return xor(m.not());
622 }
623
624 // Unary operations
625
626 @Override
627 @ForceInline
628 public DoubleMaxMask not() {
629 return xor(maskAll(true));
630 }
631
632 // Binary operations
633
634 @Override
635 @ForceInline
636 public DoubleMaxMask and(VectorMask<Double> mask) {
637 Objects.requireNonNull(mask);
638 DoubleMaxMask m = (DoubleMaxMask)mask;
639 return VectorSupport.binaryOp(VECTOR_OP_AND, DoubleMaxMask.class, null, long.class, VLENGTH,
640 this, m, null,
641 (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b));
642 }
643
644 @Override
645 @ForceInline
646 public DoubleMaxMask or(VectorMask<Double> mask) {
647 Objects.requireNonNull(mask);
648 DoubleMaxMask m = (DoubleMaxMask)mask;
649 return VectorSupport.binaryOp(VECTOR_OP_OR, DoubleMaxMask.class, null, long.class, VLENGTH,
650 this, m, null,
651 (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
652 }
653
654 @ForceInline
655 /* package-private */
656 DoubleMaxMask xor(VectorMask<Double> mask) {
657 Objects.requireNonNull(mask);
658 DoubleMaxMask m = (DoubleMaxMask)mask;
659 return VectorSupport.binaryOp(VECTOR_OP_XOR, DoubleMaxMask.class, null, long.class, VLENGTH,
660 this, m, null,
661 (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a ^ b));
662 }
663
664 // Mask Query operations
665
666 @Override
667 @ForceInline
668 public int trueCount() {
669 return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, DoubleMaxMask.class, long.class, VLENGTH, this,
670 (m) -> trueCountHelper(m.getBits()));
671 }
672
673 @Override
674 @ForceInline
675 public int firstTrue() {
676 return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, DoubleMaxMask.class, long.class, VLENGTH, this,
677 (m) -> firstTrueHelper(m.getBits()));
678 }
679
680 @Override
681 @ForceInline
682 public int lastTrue() {
683 return (int) VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, DoubleMaxMask.class, long.class, VLENGTH, this,
684 (m) -> lastTrueHelper(m.getBits()));
685 }
686
687 @Override
688 @ForceInline
689 public long toLong() {
690 if (length() > Long.SIZE) {
691 throw new UnsupportedOperationException("too many lanes for one long");
692 }
693 return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TOLONG, DoubleMaxMask.class, long.class, VLENGTH, this,
694 (m) -> toLongHelper(m.getBits()));
695 }
696
697 // Reductions
698
699 @Override
700 @ForceInline
701 public boolean anyTrue() {
702 return VectorSupport.test(BT_ne, DoubleMaxMask.class, long.class, VLENGTH,
703 this, vspecies().maskAll(true),
704 (m, __) -> anyTrueHelper(((DoubleMaxMask)m).getBits()));
705 }
706
707 @Override
708 @ForceInline
709 public boolean allTrue() {
710 return VectorSupport.test(BT_overflow, DoubleMaxMask.class, long.class, VLENGTH,
711 this, vspecies().maskAll(true),
712 (m, __) -> allTrueHelper(((DoubleMaxMask)m).getBits()));
713 }
714
715 @ForceInline
716 /*package-private*/
717 static DoubleMaxMask maskAll(boolean bit) {
718 return VectorSupport.broadcastCoerced(DoubleMaxMask.class, long.class, VLENGTH,
719 (bit ? -1 : 0), null,
720 (v, __) -> (v != 0 ? TRUE_MASK : FALSE_MASK));
721 }
722 private static final DoubleMaxMask TRUE_MASK = new DoubleMaxMask(true);
723 private static final DoubleMaxMask FALSE_MASK = new DoubleMaxMask(false);
724
725 }
726
727 // Shuffle
728
729 static final class DoubleMaxShuffle extends AbstractShuffle<Double> {
730 static final int VLENGTH = VSPECIES.laneCount(); // used by the JVM
731 static final Class<Double> ETYPE = double.class; // used by the JVM
732
733 DoubleMaxShuffle(byte[] reorder) {
734 super(VLENGTH, reorder);
735 }
736
737 public DoubleMaxShuffle(int[] reorder) {
738 super(VLENGTH, reorder);
739 }
740
741 public DoubleMaxShuffle(int[] reorder, int i) {
742 super(VLENGTH, reorder, i);
743 }
744
745 public DoubleMaxShuffle(IntUnaryOperator fn) {
746 super(VLENGTH, fn);
747 }
748
749 @Override
750 public DoubleSpecies vspecies() {
751 return VSPECIES;
752 }
753
754 static {
755 // There must be enough bits in the shuffle lanes to encode
756 // VLENGTH valid indexes and VLENGTH exceptional ones.
757 assert(VLENGTH < Byte.MAX_VALUE);
758 assert(Byte.MIN_VALUE <= -VLENGTH);
759 }
760 static final DoubleMaxShuffle IOTA = new DoubleMaxShuffle(IDENTITY);
761
762 @Override
763 @ForceInline
764 public DoubleMaxVector toVector() {
765 return VectorSupport.shuffleToVector(VCLASS, ETYPE, DoubleMaxShuffle.class, this, VLENGTH,
766 (s) -> ((DoubleMaxVector)(((AbstractShuffle<Double>)(s)).toVectorTemplate())));
767 }
768
769 @Override
770 @ForceInline
771 public <F> VectorShuffle<F> cast(VectorSpecies<F> s) {
772 AbstractSpecies<F> species = (AbstractSpecies<F>) s;
773 if (length() != species.laneCount())
774 throw new IllegalArgumentException("VectorShuffle length and species length differ");
775 int[] shuffleArray = toArray();
776 return s.shuffleFromArray(shuffleArray, 0).check(s);
777 }
778
779 @ForceInline
780 @Override
781 public DoubleMaxShuffle rearrange(VectorShuffle<Double> shuffle) {
782 DoubleMaxShuffle s = (DoubleMaxShuffle) shuffle;
783 byte[] reorder1 = reorder();
784 byte[] reorder2 = s.reorder();
785 byte[] r = new byte[reorder1.length];
786 for (int i = 0; i < reorder1.length; i++) {
787 int ssi = reorder2[i];
788 r[i] = reorder1[ssi]; // throws on exceptional index
789 }
790 return new DoubleMaxShuffle(r);
791 }
792 }
793
794 // ================================================
795
796 // Specialized low-level memory operations.
797
798 @ForceInline
799 @Override
800 final
801 DoubleVector fromArray0(double[] a, int offset) {
802 return super.fromArray0Template(a, offset); // specialize
803 }
804
805 @ForceInline
806 @Override
807 final
808 DoubleVector fromArray0(double[] a, int offset, VectorMask<Double> m) {
809 return super.fromArray0Template(DoubleMaxMask.class, a, offset, (DoubleMaxMask) m); // specialize
810 }
811
812 @ForceInline
813 @Override
814 final
815 DoubleVector fromArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Double> m) {
816 return super.fromArray0Template(DoubleMaxMask.class, a, offset, indexMap, mapOffset, (DoubleMaxMask) m);
817 }
818
819
820
821 @ForceInline
822 @Override
823 final
824 DoubleVector fromByteArray0(byte[] a, int offset) {
825 return super.fromByteArray0Template(a, offset); // specialize
826 }
827
828 @ForceInline
829 @Override
830 final
831 DoubleVector fromByteArray0(byte[] a, int offset, VectorMask<Double> m) {
832 return super.fromByteArray0Template(DoubleMaxMask.class, a, offset, (DoubleMaxMask) m); // specialize
833 }
834
835 @ForceInline
836 @Override
837 final
838 DoubleVector fromByteBuffer0(ByteBuffer bb, int offset) {
839 return super.fromByteBuffer0Template(bb, offset); // specialize
840 }
841
842 @ForceInline
843 @Override
844 final
845 DoubleVector fromByteBuffer0(ByteBuffer bb, int offset, VectorMask<Double> m) {
846 return super.fromByteBuffer0Template(DoubleMaxMask.class, bb, offset, (DoubleMaxMask) m); // specialize
847 }
848
849 @ForceInline
850 @Override
851 final
852 void intoArray0(double[] a, int offset) {
853 super.intoArray0Template(a, offset); // specialize
854 }
855
856 @ForceInline
857 @Override
858 final
859 void intoArray0(double[] a, int offset, VectorMask<Double> m) {
860 super.intoArray0Template(DoubleMaxMask.class, a, offset, (DoubleMaxMask) m);
861 }
862
863 @ForceInline
864 @Override
865 final
866 void intoArray0(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Double> m) {
867 super.intoArray0Template(DoubleMaxMask.class, a, offset, indexMap, mapOffset, (DoubleMaxMask) m);
868 }
869
870
871 @ForceInline
872 @Override
873 final
874 void intoByteArray0(byte[] a, int offset) {
875 super.intoByteArray0Template(a, offset); // specialize
876 }
877
878 @ForceInline
879 @Override
880 final
881 void intoByteArray0(byte[] a, int offset, VectorMask<Double> m) {
882 super.intoByteArray0Template(DoubleMaxMask.class, a, offset, (DoubleMaxMask) m); // specialize
883 }
884
885 @ForceInline
886 @Override
887 final
888 void intoByteBuffer0(ByteBuffer bb, int offset, VectorMask<Double> m) {
889 super.intoByteBuffer0Template(DoubleMaxMask.class, bb, offset, (DoubleMaxMask) m);
890 }
891
892
893 // End of specialized low-level memory operations.
894
895 // ================================================
896
897 }