< prev index next >

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

Print this page




1090 
1091     @Override
1092     void forEach(VectorMask<Integer> o, FUnCon f) {
1093         boolean[] mbits = ((Int256Mask)o).getBits();
1094         forEach((i, a) -> {
1095             if (mbits[i]) { f.apply(i, a); }
1096         });
1097     }
1098 
1099 
1100     Float256Vector toFP() {
1101         int[] vec = getElements();
1102         float[] res = new float[this.species().length()];
1103         for(int i = 0; i < this.species().length(); i++){
1104             res[i] = Float.intBitsToFloat(vec[i]);
1105         }
1106         return new Float256Vector(res);
1107     }
1108 
1109     @Override

1110     public Int256Vector rotateLanesLeft(int j) {
1111         int[] vec = getElements();
1112         int[] res = new int[length()];
1113         for (int i = 0; i < length(); i++){
1114             res[(j + i) % length()] = vec[i];



1115         }
1116         return new Int256Vector(res);
1117     }
1118 
1119     @Override

1120     public Int256Vector rotateLanesRight(int j) {
1121         int[] vec = getElements();
1122         int[] res = new int[length()];
1123         for (int i = 0; i < length(); i++){
1124             int z = i - j;
1125             if(j < 0) {
1126                 res[length() + z] = vec[i];
1127             } else {
1128                 res[z] = vec[i];
1129             }

1130         }
1131         return new Int256Vector(res);
1132     }
1133 
1134     @Override


1135     public Int256Vector shiftLanesLeft(int j) {
1136         int[] vec = getElements();
1137         int[] res = new int[length()];
1138         for (int i = 0; i < length() - j; i++) {
1139             res[i] = vec[i + j];






1140         }
1141         return new Int256Vector(res);
1142     }
1143 
1144     @Override


1145     public Int256Vector shiftLanesRight(int j) {
1146         int[] vec = getElements();
1147         int[] res = new int[length()];
1148         for (int i = 0; i < length() - j; i++){
1149             res[i + j] = vec[i];






1150         }
1151         return new Int256Vector(res);
1152     }
1153 
1154     @Override
1155     @ForceInline
1156     public Int256Vector rearrange(Vector<Integer> v,
1157                                   VectorShuffle<Integer> s, VectorMask<Integer> m) {
1158         return this.rearrange(s).blend(v.rearrange(s), m);
1159     }
1160 
1161     @Override
1162     @ForceInline
1163     public Int256Vector rearrange(VectorShuffle<Integer> o1) {
1164         Objects.requireNonNull(o1);
1165         Int256Shuffle s =  (Int256Shuffle)o1;
1166 
1167         return VectorIntrinsics.rearrangeOp(
1168             Int256Vector.class, Int256Shuffle.class, int.class, LENGTH,
1169             this, s,
1170             (v1, s_) -> v1.uOp((i, a) -> {
1171                 int ei = s_.lane(i);


1370             super(reorder);
1371         }
1372 
1373         public Int256Shuffle(int[] reorder) {
1374             super(reorder);
1375         }
1376 
1377         public Int256Shuffle(int[] reorder, int i) {
1378             super(reorder, i);
1379         }
1380 
1381         public Int256Shuffle(IntUnaryOperator f) {
1382             super(f);
1383         }
1384 
1385         @Override
1386         public VectorSpecies<Integer> species() {
1387             return SPECIES;
1388         }
1389 
1390         @Override
1391         public IntVector toVector() {
1392             int[] va = new int[SPECIES.length()];
1393             for (int i = 0; i < va.length; i++) {
1394               va[i] = (int) lane(i);
1395             }
1396             return IntVector.fromArray(SPECIES, va, 0);
1397         }
1398 
1399         @Override
1400         @ForceInline








1401         @SuppressWarnings("unchecked")
1402         public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
1403             if (length() != species.length())
1404                 throw new IllegalArgumentException("Shuffle length and species length differ");
1405             Class<?> stype = species.elementType();
1406             int [] shuffleArray = toArray();
1407             if (stype == byte.class) {
1408                 return (VectorShuffle<F>) new Byte256Vector.Byte256Shuffle(shuffleArray);
1409             } else if (stype == short.class) {
1410                 return (VectorShuffle<F>) new Short256Vector.Short256Shuffle(shuffleArray);
1411             } else if (stype == int.class) {
1412                 return (VectorShuffle<F>) new Int256Vector.Int256Shuffle(shuffleArray);
1413             } else if (stype == long.class) {
1414                 return (VectorShuffle<F>) new Long256Vector.Long256Shuffle(shuffleArray);
1415             } else if (stype == float.class) {
1416                 return (VectorShuffle<F>) new Float256Vector.Float256Shuffle(shuffleArray);
1417             } else if (stype == double.class) {
1418                 return (VectorShuffle<F>) new Double256Vector.Double256Shuffle(shuffleArray);
1419             } else {
1420                 throw new UnsupportedOperationException("Bad lane type for casting.");
1421             }
1422         }

1423 
1424         @Override
1425         public Int256Shuffle rearrange(VectorShuffle<Integer> o) {
1426             Int256Shuffle s = (Int256Shuffle) o;
1427             byte[] r = new byte[reorder.length];
1428             for (int i = 0; i < reorder.length; i++) {
1429                 r[i] = reorder[s.reorder[i]];
1430             }
1431             return new Int256Shuffle(r);
1432         }
1433     }
1434 
1435     // VectorSpecies
1436 
1437     @Override
1438     public VectorSpecies<Integer> species() {
1439         return SPECIES;
1440     }
1441 }


