< prev index next >

src/jdk.incubator.vector/share/classes/jdk/incubator/vector/FloatMaxVector.java

Print this page

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     }
464 
465     @Override
466     @ForceInline
467     public FloatMaxVector selectFrom(Vector<Float> v,
468                                    VectorMask<Float> m) {
469         return (FloatMaxVector)
470             super.selectFromTemplate((FloatMaxVector) v,
471                                      (FloatMaxMask) m);  // specialize
472     }
473 
474 
475     @ForceInline
476     @Override
477     public float lane(int i) {

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));

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 compress(VectorMask<Float> m) {
461         return (FloatMaxVector)
462             super.compressTemplate(FloatMaxMask.class,
463                                    (FloatMaxMask) m);  // specialize
464     }
465 
466     @Override
467     @ForceInline
468     public FloatMaxVector expand(VectorMask<Float> m) {
469         return (FloatMaxVector)
470             super.expandTemplate(FloatMaxMask.class,
471                                    (FloatMaxMask) m);  // specialize
472     }
473 
474     @Override
475     @ForceInline
476     public FloatMaxVector selectFrom(Vector<Float> v) {
477         return (FloatMaxVector)
478             super.selectFromTemplate((FloatMaxVector) v);  // specialize
479     }
480 
481     @Override
482     @ForceInline
483     public FloatMaxVector selectFrom(Vector<Float> v,
484                                    VectorMask<Float> m) {
485         return (FloatMaxVector)
486             super.selectFromTemplate((FloatMaxVector) v,
487                                      (FloatMaxMask) m);  // specialize
488     }
489 
490 
491     @ForceInline
492     @Override
493     public float lane(int i) {

628                 this, species,
629                 (m, s) -> s.maskFactory(m.toArray()).check(s));
630         }
631 
632         @Override
633         @ForceInline
634         public FloatMaxMask eq(VectorMask<Float> mask) {
635             Objects.requireNonNull(mask);
636             FloatMaxMask m = (FloatMaxMask)mask;
637             return xor(m.not());
638         }
639 
640         // Unary operations
641 
642         @Override
643         @ForceInline
644         public FloatMaxMask not() {
645             return xor(maskAll(true));
646         }
647 
648         @Override
649         @ForceInline
650         public FloatMaxMask compress() {
651             return (FloatMaxMask)VectorSupport.comExpOp(VectorSupport.VECTOR_OP_MASK_COMPRESS,
652                 FloatMaxVector.class, FloatMaxMask.class, ETYPE, VLENGTH, null, this,
653                 (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount()));
654         }
655 
656 
657         // Binary operations
658 
659         @Override
660         @ForceInline
661         public FloatMaxMask and(VectorMask<Float> mask) {
662             Objects.requireNonNull(mask);
663             FloatMaxMask m = (FloatMaxMask)mask;
664             return VectorSupport.binaryOp(VECTOR_OP_AND, FloatMaxMask.class, null, int.class, VLENGTH,
665                                           this, m, null,
666                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b));
667         }
668 
669         @Override
670         @ForceInline
671         public FloatMaxMask or(VectorMask<Float> mask) {
672             Objects.requireNonNull(mask);
673             FloatMaxMask m = (FloatMaxMask)mask;
674             return VectorSupport.binaryOp(VECTOR_OP_OR, FloatMaxMask.class, null, int.class, VLENGTH,
675                                           this, m, null,
676                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
< prev index next >