1077
1078 @Override
1079 void forEach(VectorMask<Long> o, FUnCon f) {
1080 boolean[] mbits = ((Long64Mask)o).getBits();
1081 forEach((i, a) -> {
1082 if (mbits[i]) { f.apply(i, a); }
1083 });
1084 }
1085
1086
1087 Double64Vector toFP() {
1088 long[] vec = getElements();
1089 double[] res = new double[this.species().length()];
1090 for(int i = 0; i < this.species().length(); i++){
1091 res[i] = Double.longBitsToDouble(vec[i]);
1092 }
1093 return new Double64Vector(res);
1094 }
1095
1096 @Override
1097 public Long64Vector rotateLanesLeft(int j) {
1098 long[] vec = getElements();
1099 long[] res = new long[length()];
1100 for (int i = 0; i < length(); i++){
1101 res[(j + i) % length()] = vec[i];
1102 }
1103 return new Long64Vector(res);
1104 }
1105
1106 @Override
1107 public Long64Vector rotateLanesRight(int j) {
1108 long[] vec = getElements();
1109 long[] res = new long[length()];
1110 for (int i = 0; i < length(); i++){
1111 int z = i - j;
1112 if(j < 0) {
1113 res[length() + z] = vec[i];
1114 } else {
1115 res[z] = vec[i];
1116 }
1117 }
1118 return new Long64Vector(res);
1119 }
1120
1121 @Override
1122 public Long64Vector shiftLanesLeft(int j) {
1123 long[] vec = getElements();
1124 long[] res = new long[length()];
1125 for (int i = 0; i < length() - j; i++) {
1126 res[i] = vec[i + j];
1127 }
1128 return new Long64Vector(res);
1129 }
1130
1131 @Override
1132 public Long64Vector shiftLanesRight(int j) {
1133 long[] vec = getElements();
1134 long[] res = new long[length()];
1135 for (int i = 0; i < length() - j; i++){
1136 res[i + j] = vec[i];
1137 }
1138 return new Long64Vector(res);
1139 }
1140
1141 @Override
1142 @ForceInline
1143 public Long64Vector rearrange(Vector<Long> v,
1144 VectorShuffle<Long> s, VectorMask<Long> m) {
1145 return this.rearrange(s).blend(v.rearrange(s), m);
1146 }
1147
1148 @Override
1149 @ForceInline
1150 public Long64Vector rearrange(VectorShuffle<Long> o1) {
1151 Objects.requireNonNull(o1);
1152 Long64Shuffle s = (Long64Shuffle)o1;
1153
1154 return VectorIntrinsics.rearrangeOp(
1155 Long64Vector.class, Long64Shuffle.class, long.class, LENGTH,
1156 this, s,
1157 (v1, s_) -> v1.uOp((i, a) -> {
1158 int ei = s_.lane(i);
1357 super(reorder);
1358 }
1359
1360 public Long64Shuffle(int[] reorder) {
1361 super(reorder);
1362 }
1363
1364 public Long64Shuffle(int[] reorder, int i) {
1365 super(reorder, i);
1366 }
1367
1368 public Long64Shuffle(IntUnaryOperator f) {
1369 super(f);
1370 }
1371
1372 @Override
1373 public VectorSpecies<Long> species() {
1374 return SPECIES;
1375 }
1376
1377 @Override
1378 public LongVector toVector() {
1379 long[] va = new long[SPECIES.length()];
1380 for (int i = 0; i < va.length; i++) {
1381 va[i] = (long) lane(i);
1382 }
1383 return LongVector.fromArray(SPECIES, va, 0);
1384 }
1385
1386 @Override
1387 @ForceInline
1388 @SuppressWarnings("unchecked")
1389 public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
1390 if (length() != species.length())
1391 throw new IllegalArgumentException("Shuffle length and species length differ");
1392 Class<?> stype = species.elementType();
1393 int [] shuffleArray = toArray();
1394 if (stype == byte.class) {
1395 return (VectorShuffle<F>) new Byte64Vector.Byte64Shuffle(shuffleArray);
1396 } else if (stype == short.class) {
1397 return (VectorShuffle<F>) new Short64Vector.Short64Shuffle(shuffleArray);
1398 } else if (stype == int.class) {
1399 return (VectorShuffle<F>) new Int64Vector.Int64Shuffle(shuffleArray);
1400 } else if (stype == long.class) {
1401 return (VectorShuffle<F>) new Long64Vector.Long64Shuffle(shuffleArray);
1402 } else if (stype == float.class) {
1403 return (VectorShuffle<F>) new Float64Vector.Float64Shuffle(shuffleArray);
1404 } else if (stype == double.class) {
1405 return (VectorShuffle<F>) new Double64Vector.Double64Shuffle(shuffleArray);
1406 } else {
1407 throw new UnsupportedOperationException("Bad lane type for casting.");
1408 }
1409 }
1410
1411 @Override
1412 public Long64Shuffle rearrange(VectorShuffle<Long> o) {
1413 Long64Shuffle s = (Long64Shuffle) o;
1414 byte[] r = new byte[reorder.length];
1415 for (int i = 0; i < reorder.length; i++) {
1416 r[i] = reorder[s.reorder[i]];
1417 }
1418 return new Long64Shuffle(r);
1419 }
1420 }
1421
1422 // VectorSpecies
1423
1424 @Override
1425 public VectorSpecies<Long> species() {
1426 return SPECIES;
1427 }
1428 }
|
1077
1078 @Override
1079 void forEach(VectorMask<Long> o, FUnCon f) {
1080 boolean[] mbits = ((Long64Mask)o).getBits();
1081 forEach((i, a) -> {
1082 if (mbits[i]) { f.apply(i, a); }
1083 });
1084 }
1085
1086
1087 Double64Vector toFP() {
1088 long[] vec = getElements();
1089 double[] res = new double[this.species().length()];
1090 for(int i = 0; i < this.species().length(); i++){
1091 res[i] = Double.longBitsToDouble(vec[i]);
1092 }
1093 return new Double64Vector(res);
1094 }
1095
1096 @Override
1097 @ForceInline
1098 public Long64Vector rotateLanesLeft(int j) {
1099 int L = length();
1100 if (j < 0) {
1101 throw new IllegalArgumentException("Index " + j + " must be zero or positive");
1102 } else {
1103 j = j & (L-1);
1104 VectorShuffle<Long> PermMask = VectorShuffle.shuffleIota(SPECIES, L - j);
1105 return this.rearrange(PermMask);
1106 }
1107 }
1108
1109 @Override
1110 @ForceInline
1111 public Long64Vector rotateLanesRight(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<Long> PermMask = VectorShuffle.shuffleIota(SPECIES, j);
1118 return this.rearrange(PermMask);
1119 }
1120 }
1121
1122 @Override
1123 @ForceInline
1124 @SuppressWarnings("unchecked")
1125 public Long64Vector shiftLanesLeft(int j) {
1126 int L = length();
1127 if (j < 0) {
1128 throw new IllegalArgumentException("Index " + j + " must be zero or positive");
1129 } else if ( j >= L ) {
1130 return ZERO;
1131 } else {
1132 Long64Shuffle Iota = (Long64Shuffle)(VectorShuffle.shuffleIota(SPECIES, L-j));
1133 VectorMask<Long> BlendMask = Iota.toVector().lessThan(Long64Vector.broadcast(SPECIES, (long)(L-j)));
1134 Iota = (Long64Shuffle)(VectorShuffle.shuffleIota(SPECIES, L -j));
1135 return ZERO.blend(this.rearrange(Iota),BlendMask);
1136 }
1137 }
1138
1139 @Override
1140 @ForceInline
1141 @SuppressWarnings("unchecked")
1142 public Long64Vector shiftLanesRight(int j) {
1143 int L = length();
1144 if (j < 0) {
1145 throw new IllegalArgumentException("Index " + j + " must be zero or positive");
1146 } else if ( j >= L ) {
1147 return ZERO;
1148 } else {
1149 Long64Shuffle Iota = (Long64Shuffle)(VectorShuffle.shuffleIota(SPECIES, j));
1150 VectorMask<Long> BlendMask = Iota.toVector().greaterThanEq(Long64Vector.broadcast(SPECIES, (long)(j)));
1151 Iota = (Long64Shuffle)(VectorShuffle.shuffleIota(SPECIES, j));
1152 return ZERO.blend(this.rearrange(Iota),BlendMask);
1153 }
1154 }
1155
1156 @Override
1157 @ForceInline
1158 public Long64Vector rearrange(Vector<Long> v,
1159 VectorShuffle<Long> s, VectorMask<Long> m) {
1160 return this.rearrange(s).blend(v.rearrange(s), m);
1161 }
1162
1163 @Override
1164 @ForceInline
1165 public Long64Vector rearrange(VectorShuffle<Long> o1) {
1166 Objects.requireNonNull(o1);
1167 Long64Shuffle s = (Long64Shuffle)o1;
1168
1169 return VectorIntrinsics.rearrangeOp(
1170 Long64Vector.class, Long64Shuffle.class, long.class, LENGTH,
1171 this, s,
1172 (v1, s_) -> v1.uOp((i, a) -> {
1173 int ei = s_.lane(i);
1372 super(reorder);
1373 }
1374
1375 public Long64Shuffle(int[] reorder) {
1376 super(reorder);
1377 }
1378
1379 public Long64Shuffle(int[] reorder, int i) {
1380 super(reorder, i);
1381 }
1382
1383 public Long64Shuffle(IntUnaryOperator f) {
1384 super(f);
1385 }
1386
1387 @Override
1388 public VectorSpecies<Long> species() {
1389 return SPECIES;
1390 }
1391
1392 private LongVector toVector_helper() {
1393 long[] va = new long[SPECIES.length()];
1394 for (int i = 0; i < va.length; i++) {
1395 va[i] = (long) lane(i);
1396 }
1397 return LongVector.fromArray(SPECIES, va, 0);
1398 }
1399
1400 @Override
1401 @ForceInline
1402 public LongVector toVector() {
1403 return VectorIntrinsics.shuffleToVector(Long64Vector.class, long.class, Long64Shuffle.class, this,
1404 SPECIES.length(),
1405 (s) -> (((Long64Shuffle)(s)).toVector_helper()));
1406 }
1407
1408 @Override
1409 @ForceInline
1410 @SuppressWarnings("unchecked")
1411 public <F> VectorShuffle<F> cast(VectorSpecies<F> species) {
1412 if (length() != species.length())
1413 throw new IllegalArgumentException("Shuffle length and species length differ");
1414 Class<?> stype = species.elementType();
1415 int [] shuffleArray = toArray();
1416 if (stype == byte.class) {
1417 return (VectorShuffle<F>) new Byte64Vector.Byte64Shuffle(shuffleArray);
1418 } else if (stype == short.class) {
1419 return (VectorShuffle<F>) new Short64Vector.Short64Shuffle(shuffleArray);
1420 } else if (stype == int.class) {
1421 return (VectorShuffle<F>) new Int64Vector.Int64Shuffle(shuffleArray);
1422 } else if (stype == long.class) {
1423 return (VectorShuffle<F>) new Long64Vector.Long64Shuffle(shuffleArray);
1424 } else if (stype == float.class) {
1425 return (VectorShuffle<F>) new Float64Vector.Float64Shuffle(shuffleArray);
1426 } else if (stype == double.class) {
1427 return (VectorShuffle<F>) new Double64Vector.Double64Shuffle(shuffleArray);
1428 } else {
1429 throw new UnsupportedOperationException("Bad lane type for casting.");
1430 }
1431 }
1432
1433
1434 @Override
1435 public Long64Shuffle rearrange(VectorShuffle<Long> o) {
1436 Long64Shuffle s = (Long64Shuffle) o;
1437 byte[] r = new byte[reorder.length];
1438 for (int i = 0; i < reorder.length; i++) {
1439 r[i] = reorder[s.reorder[i]];
1440 }
1441 return new Long64Shuffle(r);
1442 }
1443 }
1444
1445 // VectorSpecies
1446
1447 @Override
1448 public VectorSpecies<Long> species() {
1449 return SPECIES;
1450 }
1451 }
|