< prev index next >

test/jdk/jdk/incubator/vector/Float256VectorTests.java

Print this page
rev 55892 : 8222933: [vector] Test failures after api change in JDK-8222752
Summary: Test failure becaues of renaming get() and getElement() functions to lane() in changeset http://hg.openjdk.java.net/panama/dev/rev/82514a6254e6
Reviewed-by: sviswanathan


 960                 av.with(0, (float)4).intoArray(r, i);
 961             }
 962         }
 963 
 964         assertInsertArraysEquals(a, r, (float)4, 0);
 965     }
 966 
 967     @Test(dataProvider = "floatCompareOpProvider")
 968     static void lessThanFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
 969         float[] a = fa.apply(SPECIES.length());
 970         float[] b = fb.apply(SPECIES.length());
 971 
 972         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 973             for (int i = 0; i < a.length; i += SPECIES.length()) {
 974                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
 975                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
 976                 VectorMask<Float> mv = av.lessThan(bv);
 977 
 978                 // Check results as part of computation.
 979                 for (int j = 0; j < SPECIES.length(); j++) {
 980                     Assert.assertEquals(mv.getElement(j), a[i + j] < b[i + j]);
 981                 }
 982             }
 983         }
 984     }
 985 
 986 
 987     @Test(dataProvider = "floatCompareOpProvider")
 988     static void greaterThanFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
 989         float[] a = fa.apply(SPECIES.length());
 990         float[] b = fb.apply(SPECIES.length());
 991 
 992         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 993             for (int i = 0; i < a.length; i += SPECIES.length()) {
 994                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
 995                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
 996                 VectorMask<Float> mv = av.greaterThan(bv);
 997 
 998                 // Check results as part of computation.
 999                 for (int j = 0; j < SPECIES.length(); j++) {
1000                     Assert.assertEquals(mv.getElement(j), a[i + j] > b[i + j]);
1001                 }
1002             }
1003         }
1004     }
1005 
1006 
1007     @Test(dataProvider = "floatCompareOpProvider")
1008     static void equalFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
1009         float[] a = fa.apply(SPECIES.length());
1010         float[] b = fb.apply(SPECIES.length());
1011 
1012         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1013             for (int i = 0; i < a.length; i += SPECIES.length()) {
1014                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1015                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1016                 VectorMask<Float> mv = av.equal(bv);
1017 
1018                 // Check results as part of computation.
1019                 for (int j = 0; j < SPECIES.length(); j++) {
1020                     Assert.assertEquals(mv.getElement(j), a[i + j] == b[i + j]);
1021                 }
1022             }
1023         }
1024     }
1025 
1026 
1027     @Test(dataProvider = "floatCompareOpProvider")
1028     static void notEqualFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
1029         float[] a = fa.apply(SPECIES.length());
1030         float[] b = fb.apply(SPECIES.length());
1031 
1032         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1033             for (int i = 0; i < a.length; i += SPECIES.length()) {
1034                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1035                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1036                 VectorMask<Float> mv = av.notEqual(bv);
1037 
1038                 // Check results as part of computation.
1039                 for (int j = 0; j < SPECIES.length(); j++) {
1040                     Assert.assertEquals(mv.getElement(j), a[i + j] != b[i + j]);
1041                 }
1042             }
1043         }
1044     }
1045 
1046 
1047     @Test(dataProvider = "floatCompareOpProvider")
1048     static void lessThanEqFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
1049         float[] a = fa.apply(SPECIES.length());
1050         float[] b = fb.apply(SPECIES.length());
1051 
1052         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1053             for (int i = 0; i < a.length; i += SPECIES.length()) {
1054                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1055                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1056                 VectorMask<Float> mv = av.lessThanEq(bv);
1057 
1058                 // Check results as part of computation.
1059                 for (int j = 0; j < SPECIES.length(); j++) {
1060                     Assert.assertEquals(mv.getElement(j), a[i + j] <= b[i + j]);
1061                 }
1062             }
1063         }
1064     }
1065 
1066 
1067     @Test(dataProvider = "floatCompareOpProvider")
1068     static void greaterThanEqFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
1069         float[] a = fa.apply(SPECIES.length());
1070         float[] b = fb.apply(SPECIES.length());
1071 
1072         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1073             for (int i = 0; i < a.length; i += SPECIES.length()) {
1074                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1075                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1076                 VectorMask<Float> mv = av.greaterThanEq(bv);
1077 
1078                 // Check results as part of computation.
1079                 for (int j = 0; j < SPECIES.length(); j++) {
1080                     Assert.assertEquals(mv.getElement(j), a[i + j] >= b[i + j]);
1081                 }
1082             }
1083         }
1084     }
1085 
1086 
1087     static float blend(float a, float b, boolean mask) {
1088         return mask ? b : a;
1089     }
1090 
1091     @Test(dataProvider = "floatBinaryOpMaskProvider")
1092     static void blendFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb,
1093                                           IntFunction<boolean[]> fm) {
1094         float[] a = fa.apply(SPECIES.length());
1095         float[] b = fb.apply(SPECIES.length());
1096         float[] r = fr.apply(SPECIES.length());
1097         boolean[] mask = fm.apply(SPECIES.length());
1098         VectorMask<Float> vmask = VectorMask.fromValues(SPECIES, mask);
1099 
1100         for (int ic = 0; ic < INVOC_COUNT; ic++) {


1123         }
1124 
1125         assertRearrangeArraysEquals(a, r, order, SPECIES.length());
1126     }
1127 
1128 
1129 
1130 
1131     @Test(dataProvider = "floatUnaryOpProvider")
1132     static void getFloat256VectorTests(IntFunction<float[]> fa) {
1133         float[] a = fa.apply(SPECIES.length());
1134         float[] r = fr.apply(SPECIES.length());
1135 
1136         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1137             for (int i = 0; i < a.length; i += SPECIES.length()) {
1138                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1139                 int num_lanes = SPECIES.length();
1140                 // Manually unroll because full unroll happens after intrinsification.
1141                 // Unroll is needed because get intrinsic requires for index to be a known constant.
1142                 if (num_lanes == 1) {
1143                     r[i]=av.get(0);
1144                 } else if (num_lanes == 2) {
1145                     r[i]=av.get(0);
1146                     r[i+1]=av.get(1);
1147                 } else if (num_lanes == 4) {
1148                     r[i]=av.get(0);
1149                     r[i+1]=av.get(1);
1150                     r[i+2]=av.get(2);
1151                     r[i+3]=av.get(3);
1152                 } else if (num_lanes == 8) {
1153                     r[i]=av.get(0);
1154                     r[i+1]=av.get(1);
1155                     r[i+2]=av.get(2);
1156                     r[i+3]=av.get(3);
1157                     r[i+4]=av.get(4);
1158                     r[i+5]=av.get(5);
1159                     r[i+6]=av.get(6);
1160                     r[i+7]=av.get(7);
1161                 } else if (num_lanes == 16) {
1162                     r[i]=av.get(0);
1163                     r[i+1]=av.get(1);
1164                     r[i+2]=av.get(2);
1165                     r[i+3]=av.get(3);
1166                     r[i+4]=av.get(4);
1167                     r[i+5]=av.get(5);
1168                     r[i+6]=av.get(6);
1169                     r[i+7]=av.get(7);
1170                     r[i+8]=av.get(8);
1171                     r[i+9]=av.get(9);
1172                     r[i+10]=av.get(10);
1173                     r[i+11]=av.get(11);
1174                     r[i+12]=av.get(12);
1175                     r[i+13]=av.get(13);
1176                     r[i+14]=av.get(14);
1177                     r[i+15]=av.get(15);
1178                 } else if (num_lanes == 32) {
1179                     r[i]=av.get(0);
1180                     r[i+1]=av.get(1);
1181                     r[i+2]=av.get(2);
1182                     r[i+3]=av.get(3);
1183                     r[i+4]=av.get(4);
1184                     r[i+5]=av.get(5);
1185                     r[i+6]=av.get(6);
1186                     r[i+7]=av.get(7);
1187                     r[i+8]=av.get(8);
1188                     r[i+9]=av.get(9);
1189                     r[i+10]=av.get(10);
1190                     r[i+11]=av.get(11);
1191                     r[i+12]=av.get(12);
1192                     r[i+13]=av.get(13);
1193                     r[i+14]=av.get(14);
1194                     r[i+15]=av.get(15);
1195                     r[i+16]=av.get(16);
1196                     r[i+17]=av.get(17);
1197                     r[i+18]=av.get(18);
1198                     r[i+19]=av.get(19);
1199                     r[i+20]=av.get(20);
1200                     r[i+21]=av.get(21);
1201                     r[i+22]=av.get(22);
1202                     r[i+23]=av.get(23);
1203                     r[i+24]=av.get(24);
1204                     r[i+25]=av.get(25);
1205                     r[i+26]=av.get(26);
1206                     r[i+27]=av.get(27);
1207                     r[i+28]=av.get(28);
1208                     r[i+29]=av.get(29);
1209                     r[i+30]=av.get(30);
1210                     r[i+31]=av.get(31);
1211                 } else if (num_lanes == 64) {
1212                     r[i]=av.get(0);
1213                     r[i+1]=av.get(1);
1214                     r[i+2]=av.get(2);
1215                     r[i+3]=av.get(3);
1216                     r[i+4]=av.get(4);
1217                     r[i+5]=av.get(5);
1218                     r[i+6]=av.get(6);
1219                     r[i+7]=av.get(7);
1220                     r[i+8]=av.get(8);
1221                     r[i+9]=av.get(9);
1222                     r[i+10]=av.get(10);
1223                     r[i+11]=av.get(11);
1224                     r[i+12]=av.get(12);
1225                     r[i+13]=av.get(13);
1226                     r[i+14]=av.get(14);
1227                     r[i+15]=av.get(15);
1228                     r[i+16]=av.get(16);
1229                     r[i+17]=av.get(17);
1230                     r[i+18]=av.get(18);
1231                     r[i+19]=av.get(19);
1232                     r[i+20]=av.get(20);
1233                     r[i+21]=av.get(21);
1234                     r[i+22]=av.get(22);
1235                     r[i+23]=av.get(23);
1236                     r[i+24]=av.get(24);
1237                     r[i+25]=av.get(25);
1238                     r[i+26]=av.get(26);
1239                     r[i+27]=av.get(27);
1240                     r[i+28]=av.get(28);
1241                     r[i+29]=av.get(29);
1242                     r[i+30]=av.get(30);
1243                     r[i+31]=av.get(31);
1244                     r[i+32]=av.get(32);
1245                     r[i+33]=av.get(33);
1246                     r[i+34]=av.get(34);
1247                     r[i+35]=av.get(35);
1248                     r[i+36]=av.get(36);
1249                     r[i+37]=av.get(37);
1250                     r[i+38]=av.get(38);
1251                     r[i+39]=av.get(39);
1252                     r[i+40]=av.get(40);
1253                     r[i+41]=av.get(41);
1254                     r[i+42]=av.get(42);
1255                     r[i+43]=av.get(43);
1256                     r[i+44]=av.get(44);
1257                     r[i+45]=av.get(45);
1258                     r[i+46]=av.get(46);
1259                     r[i+47]=av.get(47);
1260                     r[i+48]=av.get(48);
1261                     r[i+49]=av.get(49);
1262                     r[i+50]=av.get(50);
1263                     r[i+51]=av.get(51);
1264                     r[i+52]=av.get(52);
1265                     r[i+53]=av.get(53);
1266                     r[i+54]=av.get(54);
1267                     r[i+55]=av.get(55);
1268                     r[i+56]=av.get(56);
1269                     r[i+57]=av.get(57);
1270                     r[i+58]=av.get(58);
1271                     r[i+59]=av.get(59);
1272                     r[i+60]=av.get(60);
1273                     r[i+61]=av.get(61);
1274                     r[i+62]=av.get(62);
1275                     r[i+63]=av.get(63);
1276                 } else {
1277                     for (int j = 0; j < SPECIES.length(); j++) {
1278                         r[i+j]=av.get(j);
1279                     }
1280                 }
1281             }
1282         }
1283 
1284         assertArraysEquals(a, r, Float256VectorTests::get);
1285     }
1286 
1287     static float sin(float a) {
1288         return (float)(Math.sin((double)a));
1289     }
1290 
1291     static float strictsin(float a) {
1292         return (float)(StrictMath.sin((double)a));
1293     }
1294 
1295     @Test(dataProvider = "floatUnaryOpProvider")
1296     static void sinFloat256VectorTests(IntFunction<float[]> fa) {
1297         float[] a = fa.apply(SPECIES.length());
1298         float[] r = fr.apply(SPECIES.length());




 960                 av.with(0, (float)4).intoArray(r, i);
 961             }
 962         }
 963 
 964         assertInsertArraysEquals(a, r, (float)4, 0);
 965     }
 966 
 967     @Test(dataProvider = "floatCompareOpProvider")
 968     static void lessThanFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
 969         float[] a = fa.apply(SPECIES.length());
 970         float[] b = fb.apply(SPECIES.length());
 971 
 972         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 973             for (int i = 0; i < a.length; i += SPECIES.length()) {
 974                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
 975                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
 976                 VectorMask<Float> mv = av.lessThan(bv);
 977 
 978                 // Check results as part of computation.
 979                 for (int j = 0; j < SPECIES.length(); j++) {
 980                     Assert.assertEquals(mv.lane(j), a[i + j] < b[i + j]);
 981                 }
 982             }
 983         }
 984     }
 985 
 986 
 987     @Test(dataProvider = "floatCompareOpProvider")
 988     static void greaterThanFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
 989         float[] a = fa.apply(SPECIES.length());
 990         float[] b = fb.apply(SPECIES.length());
 991 
 992         for (int ic = 0; ic < INVOC_COUNT; ic++) {
 993             for (int i = 0; i < a.length; i += SPECIES.length()) {
 994                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
 995                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
 996                 VectorMask<Float> mv = av.greaterThan(bv);
 997 
 998                 // Check results as part of computation.
 999                 for (int j = 0; j < SPECIES.length(); j++) {
1000                     Assert.assertEquals(mv.lane(j), a[i + j] > b[i + j]);
1001                 }
1002             }
1003         }
1004     }
1005 
1006 
1007     @Test(dataProvider = "floatCompareOpProvider")
1008     static void equalFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
1009         float[] a = fa.apply(SPECIES.length());
1010         float[] b = fb.apply(SPECIES.length());
1011 
1012         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1013             for (int i = 0; i < a.length; i += SPECIES.length()) {
1014                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1015                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1016                 VectorMask<Float> mv = av.equal(bv);
1017 
1018                 // Check results as part of computation.
1019                 for (int j = 0; j < SPECIES.length(); j++) {
1020                     Assert.assertEquals(mv.lane(j), a[i + j] == b[i + j]);
1021                 }
1022             }
1023         }
1024     }
1025 
1026 
1027     @Test(dataProvider = "floatCompareOpProvider")
1028     static void notEqualFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
1029         float[] a = fa.apply(SPECIES.length());
1030         float[] b = fb.apply(SPECIES.length());
1031 
1032         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1033             for (int i = 0; i < a.length; i += SPECIES.length()) {
1034                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1035                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1036                 VectorMask<Float> mv = av.notEqual(bv);
1037 
1038                 // Check results as part of computation.
1039                 for (int j = 0; j < SPECIES.length(); j++) {
1040                     Assert.assertEquals(mv.lane(j), a[i + j] != b[i + j]);
1041                 }
1042             }
1043         }
1044     }
1045 
1046 
1047     @Test(dataProvider = "floatCompareOpProvider")
1048     static void lessThanEqFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
1049         float[] a = fa.apply(SPECIES.length());
1050         float[] b = fb.apply(SPECIES.length());
1051 
1052         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1053             for (int i = 0; i < a.length; i += SPECIES.length()) {
1054                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1055                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1056                 VectorMask<Float> mv = av.lessThanEq(bv);
1057 
1058                 // Check results as part of computation.
1059                 for (int j = 0; j < SPECIES.length(); j++) {
1060                     Assert.assertEquals(mv.lane(j), a[i + j] <= b[i + j]);
1061                 }
1062             }
1063         }
1064     }
1065 
1066 
1067     @Test(dataProvider = "floatCompareOpProvider")
1068     static void greaterThanEqFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb) {
1069         float[] a = fa.apply(SPECIES.length());
1070         float[] b = fb.apply(SPECIES.length());
1071 
1072         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1073             for (int i = 0; i < a.length; i += SPECIES.length()) {
1074                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1075                 FloatVector bv = FloatVector.fromArray(SPECIES, b, i);
1076                 VectorMask<Float> mv = av.greaterThanEq(bv);
1077 
1078                 // Check results as part of computation.
1079                 for (int j = 0; j < SPECIES.length(); j++) {
1080                     Assert.assertEquals(mv.lane(j), a[i + j] >= b[i + j]);
1081                 }
1082             }
1083         }
1084     }
1085 
1086 
1087     static float blend(float a, float b, boolean mask) {
1088         return mask ? b : a;
1089     }
1090 
1091     @Test(dataProvider = "floatBinaryOpMaskProvider")
1092     static void blendFloat256VectorTests(IntFunction<float[]> fa, IntFunction<float[]> fb,
1093                                           IntFunction<boolean[]> fm) {
1094         float[] a = fa.apply(SPECIES.length());
1095         float[] b = fb.apply(SPECIES.length());
1096         float[] r = fr.apply(SPECIES.length());
1097         boolean[] mask = fm.apply(SPECIES.length());
1098         VectorMask<Float> vmask = VectorMask.fromValues(SPECIES, mask);
1099 
1100         for (int ic = 0; ic < INVOC_COUNT; ic++) {


1123         }
1124 
1125         assertRearrangeArraysEquals(a, r, order, SPECIES.length());
1126     }
1127 
1128 
1129 
1130 
1131     @Test(dataProvider = "floatUnaryOpProvider")
1132     static void getFloat256VectorTests(IntFunction<float[]> fa) {
1133         float[] a = fa.apply(SPECIES.length());
1134         float[] r = fr.apply(SPECIES.length());
1135 
1136         for (int ic = 0; ic < INVOC_COUNT; ic++) {
1137             for (int i = 0; i < a.length; i += SPECIES.length()) {
1138                 FloatVector av = FloatVector.fromArray(SPECIES, a, i);
1139                 int num_lanes = SPECIES.length();
1140                 // Manually unroll because full unroll happens after intrinsification.
1141                 // Unroll is needed because get intrinsic requires for index to be a known constant.
1142                 if (num_lanes == 1) {
1143                     r[i]=av.lane(0);
1144                 } else if (num_lanes == 2) {
1145                     r[i]=av.lane(0);
1146                     r[i+1]=av.lane(1);
1147                 } else if (num_lanes == 4) {
1148                     r[i]=av.lane(0);
1149                     r[i+1]=av.lane(1);
1150                     r[i+2]=av.lane(2);
1151                     r[i+3]=av.lane(3);
1152                 } else if (num_lanes == 8) {
1153                     r[i]=av.lane(0);
1154                     r[i+1]=av.lane(1);
1155                     r[i+2]=av.lane(2);
1156                     r[i+3]=av.lane(3);
1157                     r[i+4]=av.lane(4);
1158                     r[i+5]=av.lane(5);
1159                     r[i+6]=av.lane(6);
1160                     r[i+7]=av.lane(7);
1161                 } else if (num_lanes == 16) {
1162                     r[i]=av.lane(0);
1163                     r[i+1]=av.lane(1);
1164                     r[i+2]=av.lane(2);
1165                     r[i+3]=av.lane(3);
1166                     r[i+4]=av.lane(4);
1167                     r[i+5]=av.lane(5);
1168                     r[i+6]=av.lane(6);
1169                     r[i+7]=av.lane(7);
1170                     r[i+8]=av.lane(8);
1171                     r[i+9]=av.lane(9);
1172                     r[i+10]=av.lane(10);
1173                     r[i+11]=av.lane(11);
1174                     r[i+12]=av.lane(12);
1175                     r[i+13]=av.lane(13);
1176                     r[i+14]=av.lane(14);
1177                     r[i+15]=av.lane(15);
1178                 } else if (num_lanes == 32) {
1179                     r[i]=av.lane(0);
1180                     r[i+1]=av.lane(1);
1181                     r[i+2]=av.lane(2);
1182                     r[i+3]=av.lane(3);
1183                     r[i+4]=av.lane(4);
1184                     r[i+5]=av.lane(5);
1185                     r[i+6]=av.lane(6);
1186                     r[i+7]=av.lane(7);
1187                     r[i+8]=av.lane(8);
1188                     r[i+9]=av.lane(9);
1189                     r[i+10]=av.lane(10);
1190                     r[i+11]=av.lane(11);
1191                     r[i+12]=av.lane(12);
1192                     r[i+13]=av.lane(13);
1193                     r[i+14]=av.lane(14);
1194                     r[i+15]=av.lane(15);
1195                     r[i+16]=av.lane(16);
1196                     r[i+17]=av.lane(17);
1197                     r[i+18]=av.lane(18);
1198                     r[i+19]=av.lane(19);
1199                     r[i+20]=av.lane(20);
1200                     r[i+21]=av.lane(21);
1201                     r[i+22]=av.lane(22);
1202                     r[i+23]=av.lane(23);
1203                     r[i+24]=av.lane(24);
1204                     r[i+25]=av.lane(25);
1205                     r[i+26]=av.lane(26);
1206                     r[i+27]=av.lane(27);
1207                     r[i+28]=av.lane(28);
1208                     r[i+29]=av.lane(29);
1209                     r[i+30]=av.lane(30);
1210                     r[i+31]=av.lane(31);
1211                 } else if (num_lanes == 64) {
1212                     r[i]=av.lane(0);
1213                     r[i+1]=av.lane(1);
1214                     r[i+2]=av.lane(2);
1215                     r[i+3]=av.lane(3);
1216                     r[i+4]=av.lane(4);
1217                     r[i+5]=av.lane(5);
1218                     r[i+6]=av.lane(6);
1219                     r[i+7]=av.lane(7);
1220                     r[i+8]=av.lane(8);
1221                     r[i+9]=av.lane(9);
1222                     r[i+10]=av.lane(10);
1223                     r[i+11]=av.lane(11);
1224                     r[i+12]=av.lane(12);
1225                     r[i+13]=av.lane(13);
1226                     r[i+14]=av.lane(14);
1227                     r[i+15]=av.lane(15);
1228                     r[i+16]=av.lane(16);
1229                     r[i+17]=av.lane(17);
1230                     r[i+18]=av.lane(18);
1231                     r[i+19]=av.lane(19);
1232                     r[i+20]=av.lane(20);
1233                     r[i+21]=av.lane(21);
1234                     r[i+22]=av.lane(22);
1235                     r[i+23]=av.lane(23);
1236                     r[i+24]=av.lane(24);
1237                     r[i+25]=av.lane(25);
1238                     r[i+26]=av.lane(26);
1239                     r[i+27]=av.lane(27);
1240                     r[i+28]=av.lane(28);
1241                     r[i+29]=av.lane(29);
1242                     r[i+30]=av.lane(30);
1243                     r[i+31]=av.lane(31);
1244                     r[i+32]=av.lane(32);
1245                     r[i+33]=av.lane(33);
1246                     r[i+34]=av.lane(34);
1247                     r[i+35]=av.lane(35);
1248                     r[i+36]=av.lane(36);
1249                     r[i+37]=av.lane(37);
1250                     r[i+38]=av.lane(38);
1251                     r[i+39]=av.lane(39);
1252                     r[i+40]=av.lane(40);
1253                     r[i+41]=av.lane(41);
1254                     r[i+42]=av.lane(42);
1255                     r[i+43]=av.lane(43);
1256                     r[i+44]=av.lane(44);
1257                     r[i+45]=av.lane(45);
1258                     r[i+46]=av.lane(46);
1259                     r[i+47]=av.lane(47);
1260                     r[i+48]=av.lane(48);
1261                     r[i+49]=av.lane(49);
1262                     r[i+50]=av.lane(50);
1263                     r[i+51]=av.lane(51);
1264                     r[i+52]=av.lane(52);
1265                     r[i+53]=av.lane(53);
1266                     r[i+54]=av.lane(54);
1267                     r[i+55]=av.lane(55);
1268                     r[i+56]=av.lane(56);
1269                     r[i+57]=av.lane(57);
1270                     r[i+58]=av.lane(58);
1271                     r[i+59]=av.lane(59);
1272                     r[i+60]=av.lane(60);
1273                     r[i+61]=av.lane(61);
1274                     r[i+62]=av.lane(62);
1275                     r[i+63]=av.lane(63);
1276                 } else {
1277                     for (int j = 0; j < SPECIES.length(); j++) {
1278                         r[i+j]=av.lane(j);
1279                     }
1280                 }
1281             }
1282         }
1283 
1284         assertArraysEquals(a, r, Float256VectorTests::get);
1285     }
1286 
1287     static float sin(float a) {
1288         return (float)(Math.sin((double)a));
1289     }
1290 
1291     static float strictsin(float a) {
1292         return (float)(StrictMath.sin((double)a));
1293     }
1294 
1295     @Test(dataProvider = "floatUnaryOpProvider")
1296     static void sinFloat256VectorTests(IntFunction<float[]> fa) {
1297         float[] a = fa.apply(SPECIES.length());
1298         float[] r = fr.apply(SPECIES.length());


< prev index next >