1026 0,
1027 (z -> Float512Mask.FALSE_MASK));
1028 }
1029
1030 @Override
1031 @ForceInline
1032 public Float512Vector fromArray(float[] a, int ix) {
1033 Objects.requireNonNull(a);
1034 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
1035 return (Float512Vector) VectorIntrinsics.load(Float512Vector.class, float.class, LENGTH,
1036 a, ix,
1037 (arr, idx) -> super.fromArray((float[]) arr, idx));
1038 }
1039
1040 @Override
1041 @ForceInline
1042 public Float512Vector fromArray(float[] a, int ax, Mask<Float, Shapes.S512Bit> m) {
1043 return zero().blend(fromArray(a, ax), m); // TODO: use better default impl: op(m, i -> a[ax + i]);
1044 }
1045
1046 @Override
1047 @ForceInline
1048 @SuppressWarnings("unchecked")
1049 public <F> Float512Vector rebracket(Vector<F, Shapes.S512Bit> o) {
1050 Objects.requireNonNull(o);
1051 if (o.elementType() == byte.class) {
1052 Byte512Vector so = (Byte512Vector)o;
1053 return VectorIntrinsics.reinterpret(
1054 Byte512Vector.class, byte.class, so.length(),
1055 float.class, LENGTH, so,
1056 (v, t) -> (Float512Vector)reshape(v)
1057 );
1058 } else if (o.elementType() == short.class) {
1059 Short512Vector so = (Short512Vector)o;
1060 return VectorIntrinsics.reinterpret(
1061 Short512Vector.class, short.class, so.length(),
1062 float.class, LENGTH, so,
1063 (v, t) -> (Float512Vector)reshape(v)
1064 );
1065 } else if (o.elementType() == int.class) {
1074 return VectorIntrinsics.reinterpret(
1075 Long512Vector.class, long.class, so.length(),
1076 float.class, LENGTH, so,
1077 (v, t) -> (Float512Vector)reshape(v)
1078 );
1079 } else if (o.elementType() == float.class) {
1080 Float512Vector so = (Float512Vector)o;
1081 return VectorIntrinsics.reinterpret(
1082 Float512Vector.class, float.class, so.length(),
1083 float.class, LENGTH, so,
1084 (v, t) -> (Float512Vector)reshape(v)
1085 );
1086 } else if (o.elementType() == double.class) {
1087 Double512Vector so = (Double512Vector)o;
1088 return VectorIntrinsics.reinterpret(
1089 Double512Vector.class, double.class, so.length(),
1090 float.class, LENGTH, so,
1091 (v, t) -> (Float512Vector)reshape(v)
1092 );
1093 } else {
1094 throw new InternalError("Unimplemented size");
1095 }
1096 }
1097
1098 @Override
1099 @ForceInline
1100 @SuppressWarnings("unchecked")
1101 public <T extends Shape> Float512Vector resize(Vector<Float, T> o) {
1102 Objects.requireNonNull(o);
1103 if (o.bitSize() == 64) {
1104 Float64Vector so = (Float64Vector)o;
1105 return VectorIntrinsics.reinterpret(
1106 Float64Vector.class, float.class, so.length(),
1107 float.class, LENGTH, so,
1108 (v, t) -> (Float512Vector)reshape(v)
1109 );
1110 } else if (o.bitSize() == 128) {
1111 Float128Vector so = (Float128Vector)o;
1112 return VectorIntrinsics.reinterpret(
1113 Float128Vector.class, float.class, so.length(),
1114 float.class, LENGTH, so,
|
1026 0,
1027 (z -> Float512Mask.FALSE_MASK));
1028 }
1029
1030 @Override
1031 @ForceInline
1032 public Float512Vector fromArray(float[] a, int ix) {
1033 Objects.requireNonNull(a);
1034 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
1035 return (Float512Vector) VectorIntrinsics.load(Float512Vector.class, float.class, LENGTH,
1036 a, ix,
1037 (arr, idx) -> super.fromArray((float[]) arr, idx));
1038 }
1039
1040 @Override
1041 @ForceInline
1042 public Float512Vector fromArray(float[] a, int ax, Mask<Float, Shapes.S512Bit> m) {
1043 return zero().blend(fromArray(a, ax), m); // TODO: use better default impl: op(m, i -> a[ax + i]);
1044 }
1045
1046 @ForceInline
1047 @SuppressWarnings("unchecked")
1048 private <S extends Shape> Float512Vector castFromByte(ByteVector<S> o) {
1049 if (o.bitSize() == 64) {
1050 Byte64Vector so = (Byte64Vector)o;
1051 return VectorIntrinsics.cast(
1052 Byte64Vector.class, byte.class, so.length(),
1053 float.class, LENGTH, so,
1054 (v, t) -> (Float512Vector)super.cast(v)
1055 );
1056 } else if (o.bitSize() == 128) {
1057 Byte128Vector so = (Byte128Vector)o;
1058 return VectorIntrinsics.cast(
1059 Byte128Vector.class, byte.class, so.length(),
1060 float.class, LENGTH, so,
1061 (v, t) -> (Float512Vector)super.cast(v)
1062 );
1063 } else if (o.bitSize() == 256) {
1064 Byte256Vector so = (Byte256Vector)o;
1065 return VectorIntrinsics.cast(
1066 Byte256Vector.class, byte.class, so.length(),
1067 float.class, LENGTH, so,
1068 (v, t) -> (Float512Vector)super.cast(v)
1069 );
1070 } else if (o.bitSize() == 512) {
1071 Byte512Vector so = (Byte512Vector)o;
1072 return VectorIntrinsics.cast(
1073 Byte512Vector.class, byte.class, so.length(),
1074 float.class, LENGTH, so,
1075 (v, t) -> (Float512Vector)super.cast(v)
1076 );
1077 } else {
1078 throw new InternalError("Unimplemented size");
1079 }
1080 }
1081
1082 @ForceInline
1083 @SuppressWarnings("unchecked")
1084 private <S extends Shape> Float512Vector castFromShort(ShortVector<S> o) {
1085 if (o.bitSize() == 64) {
1086 Short64Vector so = (Short64Vector)o;
1087 return VectorIntrinsics.cast(
1088 Short64Vector.class, short.class, so.length(),
1089 float.class, LENGTH, so,
1090 (v, t) -> (Float512Vector)super.cast(v)
1091 );
1092 } else if (o.bitSize() == 128) {
1093 Short128Vector so = (Short128Vector)o;
1094 return VectorIntrinsics.cast(
1095 Short128Vector.class, short.class, so.length(),
1096 float.class, LENGTH, so,
1097 (v, t) -> (Float512Vector)super.cast(v)
1098 );
1099 } else if (o.bitSize() == 256) {
1100 Short256Vector so = (Short256Vector)o;
1101 return VectorIntrinsics.cast(
1102 Short256Vector.class, short.class, so.length(),
1103 float.class, LENGTH, so,
1104 (v, t) -> (Float512Vector)super.cast(v)
1105 );
1106 } else if (o.bitSize() == 512) {
1107 Short512Vector so = (Short512Vector)o;
1108 return VectorIntrinsics.cast(
1109 Short512Vector.class, short.class, so.length(),
1110 float.class, LENGTH, so,
1111 (v, t) -> (Float512Vector)super.cast(v)
1112 );
1113 } else {
1114 throw new InternalError("Unimplemented size");
1115 }
1116 }
1117
1118 @ForceInline
1119 @SuppressWarnings("unchecked")
1120 private <S extends Shape> Float512Vector castFromInt(IntVector<S> o) {
1121 if (o.bitSize() == 64) {
1122 Int64Vector so = (Int64Vector)o;
1123 return VectorIntrinsics.cast(
1124 Int64Vector.class, int.class, so.length(),
1125 float.class, LENGTH, so,
1126 (v, t) -> (Float512Vector)super.cast(v)
1127 );
1128 } else if (o.bitSize() == 128) {
1129 Int128Vector so = (Int128Vector)o;
1130 return VectorIntrinsics.cast(
1131 Int128Vector.class, int.class, so.length(),
1132 float.class, LENGTH, so,
1133 (v, t) -> (Float512Vector)super.cast(v)
1134 );
1135 } else if (o.bitSize() == 256) {
1136 Int256Vector so = (Int256Vector)o;
1137 return VectorIntrinsics.cast(
1138 Int256Vector.class, int.class, so.length(),
1139 float.class, LENGTH, so,
1140 (v, t) -> (Float512Vector)super.cast(v)
1141 );
1142 } else if (o.bitSize() == 512) {
1143 Int512Vector so = (Int512Vector)o;
1144 return VectorIntrinsics.cast(
1145 Int512Vector.class, int.class, so.length(),
1146 float.class, LENGTH, so,
1147 (v, t) -> (Float512Vector)super.cast(v)
1148 );
1149 } else {
1150 throw new InternalError("Unimplemented size");
1151 }
1152 }
1153
1154 @ForceInline
1155 @SuppressWarnings("unchecked")
1156 private <S extends Shape> Float512Vector castFromLong(LongVector<S> o) {
1157 if (o.bitSize() == 64) {
1158 Long64Vector so = (Long64Vector)o;
1159 return VectorIntrinsics.cast(
1160 Long64Vector.class, long.class, so.length(),
1161 float.class, LENGTH, so,
1162 (v, t) -> (Float512Vector)super.cast(v)
1163 );
1164 } else if (o.bitSize() == 128) {
1165 Long128Vector so = (Long128Vector)o;
1166 return VectorIntrinsics.cast(
1167 Long128Vector.class, long.class, so.length(),
1168 float.class, LENGTH, so,
1169 (v, t) -> (Float512Vector)super.cast(v)
1170 );
1171 } else if (o.bitSize() == 256) {
1172 Long256Vector so = (Long256Vector)o;
1173 return VectorIntrinsics.cast(
1174 Long256Vector.class, long.class, so.length(),
1175 float.class, LENGTH, so,
1176 (v, t) -> (Float512Vector)super.cast(v)
1177 );
1178 } else if (o.bitSize() == 512) {
1179 Long512Vector so = (Long512Vector)o;
1180 return VectorIntrinsics.cast(
1181 Long512Vector.class, long.class, so.length(),
1182 float.class, LENGTH, so,
1183 (v, t) -> (Float512Vector)super.cast(v)
1184 );
1185 } else {
1186 throw new InternalError("Unimplemented size");
1187 }
1188 }
1189
1190 @ForceInline
1191 @SuppressWarnings("unchecked")
1192 private <S extends Shape> Float512Vector castFromFloat(FloatVector<S> o) {
1193 if (o.bitSize() == 64) {
1194 Float64Vector so = (Float64Vector)o;
1195 return VectorIntrinsics.cast(
1196 Float64Vector.class, float.class, so.length(),
1197 float.class, LENGTH, so,
1198 (v, t) -> (Float512Vector)super.cast(v)
1199 );
1200 } else if (o.bitSize() == 128) {
1201 Float128Vector so = (Float128Vector)o;
1202 return VectorIntrinsics.cast(
1203 Float128Vector.class, float.class, so.length(),
1204 float.class, LENGTH, so,
1205 (v, t) -> (Float512Vector)super.cast(v)
1206 );
1207 } else if (o.bitSize() == 256) {
1208 Float256Vector so = (Float256Vector)o;
1209 return VectorIntrinsics.cast(
1210 Float256Vector.class, float.class, so.length(),
1211 float.class, LENGTH, so,
1212 (v, t) -> (Float512Vector)super.cast(v)
1213 );
1214 } else if (o.bitSize() == 512) {
1215 Float512Vector so = (Float512Vector)o;
1216 return VectorIntrinsics.cast(
1217 Float512Vector.class, float.class, so.length(),
1218 float.class, LENGTH, so,
1219 (v, t) -> (Float512Vector)super.cast(v)
1220 );
1221 } else {
1222 throw new InternalError("Unimplemented size");
1223 }
1224 }
1225
1226 @ForceInline
1227 @SuppressWarnings("unchecked")
1228 private <S extends Shape> Float512Vector castFromDouble(DoubleVector<S> o) {
1229 if (o.bitSize() == 64) {
1230 Double64Vector so = (Double64Vector)o;
1231 return VectorIntrinsics.cast(
1232 Double64Vector.class, double.class, so.length(),
1233 float.class, LENGTH, so,
1234 (v, t) -> (Float512Vector)super.cast(v)
1235 );
1236 } else if (o.bitSize() == 128) {
1237 Double128Vector so = (Double128Vector)o;
1238 return VectorIntrinsics.cast(
1239 Double128Vector.class, double.class, so.length(),
1240 float.class, LENGTH, so,
1241 (v, t) -> (Float512Vector)super.cast(v)
1242 );
1243 } else if (o.bitSize() == 256) {
1244 Double256Vector so = (Double256Vector)o;
1245 return VectorIntrinsics.cast(
1246 Double256Vector.class, double.class, so.length(),
1247 float.class, LENGTH, so,
1248 (v, t) -> (Float512Vector)super.cast(v)
1249 );
1250 } else if (o.bitSize() == 512) {
1251 Double512Vector so = (Double512Vector)o;
1252 return VectorIntrinsics.cast(
1253 Double512Vector.class, double.class, so.length(),
1254 float.class, LENGTH, so,
1255 (v, t) -> (Float512Vector)super.cast(v)
1256 );
1257 } else {
1258 throw new InternalError("Unimplemented size");
1259 }
1260 }
1261
1262 @Override
1263 @ForceInline
1264 @SuppressWarnings("unchecked")
1265 public <E, S extends Shape> Float512Vector cast(Vector<E, S> o) {
1266 Objects.requireNonNull(o);
1267 if (o.elementType() == byte.class) {
1268 ByteVector<S> so = (ByteVector<S>)o;
1269 return castFromByte(so);
1270 } else if (o.elementType() == short.class) {
1271 ShortVector<S> so = (ShortVector<S>)o;
1272 return castFromShort(so);
1273 } else if (o.elementType() == int.class) {
1274 IntVector<S> so = (IntVector<S>)o;
1275 return castFromInt(so);
1276 } else if (o.elementType() == long.class) {
1277 LongVector<S> so = (LongVector<S>)o;
1278 return castFromLong(so);
1279 } else if (o.elementType() == float.class) {
1280 FloatVector<S> so = (FloatVector<S>)o;
1281 return castFromFloat(so);
1282 } else if (o.elementType() == double.class) {
1283 DoubleVector<S> so = (DoubleVector<S>)o;
1284 return castFromDouble(so);
1285 } else {
1286 throw new InternalError("Unimplemented type");
1287 }
1288 }
1289
1290 @Override
1291 @ForceInline
1292 @SuppressWarnings("unchecked")
1293 public <F> Float512Vector rebracket(Vector<F, Shapes.S512Bit> o) {
1294 Objects.requireNonNull(o);
1295 if (o.elementType() == byte.class) {
1296 Byte512Vector so = (Byte512Vector)o;
1297 return VectorIntrinsics.reinterpret(
1298 Byte512Vector.class, byte.class, so.length(),
1299 float.class, LENGTH, so,
1300 (v, t) -> (Float512Vector)reshape(v)
1301 );
1302 } else if (o.elementType() == short.class) {
1303 Short512Vector so = (Short512Vector)o;
1304 return VectorIntrinsics.reinterpret(
1305 Short512Vector.class, short.class, so.length(),
1306 float.class, LENGTH, so,
1307 (v, t) -> (Float512Vector)reshape(v)
1308 );
1309 } else if (o.elementType() == int.class) {
1318 return VectorIntrinsics.reinterpret(
1319 Long512Vector.class, long.class, so.length(),
1320 float.class, LENGTH, so,
1321 (v, t) -> (Float512Vector)reshape(v)
1322 );
1323 } else if (o.elementType() == float.class) {
1324 Float512Vector so = (Float512Vector)o;
1325 return VectorIntrinsics.reinterpret(
1326 Float512Vector.class, float.class, so.length(),
1327 float.class, LENGTH, so,
1328 (v, t) -> (Float512Vector)reshape(v)
1329 );
1330 } else if (o.elementType() == double.class) {
1331 Double512Vector so = (Double512Vector)o;
1332 return VectorIntrinsics.reinterpret(
1333 Double512Vector.class, double.class, so.length(),
1334 float.class, LENGTH, so,
1335 (v, t) -> (Float512Vector)reshape(v)
1336 );
1337 } else {
1338 throw new InternalError("Unimplemented type");
1339 }
1340 }
1341
1342 @Override
1343 @ForceInline
1344 @SuppressWarnings("unchecked")
1345 public <T extends Shape> Float512Vector resize(Vector<Float, T> o) {
1346 Objects.requireNonNull(o);
1347 if (o.bitSize() == 64) {
1348 Float64Vector so = (Float64Vector)o;
1349 return VectorIntrinsics.reinterpret(
1350 Float64Vector.class, float.class, so.length(),
1351 float.class, LENGTH, so,
1352 (v, t) -> (Float512Vector)reshape(v)
1353 );
1354 } else if (o.bitSize() == 128) {
1355 Float128Vector so = (Float128Vector)o;
1356 return VectorIntrinsics.reinterpret(
1357 Float128Vector.class, float.class, so.length(),
1358 float.class, LENGTH, so,
|