< prev index next >

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

Print this page

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
















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

626                 this, species,
627                 (m, s) -> s.maskFactory(m.toArray()).check(s));
628         }
629 
630         @Override
631         @ForceInline
632         public Int64Mask eq(VectorMask<Integer> mask) {
633             Objects.requireNonNull(mask);
634             Int64Mask m = (Int64Mask)mask;
635             return xor(m.not());
636         }
637 
638         // Unary operations
639 
640         @Override
641         @ForceInline
642         public Int64Mask not() {
643             return xor(maskAll(true));
644         }
645 









646         // Binary operations
647 
648         @Override
649         @ForceInline
650         public Int64Mask and(VectorMask<Integer> mask) {
651             Objects.requireNonNull(mask);
652             Int64Mask m = (Int64Mask)mask;
653             return VectorSupport.binaryOp(VECTOR_OP_AND, Int64Mask.class, null, int.class, VLENGTH,
654                                           this, m, null,
655                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b));
656         }
657 
658         @Override
659         @ForceInline
660         public Int64Mask or(VectorMask<Integer> mask) {
661             Objects.requireNonNull(mask);
662             Int64Mask m = (Int64Mask)mask;
663             return VectorSupport.binaryOp(VECTOR_OP_OR, Int64Mask.class, null, int.class, VLENGTH,
664                                           this, m, null,
665                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));

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

642                 this, species,
643                 (m, s) -> s.maskFactory(m.toArray()).check(s));
644         }
645 
646         @Override
647         @ForceInline
648         public Int64Mask eq(VectorMask<Integer> mask) {
649             Objects.requireNonNull(mask);
650             Int64Mask m = (Int64Mask)mask;
651             return xor(m.not());
652         }
653 
654         // Unary operations
655 
656         @Override
657         @ForceInline
658         public Int64Mask not() {
659             return xor(maskAll(true));
660         }
661 
662         @Override
663         @ForceInline
664         public Int64Mask compress() {
665             return (Int64Mask)VectorSupport.comExpOp(VectorSupport.VECTOR_OP_MASK_COMPRESS,
666                 Int64Vector.class, Int64Mask.class, ETYPE, VLENGTH, null, this,
667                 (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount()));
668         }
669 
670 
671         // Binary operations
672 
673         @Override
674         @ForceInline
675         public Int64Mask and(VectorMask<Integer> mask) {
676             Objects.requireNonNull(mask);
677             Int64Mask m = (Int64Mask)mask;
678             return VectorSupport.binaryOp(VECTOR_OP_AND, Int64Mask.class, null, int.class, VLENGTH,
679                                           this, m, null,
680                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b));
681         }
682 
683         @Override
684         @ForceInline
685         public Int64Mask or(VectorMask<Integer> mask) {
686             Objects.requireNonNull(mask);
687             Int64Mask m = (Int64Mask)mask;
688             return VectorSupport.binaryOp(VECTOR_OP_OR, Int64Mask.class, null, int.class, VLENGTH,
689                                           this, m, null,
690                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
< prev index next >