< prev index next >

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

Print this page

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
















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

 686                 this, species,
 687                 (m, s) -> s.maskFactory(m.toArray()).check(s));
 688         }
 689 
 690         @Override
 691         @ForceInline
 692         public Byte256Mask eq(VectorMask<Byte> mask) {
 693             Objects.requireNonNull(mask);
 694             Byte256Mask m = (Byte256Mask)mask;
 695             return xor(m.not());
 696         }
 697 
 698         // Unary operations
 699 
 700         @Override
 701         @ForceInline
 702         public Byte256Mask not() {
 703             return xor(maskAll(true));
 704         }
 705 









 706         // Binary operations
 707 
 708         @Override
 709         @ForceInline
 710         public Byte256Mask and(VectorMask<Byte> mask) {
 711             Objects.requireNonNull(mask);
 712             Byte256Mask m = (Byte256Mask)mask;
 713             return VectorSupport.binaryOp(VECTOR_OP_AND, Byte256Mask.class, null, byte.class, VLENGTH,
 714                                           this, m, null,
 715                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b));
 716         }
 717 
 718         @Override
 719         @ForceInline
 720         public Byte256Mask or(VectorMask<Byte> mask) {
 721             Objects.requireNonNull(mask);
 722             Byte256Mask m = (Byte256Mask)mask;
 723             return VectorSupport.binaryOp(VECTOR_OP_OR, Byte256Mask.class, null, byte.class, VLENGTH,
 724                                           this, m, null,
 725                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));

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

 702                 this, species,
 703                 (m, s) -> s.maskFactory(m.toArray()).check(s));
 704         }
 705 
 706         @Override
 707         @ForceInline
 708         public Byte256Mask eq(VectorMask<Byte> mask) {
 709             Objects.requireNonNull(mask);
 710             Byte256Mask m = (Byte256Mask)mask;
 711             return xor(m.not());
 712         }
 713 
 714         // Unary operations
 715 
 716         @Override
 717         @ForceInline
 718         public Byte256Mask not() {
 719             return xor(maskAll(true));
 720         }
 721 
 722         @Override
 723         @ForceInline
 724         public Byte256Mask compress() {
 725             return (Byte256Mask)VectorSupport.comExpOp(VectorSupport.VECTOR_OP_MASK_COMPRESS,
 726                 Byte256Vector.class, Byte256Mask.class, ETYPE, VLENGTH, null, this,
 727                 (v1, m1) -> VSPECIES.iota().compare(VectorOperators.LT, m1.trueCount()));
 728         }
 729 
 730 
 731         // Binary operations
 732 
 733         @Override
 734         @ForceInline
 735         public Byte256Mask and(VectorMask<Byte> mask) {
 736             Objects.requireNonNull(mask);
 737             Byte256Mask m = (Byte256Mask)mask;
 738             return VectorSupport.binaryOp(VECTOR_OP_AND, Byte256Mask.class, null, byte.class, VLENGTH,
 739                                           this, m, null,
 740                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a & b));
 741         }
 742 
 743         @Override
 744         @ForceInline
 745         public Byte256Mask or(VectorMask<Byte> mask) {
 746             Objects.requireNonNull(mask);
 747             Byte256Mask m = (Byte256Mask)mask;
 748             return VectorSupport.binaryOp(VECTOR_OP_OR, Byte256Mask.class, null, byte.class, VLENGTH,
 749                                           this, m, null,
 750                                           (m1, m2, vm) -> m1.bOp(m2, (i, a, b) -> a | b));
< prev index next >