1090 
1091     @Override
1092     void forEach(VectorMask<Integer> o, FUnCon f) {
1093         boolean[] mbits = ((Int256Mask)o).getBits();
1094         forEach((i, a) -> {
1095             if (mbits[i]) { f.apply(i, a); }
1096         });
1097     }
1098 
1099 
1100     Float256Vector toFP() {
1101         int[] vec = getElements();
1102         float[] res = new float[this.species().length()];
1103         for(int i = 0; i < this.species().length(); i++){
1104             res[i] = Float.intBitsToFloat(vec[i]);
1105         }
1106         return new Float256Vector(res);
1107     }
1108 
1109     @Override
1110     @ForceInline
1111     public Int256Vector rotateLanesLeft(int j) {
1112       int L = length();
1113       if (j < 0) {
1114          throw new IllegalArgumentException("Index " + j + " must be zero or positive");
1115       } else {
1116         j = j & (L-1);
1117         VectorShuffle<Integer> PermMask  = VectorShuffle.shuffleIota(SPECIES, L - j);
1118         return this.rearrange(PermMask);
1119       }

1120     }
1121 
1122     @Override
1123     @ForceInline
1124     public Int256Vector rotateLanesRight(int j) {
1125       int L = length();
1126       if (j < 0) {
1127          throw new IllegalArgumentException("Index " + j + " must be zero or positive");



1128       } else {
1129         j = j & (L-1);
1130         VectorShuffle<Integer> PermMask = VectorShuffle.shuffleIota(SPECIES, j);
1131         return this.rearrange(PermMask);
1132       }

1133     }
1134 
1135     @Override
1136     @ForceInline
1137     @SuppressWarnings("unchecked")
1138     public Int256Vector shiftLanesLeft(int j) {
1139        int L = length();
1140        if (j < 0) {
1141          throw new IllegalArgumentException("Index " + j + " must be zero or positive");
1142        } else if ( j >= L ) {
1143          return ZERO;
1144        } else {
1145          Int256Shuffle     Iota    = (Int256Shuffle)(VectorShuffle.shuffleIota(SPECIES, L-j));
1146          VectorMask<Integer> BlendMask = Iota.toVector().lessThan(Int256Vector.broadcast(SPECIES, (int)(L-j)));
1147          Iota    = (Int256Shuffle)(VectorShuffle.shuffleIota(SPECIES, L -j));
1148          return ZERO.blend(this.rearrange(Iota),BlendMask);
1149        }

1150     }
1151 
1152     @Override
1153     @ForceInline
1154     @SuppressWarnings("unchecked")
1155     public Int256Vector shiftLanesRight(int j) {
1156        int L = length();
1157        if (j < 0) {
1158          throw new IllegalArgumentException("Index " + j + " must be zero or positive");
1159        } else if ( j >= L ) {
1160          return ZERO;
1161        } else {
1162          Int256Shuffle     Iota    = (Int256Shuffle)(VectorShuffle.shuffleIota(SPECIES, j));
1163          VectorMask<Integer> BlendMask = Iota.toVector().greaterThanEq(Int256Vector.broadcast(SPECIES, (int)(j)));
1164          Iota    = (Int256Shuffle)(VectorShuffle.shuffleIota(SPECIES, j));
1165          return ZERO.blend(this.rearrange(Iota),BlendMask);
1166        }

1167     }
1168 
1169     @Override
1170     @ForceInline
1171     public Int256Vector rearrange(Vector<Integer> v,
1172                                   VectorShuffle<Integer> s, VectorMask<Integer> m) {
1173         return this.rearrange(s).blend(v.rearrange(s), m);
1174     }
1175 
1176     @Override
1177     @ForceInline
1178     public Int256Vector rearrange(VectorShuffle<Integer> o1) {
1179         Objects.requireNonNull(o1);
1180         Int256Shuffle s =  (Int256Shuffle)o1;
1181 
1182         return VectorIntrinsics.rearrangeOp(
1183             Int256Vector.class, Int256Shuffle.class, int.class, LENGTH,
1184             this, s,
1185             (v1, s_) -> v1.uOp((i, a) -> {
1186                 int ei = s_.lane(i);


1385             super(reorder);
1386         }
1387 
1388         public Int256Shuffle(int[] reorder) {
1389             super(reorder);
1390         }
1391 
1392         public Int256Shuffle(int[] reorder, int i) {
1393             super(reorder, i);
1394         }
1395 
1396         public Int256Shuffle(IntUnaryOperator f) {
1397             super(f);
1398         }
1399 
1400         @Override
1401         public VectorSpecies<Integer> species() {
1402             return SPECIES;
1403         }
1404 
1405         private IntVector toVector_helper() {

1406             int[] va = new int[SPECIES.length()];
1407             for (int i = 0; i < va.length; i++) {
1408               va[i] = (int) lane(i);
1409             }
1410             return IntVector.fromArray(SPECIES, va, 0);
1411         }
1412 
1413         @Override
1414         @ForceInline
1415         public IntVector toVector() {
1416             return VectorIntrinsics.shuffleToVector(Int256Vector.class, int.class, Int256Shuffle.class, this,
1417                                                     SPECIES.length(), 
1418                                                     (s) -> (((Int256Shuffle)(s)).toVector_helper()));
1419         }
1420 
1421         @Override
1422         @ForceInline
1423         @SuppressWarnings("unchecked")
1424         public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
1425             if (length() != species.length())
1426                 throw new IllegalArgumentException("Shuffle length and species length differ");
1427             Class<?> stype = species.elementType();
1428             int [] shuffleArray = toArray();
1429             if (stype == byte.class) {
1430                 return (VectorShuffle<F>) new Byte256Vector.Byte256Shuffle(shuffleArray);
1431             } else if (stype == short.class) {
1432                 return (VectorShuffle<F>) new Short256Vector.Short256Shuffle(shuffleArray);
1433             } else if (stype == int.class) {
1434                 return (VectorShuffle<F>) new Int256Vector.Int256Shuffle(shuffleArray);
1435             } else if (stype == long.class) {
1436                 return (VectorShuffle<F>) new Long256Vector.Long256Shuffle(shuffleArray);
1437             } else if (stype == float.class) {
1438                 return (VectorShuffle<F>) new Float256Vector.Float256Shuffle(shuffleArray);
1439             } else if (stype == double.class) {
1440                 return (VectorShuffle<F>) new Double256Vector.Double256Shuffle(shuffleArray);
1441             } else {
1442                 throw new UnsupportedOperationException("Bad lane type for casting.");
1443             }
1444         }
1445 
1446 
1447         @Override
1448         public Int256Shuffle rearrange(VectorShuffle<Integer> o) {
1449             Int256Shuffle s = (Int256Shuffle) o;
1450             byte[] r = new byte[reorder.length];
1451             for (int i = 0; i < reorder.length; i++) {
1452                 r[i] = reorder[s.reorder[i]];
1453             }
1454             return new Int256Shuffle(r);
1455         }
1456     }
1457 
1458     // VectorSpecies
1459 
1460     @Override
1461     public VectorSpecies<Integer> species() {
1462         return SPECIES;
1463     }
1464 }
< prev index next >