< prev index next >

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

Print this page

451     @ForceInline
452     public Byte128Vector rearrange(VectorShuffle<Byte> shuffle,
453                                   VectorMask<Byte> m) {
454         return (Byte128Vector)
455             super.rearrangeTemplate(Byte128Shuffle.class,
456                                     Byte128Mask.class,
457                                     (Byte128Shuffle) shuffle,
458                                     (Byte128Mask) m);  // specialize
459     }
460 
461     @Override
462     @ForceInline
463     public Byte128Vector rearrange(VectorShuffle<Byte> s,
464                                   Vector<Byte> v) {
465         return (Byte128Vector)
466             super.rearrangeTemplate(Byte128Shuffle.class,
467                                     (Byte128Shuffle) s,
468                                     (Byte128Vector) v);  // specialize
469     }
470 
















471     @Override
472     @ForceInline
473     public Byte128Vector selectFrom(Vector<Byte> v) {
474         return (Byte128Vector)
475             super.selectFromTemplate((Byte128Vector) v);  // specialize
476     }
477 
478     @Override
479     @ForceInline
480     public Byte128Vector selectFrom(Vector<Byte> v,
481                                    VectorMask<Byte> m) {
482         return (Byte128Vector)
483             super.selectFromTemplate((Byte128Vector) v,
484                                      (Byte128Mask) m);  // specialize
485     }
486 
487 
488     @ForceInline
489     @Override
490     public byte lane(int i) {

654                 this, species,
655                 (m, s) -> s.maskFactory(m.toArray()).check(s));
656         }
657 
658         @Override
659         @ForceInline
660         public Byte128Mask eq(VectorMask<Byte> mask) {
661             Objects.requireNonNull(mask);
662             Byte128Mask m = (Byte128Mask)mask;
663             return xor(m.not());
664         }
665 
666         // Unary operations
667 
668         @Override
669         @ForceInline
670         public Byte128Mask not() {
671             return xor(maskAll(true));
672         }
673 









674         // Binary operations
675 
676         @Override
677         @ForceInline
678         public Byte128Mask and(VectorMask<Byte> mask) {
679             Objects.requireNonNull(mask);
680             Byte128Mask m = (Byte128Mask)mask;
681             return VectorSupport.binaryOp(VECTOR_OP_AND, Byte128Mask.class, null, byte.class, VLENGTH,
682                                           this, m, null,
683                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b));
684         }
685 
686         @Override
687         @ForceInline
688         public Byte128Mask or(VectorMask<Byte> mask) {
689             Objects.requireNonNull(mask);
690             Byte128Mask m = (Byte128Mask)mask;
691             return VectorSupport.binaryOp(VECTOR_OP_OR, Byte128Mask.class, null, byte.class, VLENGTH,
692                                           this, m, null,
693                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));

451     @ForceInline
452     public Byte128Vector rearrange(VectorShuffle<Byte> shuffle,
453                                   VectorMask<Byte> m) {
454         return (Byte128Vector)
455             super.rearrangeTemplate(Byte128Shuffle.class,
456                                     Byte128Mask.class,
457                                     (Byte128Shuffle) shuffle,
458                                     (Byte128Mask) m);  // specialize
459     }
460 
461     @Override
462     @ForceInline
463     public Byte128Vector rearrange(VectorShuffle<Byte> s,
464                                   Vector<Byte> v) {
465         return (Byte128Vector)
466             super.rearrangeTemplate(Byte128Shuffle.class,
467                                     (Byte128Shuffle) s,
468                                     (Byte128Vector) v);  // specialize
469     }
470 
471     @Override
472     @ForceInline
473     public Byte128Vector compress(VectorMask<Byte> m) {
474         return (Byte128Vector)
475             super.compressTemplate(Byte128Mask.class,
476                                    (Byte128Mask) m);  // specialize
477     }
478 
479     @Override
480     @ForceInline
481     public Byte128Vector expand(VectorMask<Byte> m) {
482         return (Byte128Vector)
483             super.expandTemplate(Byte128Mask.class,
484                                    (Byte128Mask) m);  // specialize
485     }
486 
487     @Override
488     @ForceInline
489     public Byte128Vector selectFrom(Vector<Byte> v) {
490         return (Byte128Vector)
491             super.selectFromTemplate((Byte128Vector) v);  // specialize
492     }
493 
494     @Override
495     @ForceInline
496     public Byte128Vector selectFrom(Vector<Byte> v,
497                                    VectorMask<Byte> m) {
498         return (Byte128Vector)
499             super.selectFromTemplate((Byte128Vector) v,
500                                      (Byte128Mask) m);  // specialize
501     }
502 
503 
504     @ForceInline
505     @Override
506     public byte lane(int i) {

670                 this, species,
671                 (m, s) -> s.maskFactory(m.toArray()).check(s));
672         }
673 
674         @Override
675         @ForceInline
676         public Byte128Mask eq(VectorMask<Byte> mask) {
677             Objects.requireNonNull(mask);
678             Byte128Mask m = (Byte128Mask)mask;
679             return xor(m.not());
680         }
681 
682         // Unary operations
683 
684         @Override
685         @ForceInline
686         public Byte128Mask not() {
687             return xor(maskAll(true));
688         }
689 
690         @Override
691         @ForceInline
692         public Byte128Mask compress() {
693             return (Byte128Mask)VectorSupport.comExpOp(VectorSupport.VECTOR_OP_MASK_COMPRESS,
694                 Byte128Vector.class, Byte128Mask.class, ETYPE, VLENGTH, null, this,
695                 (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount()));
696         }
697 
698 
699         // Binary operations
700 
701         @Override
702         @ForceInline
703         public Byte128Mask and(VectorMask<Byte> mask) {
704             Objects.requireNonNull(mask);
705             Byte128Mask m = (Byte128Mask)mask;
706             return VectorSupport.binaryOp(VECTOR_OP_AND, Byte128Mask.class, null, byte.class, VLENGTH,
707                                           this, m, null,
708                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b));
709         }
710 
711         @Override
712         @ForceInline
713         public Byte128Mask or(VectorMask<Byte> mask) {
714             Objects.requireNonNull(mask);
715             Byte128Mask m = (Byte128Mask)mask;
716             return VectorSupport.binaryOp(VECTOR_OP_OR, Byte128Mask.class, null, byte.class, VLENGTH,
717                                           this, m, null,
718                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
< prev index next >