219
220 @ForceInline
221 final @Override
222 FloatMaxVector tOp(Vector<Float> v1, Vector<Float> v2, FTriOp f) {
223 return (FloatMaxVector)
224 super.tOpTemplate((FloatMaxVector)v1, (FloatMaxVector)v2,
225 f); // specialize
226 }
227
228 @ForceInline
229 final @Override
230 FloatMaxVector tOp(Vector<Float> v1, Vector<Float> v2,
231 VectorMask<Float> m, FTriOp f) {
232 return (FloatMaxVector)
233 super.tOpTemplate((FloatMaxVector)v1, (FloatMaxVector)v2,
234 (FloatMaxMask)m, f); // specialize
235 }
236
237 @ForceInline
238 final @Override
239 float rOp(float v, FBinOp f) {
240 return super.rOpTemplate(v, f); // specialize
241 }
242
243 @Override
244 @ForceInline
245 public final <F>
246 Vector<F> convertShape(VectorOperators.Conversion<Float,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 FloatMaxVector lanewise(Unary op) {
273 return (FloatMaxVector) super.lanewiseTemplate(op); // specialize
274 }
275
276 @Override
277 @ForceInline
278 public FloatMaxVector lanewise(Binary op, Vector<Float> v) {
279 return (FloatMaxVector) super.lanewiseTemplate(op, v); // specialize
280 }
281
282
283 /*package-private*/
284 @Override
285 @ForceInline
286 public final
287 FloatMaxVector
288 lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2) {
289 return (FloatMaxVector) super.lanewiseTemplate(op, v1, v2); // specialize
290 }
291
292 @Override
293 @ForceInline
294 public final
295 FloatMaxVector addIndex(int scale) {
296 return (FloatMaxVector) super.addIndexTemplate(scale); // specialize
297 }
298
299 // Type specific horizontal reductions
300
301 @Override
302 @ForceInline
303 public final float reduceLanes(VectorOperators.Associative op) {
304 return super.reduceLanesTemplate(op); // specialized
305 }
306
307 @Override
308 @ForceInline
309 public final float reduceLanes(VectorOperators.Associative op,
310 VectorMask<Float> m) {
311 return super.reduceLanesTemplate(op, m); // specialized
312 }
313
314 @Override
315 @ForceInline
316 public final long reduceLanesToLong(VectorOperators.Associative op) {
317 return (long) super.reduceLanesTemplate(op); // specialized
318 }
319
320 @Override
321 @ForceInline
322 public final long reduceLanesToLong(VectorOperators.Associative op,
323 VectorMask<Float> m) {
324 return (long) super.reduceLanesTemplate(op, m); // specialized
325 }
326
327 @ForceInline
328 public VectorShuffle<Float> toShuffle() {
329 return super.toShuffleTemplate(FloatMaxShuffle.class); // specialize
330 }
331
332 // Specialized unary testing
333
334 @Override
335 @ForceInline
336 public final FloatMaxMask test(Test op) {
337 return super.testTemplate(FloatMaxMask.class, op); // specialize
338 }
339
340 // Specialized comparisons
341
342 @Override
343 @ForceInline
344 public final FloatMaxMask compare(Comparison op, Vector<Float> v) {
345 return super.compareTemplate(FloatMaxMask.class, op, v); // specialize
346 }
347
348 @Override
349 @ForceInline
350 public final FloatMaxMask compare(Comparison op, float s) {
351 return super.compareTemplate(FloatMaxMask.class, op, s); // specialize
352 }
353
354 @Override
355 @ForceInline
356 public final FloatMaxMask compare(Comparison op, long s) {
357 return super.compareTemplate(FloatMaxMask.class, op, s); // specialize
358 }
359
360 @Override
361 @ForceInline
362 public FloatMaxVector blend(Vector<Float> v, VectorMask<Float> m) {
363 return (FloatMaxVector)
364 super.blendTemplate(FloatMaxMask.class,
365 (FloatMaxVector) v,
366 (FloatMaxMask) m); // specialize
367 }
368
369 @Override
370 @ForceInline
371 public FloatMaxVector slice(int origin, Vector<Float> v) {
372 return (FloatMaxVector) super.sliceTemplate(origin, v); // specialize
373 }
374
375 @Override
376 @ForceInline
377 public FloatMaxVector slice(int origin) {
378 return (FloatMaxVector) super.sliceTemplate(origin); // specialize
379 }
396 @Override
397 @ForceInline
398 public FloatMaxVector unslice(int origin) {
399 return (FloatMaxVector) super.unsliceTemplate(origin); // specialize
400 }
401
402 @Override
403 @ForceInline
404 public FloatMaxVector rearrange(VectorShuffle<Float> s) {
405 return (FloatMaxVector)
406 super.rearrangeTemplate(FloatMaxShuffle.class,
407 (FloatMaxShuffle) s); // specialize
408 }
409
410 @Override
411 @ForceInline
412 public FloatMaxVector rearrange(VectorShuffle<Float> shuffle,
413 VectorMask<Float> m) {
414 return (FloatMaxVector)
415 super.rearrangeTemplate(FloatMaxShuffle.class,
416 (FloatMaxShuffle) shuffle,
417 (FloatMaxMask) m); // specialize
418 }
419
420 @Override
421 @ForceInline
422 public FloatMaxVector rearrange(VectorShuffle<Float> s,
423 Vector<Float> v) {
424 return (FloatMaxVector)
425 super.rearrangeTemplate(FloatMaxShuffle.class,
426 (FloatMaxShuffle) s,
427 (FloatMaxVector) v); // specialize
428 }
429
430 @Override
431 @ForceInline
432 public FloatMaxVector selectFrom(Vector<Float> v) {
433 return (FloatMaxVector)
434 super.selectFromTemplate((FloatMaxVector) v); // specialize
435 }
560
561 /**
562 * Helper function for lane-wise mask conversions.
563 * This function kicks in after intrinsic failure.
564 */
565 @ForceInline
566 private final <E>
567 VectorMask<E> defaultMaskCast(AbstractSpecies<E> dsp) {
568 if (length() != dsp.laneCount())
569 throw new IllegalArgumentException("VectorMask length and species length differ");
570 boolean[] maskArray = toArray();
571 return dsp.maskFactory(maskArray).check(dsp);
572 }
573
574 @Override
575 @ForceInline
576 public <E> VectorMask<E> cast(VectorSpecies<E> dsp) {
577 AbstractSpecies<E> species = (AbstractSpecies<E>) dsp;
578 if (length() != species.laneCount())
579 throw new IllegalArgumentException("VectorMask length and species length differ");
580 if (VSIZE == species.vectorBitSize()) {
581 Class<?> dtype = species.elementType();
582 Class<?> dmtype = species.maskType();
583 return VectorSupport.convert(VectorSupport.VECTOR_OP_REINTERPRET,
584 this.getClass(), ETYPE, VLENGTH,
585 dmtype, dtype, VLENGTH,
586 this, species,
587 FloatMaxMask::defaultMaskCast);
588 }
589 return this.defaultMaskCast(species);
590 }
591
592 @Override
593 @ForceInline
594 public FloatMaxMask eq(VectorMask<Float> mask) {
595 Objects.requireNonNull(mask);
596 FloatMaxMask m = (FloatMaxMask)mask;
597 return xor(m.not());
598 }
599
600 // Unary operations
601
602 @Override
603 @ForceInline
604 public FloatMaxMask not() {
605 return xor(maskAll(true));
606 }
607
608 // Binary operations
609
610 @Override
611 @ForceInline
612 public FloatMaxMask and(VectorMask<Float> mask) {
613 Objects.requireNonNull(mask);
614 FloatMaxMask m = (FloatMaxMask)mask;
615 return VectorSupport.binaryOp(VECTOR_OP_AND, FloatMaxMask.class, int.class, VLENGTH,
616 this, m,
617 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b));
618 }
619
620 @Override
621 @ForceInline
622 public FloatMaxMask or(VectorMask<Float> mask) {
623 Objects.requireNonNull(mask);
624 FloatMaxMask m = (FloatMaxMask)mask;
625 return VectorSupport.binaryOp(VECTOR_OP_OR, FloatMaxMask.class, int.class, VLENGTH,
626 this, m,
627 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b));
628 }
629
630 @ForceInline
631 /* package-private */
632 FloatMaxMask xor(VectorMask<Float> mask) {
633 Objects.requireNonNull(mask);
634 FloatMaxMask m = (FloatMaxMask)mask;
635 return VectorSupport.binaryOp(VECTOR_OP_XOR, FloatMaxMask.class, int.class, VLENGTH,
636 this, m,
637 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a ^ b));
638 }
639
640 // Mask Query operations
641
642 @Override
643 @ForceInline
644 public int trueCount() {
645 return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_TRUECOUNT, FloatMaxMask.class, int.class, VLENGTH, this,
646 (m) -> trueCountHelper(((FloatMaxMask)m).getBits()));
647 }
648
649 @Override
650 @ForceInline
651 public int firstTrue() {
652 return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_FIRSTTRUE, FloatMaxMask.class, int.class, VLENGTH, this,
653 (m) -> firstTrueHelper(((FloatMaxMask)m).getBits()));
654 }
655
656 @Override
657 @ForceInline
658 public int lastTrue() {
659 return VectorSupport.maskReductionCoerced(VECTOR_OP_MASK_LASTTRUE, FloatMaxMask.class, int.class, VLENGTH, this,
660 (m) -> lastTrueHelper(((FloatMaxMask)m).getBits()));
661 }
662
663 // Reductions
664
665 @Override
666 @ForceInline
667 public boolean anyTrue() {
668 return VectorSupport.test(BT_ne, FloatMaxMask.class, int.class, VLENGTH,
669 this, vspecies().maskAll(true),
670 (m, __) -> anyTrueHelper(((FloatMaxMask)m).getBits()));
671 }
672
673 @Override
674 @ForceInline
675 public boolean allTrue() {
676 return VectorSupport.test(BT_overflow, FloatMaxMask.class, int.class, VLENGTH,
677 this, vspecies().maskAll(true),
678 (m, __) -> allTrueHelper(((FloatMaxMask)m).getBits()));
679 }
680
751 byte[] r = new byte[reorder1.length];
752 for (int i = 0; i < reorder1.length; i++) {
753 int ssi = reorder2[i];
754 r[i] = reorder1[ssi]; // throws on exceptional index
755 }
756 return new FloatMaxShuffle(r);
757 }
758 }
759
760 // ================================================
761
762 // Specialized low-level memory operations.
763
764 @ForceInline
765 @Override
766 final
767 FloatVector fromArray0(float[] a, int offset) {
768 return super.fromArray0Template(a, offset); // specialize
769 }
770
771
772
773 @ForceInline
774 @Override
775 final
776 FloatVector fromByteArray0(byte[] a, int offset) {
777 return super.fromByteArray0Template(a, offset); // specialize
778 }
779
780 @ForceInline
781 @Override
782 final
783 FloatVector fromByteBuffer0(ByteBuffer bb, int offset) {
784 return super.fromByteBuffer0Template(bb, offset); // specialize
785 }
786
787 @ForceInline
788 @Override
789 final
790 void intoArray0(float[] a, int offset) {
791 super.intoArray0Template(a, offset); // specialize
792 }
793
794 @ForceInline
795 @Override
796 final
797 void intoByteArray0(byte[] a, int offset) {
798 super.intoByteArray0Template(a, offset); // specialize
799 }
800
801 // End of specialized low-level memory operations.
802
803 // ================================================
804
805 }
|
219
220 @ForceInline
221 final @Override
222 FloatMaxVector tOp(Vector<Float> v1, Vector<Float> v2, FTriOp f) {
223 return (FloatMaxVector)
224 super.tOpTemplate((FloatMaxVector)v1, (FloatMaxVector)v2,
225 f); // specialize
226 }
227
228 @ForceInline
229 final @Override
230 FloatMaxVector tOp(Vector<Float> v1, Vector<Float> v2,
231 VectorMask<Float> m, FTriOp f) {
232 return (FloatMaxVector)
233 super.tOpTemplate((FloatMaxVector)v1, (FloatMaxVector)v2,
234 (FloatMaxMask)m, f); // specialize
235 }
236
237 @ForceInline
238 final @Override
239 float rOp(float v, VectorMask<Float> 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<Float,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 FloatMaxVector lanewise(Unary op) {
273 return (FloatMaxVector) super.lanewiseTemplate(op); // specialize
274 }
275
276 @Override
277 @ForceInline
278 public FloatMaxVector lanewise(Unary op, VectorMask<Float> m) {
279 return (FloatMaxVector) super.lanewiseTemplate(op, FloatMaxMask.class, (FloatMaxMask) m); // specialize
280 }
281
282 @Override
283 @ForceInline
284 public FloatMaxVector lanewise(Binary op, Vector<Float> v) {
285 return (FloatMaxVector) super.lanewiseTemplate(op, v); // specialize
286 }
287
288 @Override
289 @ForceInline
290 public FloatMaxVector lanewise(Binary op, Vector<Float> v, VectorMask<Float> m) {
291 return (FloatMaxVector) super.lanewiseTemplate(op, FloatMaxMask.class, v, (FloatMaxMask) m); // specialize
292 }
293
294
295 /*package-private*/
296 @Override
297 @ForceInline
298 public final
299 FloatMaxVector
300 lanewise(Ternary op, Vector<Float> v1, Vector<Float> v2) {
301 return (FloatMaxVector) super.lanewiseTemplate(op, v1, v2); // specialize
302 }
303
304 @Override
305 @ForceInline
306 public final
307 FloatMaxVector
308 lanewise(Ternary op, Vector<Float> v1, Vector<Float> v2, VectorMask<Float> m) {
309 return (FloatMaxVector) super.lanewiseTemplate(op, FloatMaxMask.class, v1, v2, (FloatMaxMask) m); // specialize
310 }
311
312 @Override
313 @ForceInline
314 public final
315 FloatMaxVector addIndex(int scale) {
316 return (FloatMaxVector) super.addIndexTemplate(scale); // specialize
317 }
318
319 // Type specific horizontal reductions
320
321 @Override
322 @ForceInline
323 public final float reduceLanes(VectorOperators.Associative op) {
324 return super.reduceLanesTemplate(op); // specialized
325 }
326
327 @Override
328 @ForceInline
329 public final float reduceLanes(VectorOperators.Associative op,
330 VectorMask<Float> m) {
331 return super.reduceLanesTemplate(op, FloatMaxMask.class, (FloatMaxMask) 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<Float> m) {
344 return (long) super.reduceLanesTemplate(op, FloatMaxMask.class, (FloatMaxMask) m); // specialized
345 }
346
347 @ForceInline
348 public VectorShuffle<Float> toShuffle() {
349 return super.toShuffleTemplate(FloatMaxShuffle.class); // specialize
350 }
351
352 // Specialized unary testing
353
354 @Override
355 @ForceInline
356 public final FloatMaxMask test(Test op) {
357 return super.testTemplate(FloatMaxMask.class, op); // specialize
358 }
359
360 // Specialized comparisons
361
362 @Override
363 @ForceInline
364 public final FloatMaxMask compare(Comparison op, Vector<Float> v) {
365 return super.compareTemplate(FloatMaxMask.class, op, v); // specialize
366 }
367
368 @Override
369 @ForceInline
370 public final FloatMaxMask compare(Comparison op, float s) {
371 return super.compareTemplate(FloatMaxMask.class, op, s); // specialize
372 }
373
374 @Override
375 @ForceInline
376 public final FloatMaxMask compare(Comparison op, long s) {
377 return super.compareTemplate(FloatMaxMask.class, op, s); // specialize
378 }
379
380 @Override
381 @ForceInline
382 public final FloatMaxMask compare(Comparison op, Vector<Float> v, VectorMask<Float> m) {
383 return super.compareTemplate(FloatMaxMask.class, op, v, (FloatMaxMask) m);
384 }
385
386
387 @Override
388 @ForceInline
389 public FloatMaxVector blend(Vector<Float> v, VectorMask<Float> m) {
390 return (FloatMaxVector)
391 super.blendTemplate(FloatMaxMask.class,
392 (FloatMaxVector) v,
393 (FloatMaxMask) m); // specialize
394 }
395
396 @Override
397 @ForceInline
398 public FloatMaxVector slice(int origin, Vector<Float> v) {
399 return (FloatMaxVector) super.sliceTemplate(origin, v); // specialize
400 }
401
402 @Override
403 @ForceInline
404 public FloatMaxVector slice(int origin) {
405 return (FloatMaxVector) super.sliceTemplate(origin); // specialize
406 }
423 @Override
424 @ForceInline
425 public FloatMaxVector unslice(int origin) {
426 return (FloatMaxVector) super.unsliceTemplate(origin); // specialize
427 }
428
429 @Override
430 @ForceInline
431 public FloatMaxVector rearrange(VectorShuffle<Float> s) {
432 return (FloatMaxVector)
433 super.rearrangeTemplate(FloatMaxShuffle.class,
434 (FloatMaxShuffle) s); // specialize
435 }
436
437 @Override
438 @ForceInline
439 public FloatMaxVector rearrange(VectorShuffle<Float> shuffle,
440 VectorMask<Float> m) {
441 return (FloatMaxVector)
442 super.rearrangeTemplate(FloatMaxShuffle.class,
443 FloatMaxMask.class,
444 (FloatMaxShuffle) shuffle,
445 (FloatMaxMask) m); // specialize
446 }
447
448 @Override
449 @ForceInline
450 public FloatMaxVector rearrange(VectorShuffle<Float> s,
451 Vector<Float> v) {
452 return (FloatMaxVector)
453 super.rearrangeTemplate(FloatMaxShuffle.class,
454 (FloatMaxShuffle) s,
455 (FloatMaxVector) v); // specialize
456 }
457
458 @Override
459 @ForceInline
460 public FloatMaxVector selectFrom(Vector<Float> v) {
461 return (FloatMaxVector)
462 super.selectFromTemplate((FloatMaxVector) v); // specialize
463 }
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 FloatMaxMask eq(VectorMask<Float> mask) {
619 Objects.requireNonNull(mask);
620 FloatMaxMask m = (FloatMaxMask)mask;
621 return xor(m.not());
622 }
623
624 // Unary operations
625
626 @Override
627 @ForceInline
628 public FloatMaxMask not() {
629 return xor(maskAll(true));
630 }
631
632 // Binary operations
633
634 @Override
635 @ForceInline
636 public FloatMaxMask and(VectorMask<Float> mask) {
637 Objects.requireNonNull(mask);
638 FloatMaxMask m = (FloatMaxMask)mask;
639 return VectorSupport.binaryOp(VECTOR_OP_AND, FloatMaxMask.class, null, int.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 FloatMaxMask or(VectorMask<Float> mask) {
647 Objects.requireNonNull(mask);
648 FloatMaxMask m = (FloatMaxMask)mask;
649 return VectorSupport.binaryOp(VECTOR_OP_OR, FloatMaxMask.class, null, int.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 FloatMaxMask xor(VectorMask<Float> mask) {
657 Objects.requireNonNull(mask);
658 FloatMaxMask m = (FloatMaxMask)mask;
659 return VectorSupport.binaryOp(VECTOR_OP_XOR, FloatMaxMask.class, null, int.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, FloatMaxMask.class, int.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, FloatMaxMask.class, int.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, FloatMaxMask.class, int.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, FloatMaxMask.class, int.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, FloatMaxMask.class, int.class, VLENGTH,
703 this, vspecies().maskAll(true),
704 (m, __) -> anyTrueHelper(((FloatMaxMask)m).getBits()));
705 }
706
707 @Override
708 @ForceInline
709 public boolean allTrue() {
710 return VectorSupport.test(BT_overflow, FloatMaxMask.class, int.class, VLENGTH,
711 this, vspecies().maskAll(true),
712 (m, __) -> allTrueHelper(((FloatMaxMask)m).getBits()));
713 }
714
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 FloatMaxShuffle(r);
791 }
792 }
793
794 // ================================================
795
796 // Specialized low-level memory operations.
797
798 @ForceInline
799 @Override
800 final
801 FloatVector fromArray0(float[] a, int offset) {
802 return super.fromArray0Template(a, offset); // specialize
803 }
804
805 @ForceInline
806 @Override
807 final
808 FloatVector fromArray0(float[] a, int offset, VectorMask<Float> m) {
809 return super.fromArray0Template(FloatMaxMask.class, a, offset, (FloatMaxMask) m); // specialize
810 }
811
812 @ForceInline
813 @Override
814 final
815 FloatVector fromArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m) {
816 return super.fromArray0Template(FloatMaxMask.class, a, offset, indexMap, mapOffset, (FloatMaxMask) m);
817 }
818
819
820
821 @ForceInline
822 @Override
823 final
824 FloatVector fromByteArray0(byte[] a, int offset) {
825 return super.fromByteArray0Template(a, offset); // specialize
826 }
827
828 @ForceInline
829 @Override
830 final
831 FloatVector fromByteArray0(byte[] a, int offset, VectorMask<Float> m) {
832 return super.fromByteArray0Template(FloatMaxMask.class, a, offset, (FloatMaxMask) m); // specialize
833 }
834
835 @ForceInline
836 @Override
837 final
838 FloatVector fromByteBuffer0(ByteBuffer bb, int offset) {
839 return super.fromByteBuffer0Template(bb, offset); // specialize
840 }
841
842 @ForceInline
843 @Override
844 final
845 FloatVector fromByteBuffer0(ByteBuffer bb, int offset, VectorMask<Float> m) {
846 return super.fromByteBuffer0Template(FloatMaxMask.class, bb, offset, (FloatMaxMask) m); // specialize
847 }
848
849 @ForceInline
850 @Override
851 final
852 void intoArray0(float[] a, int offset) {
853 super.intoArray0Template(a, offset); // specialize
854 }
855
856 @ForceInline
857 @Override
858 final
859 void intoArray0(float[] a, int offset, VectorMask<Float> m) {
860 super.intoArray0Template(FloatMaxMask.class, a, offset, (FloatMaxMask) m);
861 }
862
863 @ForceInline
864 @Override
865 final
866 void intoArray0(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m) {
867 super.intoArray0Template(FloatMaxMask.class, a, offset, indexMap, mapOffset, (FloatMaxMask) 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<Float> m) {
882 super.intoByteArray0Template(FloatMaxMask.class, a, offset, (FloatMaxMask) m); // specialize
883 }
884
885 @ForceInline
886 @Override
887 final
888 void intoByteBuffer0(ByteBuffer bb, int offset, VectorMask<Float> m) {
889 super.intoByteBuffer0Template(FloatMaxMask.class, bb, offset, (FloatMaxMask) m);
890 }
891
892
893 // End of specialized low-level memory operations.
894
895 // ================================================
896
897 }
|