665 static void xorInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
666 IntFunction<boolean[]> fm) {
667 int[] a = fa.apply(SPECIES.length());
668 int[] b = fb.apply(SPECIES.length());
669 int[] r = fr.apply(SPECIES.length());
670 boolean[] mask = fm.apply(SPECIES.length());
671 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
672
673 for (int ic = 0; ic < INVOC_COUNT; ic++) {
674 for (int i = 0; i < a.length; i += SPECIES.length()) {
675 IntVector av = IntVector.fromArray(SPECIES, a, i);
676 IntVector bv = IntVector.fromArray(SPECIES, b, i);
677 av.xor(bv, vmask).intoArray(r, i);
678 }
679 }
680
681 assertArraysEquals(a, b, r, mask, Int64VectorTests::xor);
682 }
683
684
685 static int shiftR(int a, int b) {
686 return (int)((a >>> b));
687 }
688
689 @Test(dataProvider = "intBinaryOpProvider")
690 static void shiftRInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
691 int[] a = fa.apply(SPECIES.length());
692 int[] b = fb.apply(SPECIES.length());
693 int[] r = fr.apply(SPECIES.length());
694
695 for (int ic = 0; ic < INVOC_COUNT; ic++) {
696 for (int i = 0; i < a.length; i += SPECIES.length()) {
697 IntVector av = IntVector.fromArray(SPECIES, a, i);
698 IntVector bv = IntVector.fromArray(SPECIES, b, i);
699 av.shiftR(bv).intoArray(r, i);
700 }
701 }
702
703 assertArraysEquals(a, b, r, Int64VectorTests::shiftR);
704 }
705
706
707
708 @Test(dataProvider = "intBinaryOpMaskProvider")
709 static void shiftRInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
710 IntFunction<boolean[]> fm) {
711 int[] a = fa.apply(SPECIES.length());
712 int[] b = fb.apply(SPECIES.length());
713 int[] r = fr.apply(SPECIES.length());
714 boolean[] mask = fm.apply(SPECIES.length());
715 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
716
717 for (int ic = 0; ic < INVOC_COUNT; ic++) {
718 for (int i = 0; i < a.length; i += SPECIES.length()) {
719 IntVector av = IntVector.fromArray(SPECIES, a, i);
720 IntVector bv = IntVector.fromArray(SPECIES, b, i);
721 av.shiftR(bv, vmask).intoArray(r, i);
722 }
723 }
724
725 assertArraysEquals(a, b, r, mask, Int64VectorTests::shiftR);
726 }
727
728
729 static int shiftL(int a, int b) {
730 return (int)((a << b));
731 }
732
733 @Test(dataProvider = "intBinaryOpProvider")
734 static void shiftLInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
735 int[] a = fa.apply(SPECIES.length());
736 int[] b = fb.apply(SPECIES.length());
737 int[] r = fr.apply(SPECIES.length());
738
739 for (int ic = 0; ic < INVOC_COUNT; ic++) {
740 for (int i = 0; i < a.length; i += SPECIES.length()) {
741 IntVector av = IntVector.fromArray(SPECIES, a, i);
742 IntVector bv = IntVector.fromArray(SPECIES, b, i);
743 av.shiftL(bv).intoArray(r, i);
744 }
745 }
746
747 assertArraysEquals(a, b, r, Int64VectorTests::shiftL);
748 }
749
750
751
752 @Test(dataProvider = "intBinaryOpMaskProvider")
753 static void shiftLInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
754 IntFunction<boolean[]> fm) {
755 int[] a = fa.apply(SPECIES.length());
756 int[] b = fb.apply(SPECIES.length());
757 int[] r = fr.apply(SPECIES.length());
758 boolean[] mask = fm.apply(SPECIES.length());
759 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
760
761 for (int ic = 0; ic < INVOC_COUNT; ic++) {
762 for (int i = 0; i < a.length; i += SPECIES.length()) {
763 IntVector av = IntVector.fromArray(SPECIES, a, i);
764 IntVector bv = IntVector.fromArray(SPECIES, b, i);
765 av.shiftL(bv, vmask).intoArray(r, i);
766 }
767 }
768
769 assertArraysEquals(a, b, r, mask, Int64VectorTests::shiftL);
770 }
771
772
773 static int aShiftR(int a, int b) {
774 return (int)((a >> b));
775 }
776
777 @Test(dataProvider = "intBinaryOpProvider")
778 static void aShiftRInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
779 int[] a = fa.apply(SPECIES.length());
780 int[] b = fb.apply(SPECIES.length());
781 int[] r = fr.apply(SPECIES.length());
782
783 for (int ic = 0; ic < INVOC_COUNT; ic++) {
784 for (int i = 0; i < a.length; i += SPECIES.length()) {
785 IntVector av = IntVector.fromArray(SPECIES, a, i);
786 IntVector bv = IntVector.fromArray(SPECIES, b, i);
787 av.aShiftR(bv).intoArray(r, i);
788 }
789 }
790
791 assertArraysEquals(a, b, r, Int64VectorTests::aShiftR);
792 }
793
794
795
796 @Test(dataProvider = "intBinaryOpMaskProvider")
797 static void aShiftRInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
798 IntFunction<boolean[]> fm) {
799 int[] a = fa.apply(SPECIES.length());
800 int[] b = fb.apply(SPECIES.length());
801 int[] r = fr.apply(SPECIES.length());
802 boolean[] mask = fm.apply(SPECIES.length());
803 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
804
805 for (int ic = 0; ic < INVOC_COUNT; ic++) {
806 for (int i = 0; i < a.length; i += SPECIES.length()) {
807 IntVector av = IntVector.fromArray(SPECIES, a, i);
808 IntVector bv = IntVector.fromArray(SPECIES, b, i);
809 av.aShiftR(bv, vmask).intoArray(r, i);
810 }
811 }
812
813 assertArraysEquals(a, b, r, mask, Int64VectorTests::aShiftR);
814 }
815
816
817 static int aShiftR_unary(int a, int b) {
818 return (int)((a >> b));
819 }
820
821 @Test(dataProvider = "intBinaryOpProvider")
822 static void aShiftRInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
823 int[] a = fa.apply(SPECIES.length());
824 int[] b = fb.apply(SPECIES.length());
825 int[] r = fr.apply(SPECIES.length());
826
827 for (int ic = 0; ic < INVOC_COUNT; ic++) {
828 for (int i = 0; i < a.length; i += SPECIES.length()) {
829 IntVector av = IntVector.fromArray(SPECIES, a, i);
830 av.aShiftR((int)b[i]).intoArray(r, i);
831 }
832 }
833
834 assertShiftArraysEquals(a, b, r, Int64VectorTests::aShiftR_unary);
835 }
836
837
838
839 @Test(dataProvider = "intBinaryOpMaskProvider")
840 static void aShiftRInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
841 IntFunction<boolean[]> fm) {
842 int[] a = fa.apply(SPECIES.length());
843 int[] b = fb.apply(SPECIES.length());
844 int[] r = fr.apply(SPECIES.length());
845 boolean[] mask = fm.apply(SPECIES.length());
846 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
847
848 for (int ic = 0; ic < INVOC_COUNT; ic++) {
849 for (int i = 0; i < a.length; i += SPECIES.length()) {
850 IntVector av = IntVector.fromArray(SPECIES, a, i);
851 av.aShiftR((int)b[i], vmask).intoArray(r, i);
852 }
853 }
854
855 assertShiftArraysEquals(a, b, r, mask, Int64VectorTests::aShiftR_unary);
856 }
857
858
859 static int shiftR_unary(int a, int b) {
860 return (int)((a >>> b));
861 }
862
863 @Test(dataProvider = "intBinaryOpProvider")
864 static void shiftRInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
865 int[] a = fa.apply(SPECIES.length());
866 int[] b = fb.apply(SPECIES.length());
867 int[] r = fr.apply(SPECIES.length());
868
869 for (int ic = 0; ic < INVOC_COUNT; ic++) {
870 for (int i = 0; i < a.length; i += SPECIES.length()) {
871 IntVector av = IntVector.fromArray(SPECIES, a, i);
872 av.shiftR((int)b[i]).intoArray(r, i);
873 }
874 }
875
876 assertShiftArraysEquals(a, b, r, Int64VectorTests::shiftR_unary);
877 }
878
879
880
881 @Test(dataProvider = "intBinaryOpMaskProvider")
882 static void shiftRInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
883 IntFunction<boolean[]> fm) {
884 int[] a = fa.apply(SPECIES.length());
885 int[] b = fb.apply(SPECIES.length());
886 int[] r = fr.apply(SPECIES.length());
887 boolean[] mask = fm.apply(SPECIES.length());
888 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
889
890 for (int ic = 0; ic < INVOC_COUNT; ic++) {
891 for (int i = 0; i < a.length; i += SPECIES.length()) {
892 IntVector av = IntVector.fromArray(SPECIES, a, i);
893 av.shiftR((int)b[i], vmask).intoArray(r, i);
894 }
895 }
896
897 assertShiftArraysEquals(a, b, r, mask, Int64VectorTests::shiftR_unary);
898 }
899
900
901 static int shiftL_unary(int a, int b) {
902 return (int)((a << b));
903 }
904
905 @Test(dataProvider = "intBinaryOpProvider")
906 static void shiftLInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
907 int[] a = fa.apply(SPECIES.length());
908 int[] b = fb.apply(SPECIES.length());
909 int[] r = fr.apply(SPECIES.length());
910
911 for (int ic = 0; ic < INVOC_COUNT; ic++) {
912 for (int i = 0; i < a.length; i += SPECIES.length()) {
913 IntVector av = IntVector.fromArray(SPECIES, a, i);
914 av.shiftL((int)b[i]).intoArray(r, i);
915 }
916 }
917
918 assertShiftArraysEquals(a, b, r, Int64VectorTests::shiftL_unary);
919 }
920
921
922
923 @Test(dataProvider = "intBinaryOpMaskProvider")
924 static void shiftLInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
925 IntFunction<boolean[]> fm) {
926 int[] a = fa.apply(SPECIES.length());
927 int[] b = fb.apply(SPECIES.length());
928 int[] r = fr.apply(SPECIES.length());
929 boolean[] mask = fm.apply(SPECIES.length());
930 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
931
932 for (int ic = 0; ic < INVOC_COUNT; ic++) {
933 for (int i = 0; i < a.length; i += SPECIES.length()) {
934 IntVector av = IntVector.fromArray(SPECIES, a, i);
935 av.shiftL((int)b[i], vmask).intoArray(r, i);
936 }
937 }
938
939 assertShiftArraysEquals(a, b, r, mask, Int64VectorTests::shiftL_unary);
940 }
941
942
943
944
945
946
947
948
949
950
951
952
953
954 static int max(int a, int b) {
955 return (int)(Math.max(a, b));
956 }
957
958 @Test(dataProvider = "intBinaryOpProvider")
959 static void maxInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
960 int[] a = fa.apply(SPECIES.length());
961 int[] b = fb.apply(SPECIES.length());
962 int[] r = fr.apply(SPECIES.length());
963
964 for (int ic = 0; ic < INVOC_COUNT; ic++) {
965 for (int i = 0; i < a.length; i += SPECIES.length()) {
966 IntVector av = IntVector.fromArray(SPECIES, a, i);
967 IntVector bv = IntVector.fromArray(SPECIES, b, i);
968 av.max(bv).intoArray(r, i);
969 }
970 }
971
972 assertArraysEquals(a, b, r, Int64VectorTests::max);
973 }
975 return (int)(Math.min(a, b));
976 }
977
978 @Test(dataProvider = "intBinaryOpProvider")
979 static void minInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
980 int[] a = fa.apply(SPECIES.length());
981 int[] b = fb.apply(SPECIES.length());
982 int[] r = fr.apply(SPECIES.length());
983
984 for (int ic = 0; ic < INVOC_COUNT; ic++) {
985 for (int i = 0; i < a.length; i += SPECIES.length()) {
986 IntVector av = IntVector.fromArray(SPECIES, a, i);
987 IntVector bv = IntVector.fromArray(SPECIES, b, i);
988 av.min(bv).intoArray(r, i);
989 }
990 }
991
992 assertArraysEquals(a, b, r, Int64VectorTests::min);
993 }
994
995 static int andAll(int[] a, int idx) {
996 int res = -1;
997 for (int i = idx; i < (idx + SPECIES.length()); i++) {
998 res &= a[i];
999 }
1000
1001 return res;
1002 }
1003
1004 static int andAll(int[] a) {
1005 int res = -1;
1006 for (int i = 0; i < a.length; i += SPECIES.length()) {
1007 int tmp = -1;
1008 for (int j = 0; j < SPECIES.length(); j++) {
1009 tmp &= a[i + j];
1010 }
1011 res &= tmp;
1012 }
1013
1014 return res;
1015 }
1016
1017
1018 @Test(dataProvider = "intUnaryOpProvider")
1019 static void andAllInt64VectorTests(IntFunction<int[]> fa) {
1020 int[] a = fa.apply(SPECIES.length());
1021 int[] r = fr.apply(SPECIES.length());
1022 int ra = -1;
1023
1024 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1025 for (int i = 0; i < a.length; i += SPECIES.length()) {
1026 IntVector av = IntVector.fromArray(SPECIES, a, i);
1027 r[i] = av.andAll();
1028 }
1029 }
1030
1031 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1032 ra = -1;
1033 for (int i = 0; i < a.length; i += SPECIES.length()) {
1034 IntVector av = IntVector.fromArray(SPECIES, a, i);
1035 ra &= av.andAll();
1036 }
1037 }
1038
1039 assertReductionArraysEquals(a, r, ra, Int64VectorTests::andAll, Int64VectorTests::andAll);
1040 }
1041
1042
1043 static int orAll(int[] a, int idx) {
1044 int res = 0;
1045 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1046 res |= a[i];
1047 }
1048
1049 return res;
1050 }
1051
1052 static int orAll(int[] a) {
1053 int res = 0;
1054 for (int i = 0; i < a.length; i += SPECIES.length()) {
1055 int tmp = 0;
1056 for (int j = 0; j < SPECIES.length(); j++) {
1057 tmp |= a[i + j];
1058 }
1059 res |= tmp;
1060 }
1061
1062 return res;
1063 }
1064
1065
1066 @Test(dataProvider = "intUnaryOpProvider")
1067 static void orAllInt64VectorTests(IntFunction<int[]> fa) {
1068 int[] a = fa.apply(SPECIES.length());
1069 int[] r = fr.apply(SPECIES.length());
1070 int ra = 0;
1071
1072 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1073 for (int i = 0; i < a.length; i += SPECIES.length()) {
1074 IntVector av = IntVector.fromArray(SPECIES, a, i);
1075 r[i] = av.orAll();
1076 }
1077 }
1078
1079 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1080 ra = 0;
1081 for (int i = 0; i < a.length; i += SPECIES.length()) {
1082 IntVector av = IntVector.fromArray(SPECIES, a, i);
1083 ra |= av.orAll();
1084 }
1085 }
1086
1087 assertReductionArraysEquals(a, r, ra, Int64VectorTests::orAll, Int64VectorTests::orAll);
1088 }
1089
1090
1091 static int xorAll(int[] a, int idx) {
1092 int res = 0;
1093 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1094 res ^= a[i];
1095 }
1096
1097 return res;
1098 }
1099
1100 static int xorAll(int[] a) {
1101 int res = 0;
1102 for (int i = 0; i < a.length; i += SPECIES.length()) {
1103 int tmp = 0;
1104 for (int j = 0; j < SPECIES.length(); j++) {
1105 tmp ^= a[i + j];
1106 }
1107 res ^= tmp;
1108 }
1109
1110 return res;
1111 }
1112
1113
1114 @Test(dataProvider = "intUnaryOpProvider")
1115 static void xorAllInt64VectorTests(IntFunction<int[]> fa) {
1116 int[] a = fa.apply(SPECIES.length());
1117 int[] r = fr.apply(SPECIES.length());
1118 int ra = 0;
1119
1120 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1121 for (int i = 0; i < a.length; i += SPECIES.length()) {
1122 IntVector av = IntVector.fromArray(SPECIES, a, i);
1123 r[i] = av.xorAll();
1124 }
1125 }
1126
1127 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1128 ra = 0;
1129 for (int i = 0; i < a.length; i += SPECIES.length()) {
1130 IntVector av = IntVector.fromArray(SPECIES, a, i);
1131 ra ^= av.xorAll();
1132 }
1133 }
1134
1135 assertReductionArraysEquals(a, r, ra, Int64VectorTests::xorAll, Int64VectorTests::xorAll);
1136 }
1137
1138 static int addAll(int[] a, int idx) {
1139 int res = 0;
1140 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1141 res += a[i];
1142 }
1143
1144 return res;
1145 }
1146
1147 static int addAll(int[] a) {
1148 int res = 0;
1149 for (int i = 0; i < a.length; i += SPECIES.length()) {
1150 int tmp = 0;
1151 for (int j = 0; j < SPECIES.length(); j++) {
1152 tmp += a[i + j];
1153 }
1154 res += tmp;
1155 }
1156
1157 return res;
1158 }
1159 @Test(dataProvider = "intUnaryOpProvider")
1160 static void addAllInt64VectorTests(IntFunction<int[]> fa) {
1161 int[] a = fa.apply(SPECIES.length());
1162 int[] r = fr.apply(SPECIES.length());
1163 int ra = 0;
1164
1165 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1166 for (int i = 0; i < a.length; i += SPECIES.length()) {
1167 IntVector av = IntVector.fromArray(SPECIES, a, i);
1168 r[i] = av.addAll();
1169 }
1170 }
1171
1172 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1173 ra = 0;
1174 for (int i = 0; i < a.length; i += SPECIES.length()) {
1175 IntVector av = IntVector.fromArray(SPECIES, a, i);
1176 ra += av.addAll();
1177 }
1178 }
1179
1180 assertReductionArraysEquals(a, r, ra, Int64VectorTests::addAll, Int64VectorTests::addAll);
1181 }
1182 static int mulAll(int[] a, int idx) {
1183 int res = 1;
1184 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1185 res *= a[i];
1186 }
1187
1188 return res;
1189 }
1190
1191 static int mulAll(int[] a) {
1192 int res = 1;
1193 for (int i = 0; i < a.length; i += SPECIES.length()) {
1194 int tmp = 1;
1195 for (int j = 0; j < SPECIES.length(); j++) {
1196 tmp *= a[i + j];
1197 }
1198 res *= tmp;
1199 }
1200
1201 return res;
1202 }
1203 @Test(dataProvider = "intUnaryOpProvider")
1204 static void mulAllInt64VectorTests(IntFunction<int[]> fa) {
1205 int[] a = fa.apply(SPECIES.length());
1206 int[] r = fr.apply(SPECIES.length());
1207 int ra = 1;
1208
1209 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1210 for (int i = 0; i < a.length; i += SPECIES.length()) {
1211 IntVector av = IntVector.fromArray(SPECIES, a, i);
1212 r[i] = av.mulAll();
1213 }
1214 }
1215
1216 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1217 ra = 1;
1218 for (int i = 0; i < a.length; i += SPECIES.length()) {
1219 IntVector av = IntVector.fromArray(SPECIES, a, i);
1220 ra *= av.mulAll();
1221 }
1222 }
1223
1224 assertReductionArraysEquals(a, r, ra, Int64VectorTests::mulAll, Int64VectorTests::mulAll);
1225 }
1226 static int minAll(int[] a, int idx) {
1227 int res = Integer.MAX_VALUE;
1228 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1229 res = (int)Math.min(res, a[i]);
1230 }
1231
1232 return res;
1233 }
1234
1235 static int minAll(int[] a) {
1236 int res = Integer.MAX_VALUE;
1237 for (int i = 0; i < a.length; i++) {
1238 res = (int)Math.min(res, a[i]);
1239 }
1240
1241 return res;
1242 }
1243 @Test(dataProvider = "intUnaryOpProvider")
1244 static void minAllInt64VectorTests(IntFunction<int[]> fa) {
1245 int[] a = fa.apply(SPECIES.length());
1246 int[] r = fr.apply(SPECIES.length());
1247 int ra = Integer.MAX_VALUE;
1248
1249 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1250 for (int i = 0; i < a.length; i += SPECIES.length()) {
1251 IntVector av = IntVector.fromArray(SPECIES, a, i);
1252 r[i] = av.minAll();
1253 }
1254 }
1255
1256 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1257 ra = Integer.MAX_VALUE;
1258 for (int i = 0; i < a.length; i += SPECIES.length()) {
1259 IntVector av = IntVector.fromArray(SPECIES, a, i);
1260 ra = (int)Math.min(ra, av.minAll());
1261 }
1262 }
1263
1264 assertReductionArraysEquals(a, r, ra, Int64VectorTests::minAll, Int64VectorTests::minAll);
1265 }
1266 static int maxAll(int[] a, int idx) {
1267 int res = Integer.MIN_VALUE;
1268 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1269 res = (int)Math.max(res, a[i]);
1270 }
1271
1272 return res;
1273 }
1274
1275 static int maxAll(int[] a) {
1276 int res = Integer.MIN_VALUE;
1277 for (int i = 0; i < a.length; i++) {
1278 res = (int)Math.max(res, a[i]);
1279 }
1280
1281 return res;
1282 }
1283 @Test(dataProvider = "intUnaryOpProvider")
1284 static void maxAllInt64VectorTests(IntFunction<int[]> fa) {
1285 int[] a = fa.apply(SPECIES.length());
1286 int[] r = fr.apply(SPECIES.length());
1287 int ra = Integer.MIN_VALUE;
1288
1289 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1290 for (int i = 0; i < a.length; i += SPECIES.length()) {
1291 IntVector av = IntVector.fromArray(SPECIES, a, i);
1292 r[i] = av.maxAll();
1293 }
1294 }
1295
1296 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1297 ra = Integer.MIN_VALUE;
1298 for (int i = 0; i < a.length; i += SPECIES.length()) {
1299 IntVector av = IntVector.fromArray(SPECIES, a, i);
1300 ra = (int)Math.max(ra, av.maxAll());
1301 }
1302 }
1303
1304 assertReductionArraysEquals(a, r, ra, Int64VectorTests::maxAll, Int64VectorTests::maxAll);
1305 }
1306
1307 static boolean anyTrue(boolean[] a, int idx) {
1308 boolean res = false;
1309 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1310 res |= a[i];
1311 }
1312
1313 return res;
1314 }
1315
1316
1317 @Test(dataProvider = "boolUnaryOpProvider")
1318 static void anyTrueInt64VectorTests(IntFunction<boolean[]> fm) {
1319 boolean[] mask = fm.apply(SPECIES.length());
1320 boolean[] r = fmr.apply(SPECIES.length());
1321
1322 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1323 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1324 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
|
665 static void xorInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
666 IntFunction<boolean[]> fm) {
667 int[] a = fa.apply(SPECIES.length());
668 int[] b = fb.apply(SPECIES.length());
669 int[] r = fr.apply(SPECIES.length());
670 boolean[] mask = fm.apply(SPECIES.length());
671 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
672
673 for (int ic = 0; ic < INVOC_COUNT; ic++) {
674 for (int i = 0; i < a.length; i += SPECIES.length()) {
675 IntVector av = IntVector.fromArray(SPECIES, a, i);
676 IntVector bv = IntVector.fromArray(SPECIES, b, i);
677 av.xor(bv, vmask).intoArray(r, i);
678 }
679 }
680
681 assertArraysEquals(a, b, r, mask, Int64VectorTests::xor);
682 }
683
684
685 static int shiftLeft(int a, int b) {
686 return (int)((a << b));
687 }
688
689 @Test(dataProvider = "intBinaryOpProvider")
690 static void shiftLeftInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
691 int[] a = fa.apply(SPECIES.length());
692 int[] b = fb.apply(SPECIES.length());
693 int[] r = fr.apply(SPECIES.length());
694
695 for (int ic = 0; ic < INVOC_COUNT; ic++) {
696 for (int i = 0; i < a.length; i += SPECIES.length()) {
697 IntVector av = IntVector.fromArray(SPECIES, a, i);
698 IntVector bv = IntVector.fromArray(SPECIES, b, i);
699 av.shiftLeft(bv).intoArray(r, i);
700 }
701 }
702
703 assertArraysEquals(a, b, r, Int64VectorTests::shiftLeft);
704 }
705
706
707
708 @Test(dataProvider = "intBinaryOpMaskProvider")
709 static void shiftLeftInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
710 IntFunction<boolean[]> fm) {
711 int[] a = fa.apply(SPECIES.length());
712 int[] b = fb.apply(SPECIES.length());
713 int[] r = fr.apply(SPECIES.length());
714 boolean[] mask = fm.apply(SPECIES.length());
715 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
716
717 for (int ic = 0; ic < INVOC_COUNT; ic++) {
718 for (int i = 0; i < a.length; i += SPECIES.length()) {
719 IntVector av = IntVector.fromArray(SPECIES, a, i);
720 IntVector bv = IntVector.fromArray(SPECIES, b, i);
721 av.shiftLeft(bv, vmask).intoArray(r, i);
722 }
723 }
724
725 assertArraysEquals(a, b, r, mask, Int64VectorTests::shiftLeft);
726 }
727
728
729
730
731
732
733 static int shiftRight(int a, int b) {
734 return (int)((a >>> b));
735 }
736
737 @Test(dataProvider = "intBinaryOpProvider")
738 static void shiftRightInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
739 int[] a = fa.apply(SPECIES.length());
740 int[] b = fb.apply(SPECIES.length());
741 int[] r = fr.apply(SPECIES.length());
742
743 for (int ic = 0; ic < INVOC_COUNT; ic++) {
744 for (int i = 0; i < a.length; i += SPECIES.length()) {
745 IntVector av = IntVector.fromArray(SPECIES, a, i);
746 IntVector bv = IntVector.fromArray(SPECIES, b, i);
747 av.shiftRight(bv).intoArray(r, i);
748 }
749 }
750
751 assertArraysEquals(a, b, r, Int64VectorTests::shiftRight);
752 }
753
754
755
756 @Test(dataProvider = "intBinaryOpMaskProvider")
757 static void shiftRightInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
758 IntFunction<boolean[]> fm) {
759 int[] a = fa.apply(SPECIES.length());
760 int[] b = fb.apply(SPECIES.length());
761 int[] r = fr.apply(SPECIES.length());
762 boolean[] mask = fm.apply(SPECIES.length());
763 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
764
765 for (int ic = 0; ic < INVOC_COUNT; ic++) {
766 for (int i = 0; i < a.length; i += SPECIES.length()) {
767 IntVector av = IntVector.fromArray(SPECIES, a, i);
768 IntVector bv = IntVector.fromArray(SPECIES, b, i);
769 av.shiftRight(bv, vmask).intoArray(r, i);
770 }
771 }
772
773 assertArraysEquals(a, b, r, mask, Int64VectorTests::shiftRight);
774 }
775
776
777
778
779
780
781 static int shiftArithmeticRight(int a, int b) {
782 return (int)((a >> b));
783 }
784
785 @Test(dataProvider = "intBinaryOpProvider")
786 static void shiftArithmeticRightInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
787 int[] a = fa.apply(SPECIES.length());
788 int[] b = fb.apply(SPECIES.length());
789 int[] r = fr.apply(SPECIES.length());
790
791 for (int ic = 0; ic < INVOC_COUNT; ic++) {
792 for (int i = 0; i < a.length; i += SPECIES.length()) {
793 IntVector av = IntVector.fromArray(SPECIES, a, i);
794 IntVector bv = IntVector.fromArray(SPECIES, b, i);
795 av.shiftArithmeticRight(bv).intoArray(r, i);
796 }
797 }
798
799 assertArraysEquals(a, b, r, Int64VectorTests::shiftArithmeticRight);
800 }
801
802
803
804 @Test(dataProvider = "intBinaryOpMaskProvider")
805 static void shiftArithmeticRightInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
806 IntFunction<boolean[]> fm) {
807 int[] a = fa.apply(SPECIES.length());
808 int[] b = fb.apply(SPECIES.length());
809 int[] r = fr.apply(SPECIES.length());
810 boolean[] mask = fm.apply(SPECIES.length());
811 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
812
813 for (int ic = 0; ic < INVOC_COUNT; ic++) {
814 for (int i = 0; i < a.length; i += SPECIES.length()) {
815 IntVector av = IntVector.fromArray(SPECIES, a, i);
816 IntVector bv = IntVector.fromArray(SPECIES, b, i);
817 av.shiftArithmeticRight(bv, vmask).intoArray(r, i);
818 }
819 }
820
821 assertArraysEquals(a, b, r, mask, Int64VectorTests::shiftArithmeticRight);
822 }
823
824
825
826
827
828
829 static int shiftLeft_unary(int a, int b) {
830 return (int)((a << b));
831 }
832
833 @Test(dataProvider = "intBinaryOpProvider")
834 static void shiftLeftInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
835 int[] a = fa.apply(SPECIES.length());
836 int[] b = fb.apply(SPECIES.length());
837 int[] r = fr.apply(SPECIES.length());
838
839 for (int ic = 0; ic < INVOC_COUNT; ic++) {
840 for (int i = 0; i < a.length; i += SPECIES.length()) {
841 IntVector av = IntVector.fromArray(SPECIES, a, i);
842 av.shiftLeft((int)b[i]).intoArray(r, i);
843 }
844 }
845
846 assertShiftArraysEquals(a, b, r, Int64VectorTests::shiftLeft_unary);
847 }
848
849
850
851 @Test(dataProvider = "intBinaryOpMaskProvider")
852 static void shiftLeftInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
853 IntFunction<boolean[]> fm) {
854 int[] a = fa.apply(SPECIES.length());
855 int[] b = fb.apply(SPECIES.length());
856 int[] r = fr.apply(SPECIES.length());
857 boolean[] mask = fm.apply(SPECIES.length());
858 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
859
860 for (int ic = 0; ic < INVOC_COUNT; ic++) {
861 for (int i = 0; i < a.length; i += SPECIES.length()) {
862 IntVector av = IntVector.fromArray(SPECIES, a, i);
863 av.shiftLeft((int)b[i], vmask).intoArray(r, i);
864 }
865 }
866
867 assertShiftArraysEquals(a, b, r, mask, Int64VectorTests::shiftLeft_unary);
868 }
869
870
871
872
873
874
875 static int shiftRight_unary(int a, int b) {
876 return (int)((a >>> b));
877 }
878
879 @Test(dataProvider = "intBinaryOpProvider")
880 static void shiftRightInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
881 int[] a = fa.apply(SPECIES.length());
882 int[] b = fb.apply(SPECIES.length());
883 int[] r = fr.apply(SPECIES.length());
884
885 for (int ic = 0; ic < INVOC_COUNT; ic++) {
886 for (int i = 0; i < a.length; i += SPECIES.length()) {
887 IntVector av = IntVector.fromArray(SPECIES, a, i);
888 av.shiftRight((int)b[i]).intoArray(r, i);
889 }
890 }
891
892 assertShiftArraysEquals(a, b, r, Int64VectorTests::shiftRight_unary);
893 }
894
895
896
897 @Test(dataProvider = "intBinaryOpMaskProvider")
898 static void shiftRightInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
899 IntFunction<boolean[]> fm) {
900 int[] a = fa.apply(SPECIES.length());
901 int[] b = fb.apply(SPECIES.length());
902 int[] r = fr.apply(SPECIES.length());
903 boolean[] mask = fm.apply(SPECIES.length());
904 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
905
906 for (int ic = 0; ic < INVOC_COUNT; ic++) {
907 for (int i = 0; i < a.length; i += SPECIES.length()) {
908 IntVector av = IntVector.fromArray(SPECIES, a, i);
909 av.shiftRight((int)b[i], vmask).intoArray(r, i);
910 }
911 }
912
913 assertShiftArraysEquals(a, b, r, mask, Int64VectorTests::shiftRight_unary);
914 }
915
916
917
918
919
920
921 static int shiftArithmeticRight_unary(int a, int b) {
922 return (int)((a >> b));
923 }
924
925 @Test(dataProvider = "intBinaryOpProvider")
926 static void shiftArithmeticRightInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
927 int[] a = fa.apply(SPECIES.length());
928 int[] b = fb.apply(SPECIES.length());
929 int[] r = fr.apply(SPECIES.length());
930
931 for (int ic = 0; ic < INVOC_COUNT; ic++) {
932 for (int i = 0; i < a.length; i += SPECIES.length()) {
933 IntVector av = IntVector.fromArray(SPECIES, a, i);
934 av.shiftArithmeticRight((int)b[i]).intoArray(r, i);
935 }
936 }
937
938 assertShiftArraysEquals(a, b, r, Int64VectorTests::shiftArithmeticRight_unary);
939 }
940
941
942
943 @Test(dataProvider = "intBinaryOpMaskProvider")
944 static void shiftArithmeticRightInt64VectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
945 IntFunction<boolean[]> fm) {
946 int[] a = fa.apply(SPECIES.length());
947 int[] b = fb.apply(SPECIES.length());
948 int[] r = fr.apply(SPECIES.length());
949 boolean[] mask = fm.apply(SPECIES.length());
950 VectorMask<Integer> vmask = VectorMask.fromValues(SPECIES, mask);
951
952 for (int ic = 0; ic < INVOC_COUNT; ic++) {
953 for (int i = 0; i < a.length; i += SPECIES.length()) {
954 IntVector av = IntVector.fromArray(SPECIES, a, i);
955 av.shiftArithmeticRight((int)b[i], vmask).intoArray(r, i);
956 }
957 }
958
959 assertShiftArraysEquals(a, b, r, mask, Int64VectorTests::shiftArithmeticRight_unary);
960 }
961
962
963
964
965
966 static int max(int a, int b) {
967 return (int)(Math.max(a, b));
968 }
969
970 @Test(dataProvider = "intBinaryOpProvider")
971 static void maxInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
972 int[] a = fa.apply(SPECIES.length());
973 int[] b = fb.apply(SPECIES.length());
974 int[] r = fr.apply(SPECIES.length());
975
976 for (int ic = 0; ic < INVOC_COUNT; ic++) {
977 for (int i = 0; i < a.length; i += SPECIES.length()) {
978 IntVector av = IntVector.fromArray(SPECIES, a, i);
979 IntVector bv = IntVector.fromArray(SPECIES, b, i);
980 av.max(bv).intoArray(r, i);
981 }
982 }
983
984 assertArraysEquals(a, b, r, Int64VectorTests::max);
985 }
987 return (int)(Math.min(a, b));
988 }
989
990 @Test(dataProvider = "intBinaryOpProvider")
991 static void minInt64VectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
992 int[] a = fa.apply(SPECIES.length());
993 int[] b = fb.apply(SPECIES.length());
994 int[] r = fr.apply(SPECIES.length());
995
996 for (int ic = 0; ic < INVOC_COUNT; ic++) {
997 for (int i = 0; i < a.length; i += SPECIES.length()) {
998 IntVector av = IntVector.fromArray(SPECIES, a, i);
999 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1000 av.min(bv).intoArray(r, i);
1001 }
1002 }
1003
1004 assertArraysEquals(a, b, r, Int64VectorTests::min);
1005 }
1006
1007 static int andLanes(int[] a, int idx) {
1008 int res = -1;
1009 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1010 res &= a[i];
1011 }
1012
1013 return res;
1014 }
1015
1016 static int andLanes(int[] a) {
1017 int res = -1;
1018 for (int i = 0; i < a.length; i += SPECIES.length()) {
1019 int tmp = -1;
1020 for (int j = 0; j < SPECIES.length(); j++) {
1021 tmp &= a[i + j];
1022 }
1023 res &= tmp;
1024 }
1025
1026 return res;
1027 }
1028
1029
1030 @Test(dataProvider = "intUnaryOpProvider")
1031 static void andLanesInt64VectorTests(IntFunction<int[]> fa) {
1032 int[] a = fa.apply(SPECIES.length());
1033 int[] r = fr.apply(SPECIES.length());
1034 int ra = -1;
1035
1036 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1037 for (int i = 0; i < a.length; i += SPECIES.length()) {
1038 IntVector av = IntVector.fromArray(SPECIES, a, i);
1039 r[i] = av.andLanes();
1040 }
1041 }
1042
1043 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1044 ra = -1;
1045 for (int i = 0; i < a.length; i += SPECIES.length()) {
1046 IntVector av = IntVector.fromArray(SPECIES, a, i);
1047 ra &= av.andLanes();
1048 }
1049 }
1050
1051 assertReductionArraysEquals(a, r, ra, Int64VectorTests::andLanes, Int64VectorTests::andLanes);
1052 }
1053
1054
1055 static int orLanes(int[] a, int idx) {
1056 int res = 0;
1057 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1058 res |= a[i];
1059 }
1060
1061 return res;
1062 }
1063
1064 static int orLanes(int[] a) {
1065 int res = 0;
1066 for (int i = 0; i < a.length; i += SPECIES.length()) {
1067 int tmp = 0;
1068 for (int j = 0; j < SPECIES.length(); j++) {
1069 tmp |= a[i + j];
1070 }
1071 res |= tmp;
1072 }
1073
1074 return res;
1075 }
1076
1077
1078 @Test(dataProvider = "intUnaryOpProvider")
1079 static void orLanesInt64VectorTests(IntFunction<int[]> fa) {
1080 int[] a = fa.apply(SPECIES.length());
1081 int[] r = fr.apply(SPECIES.length());
1082 int ra = 0;
1083
1084 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1085 for (int i = 0; i < a.length; i += SPECIES.length()) {
1086 IntVector av = IntVector.fromArray(SPECIES, a, i);
1087 r[i] = av.orLanes();
1088 }
1089 }
1090
1091 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1092 ra = 0;
1093 for (int i = 0; i < a.length; i += SPECIES.length()) {
1094 IntVector av = IntVector.fromArray(SPECIES, a, i);
1095 ra |= av.orLanes();
1096 }
1097 }
1098
1099 assertReductionArraysEquals(a, r, ra, Int64VectorTests::orLanes, Int64VectorTests::orLanes);
1100 }
1101
1102
1103 static int xorLanes(int[] a, int idx) {
1104 int res = 0;
1105 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1106 res ^= a[i];
1107 }
1108
1109 return res;
1110 }
1111
1112 static int xorLanes(int[] a) {
1113 int res = 0;
1114 for (int i = 0; i < a.length; i += SPECIES.length()) {
1115 int tmp = 0;
1116 for (int j = 0; j < SPECIES.length(); j++) {
1117 tmp ^= a[i + j];
1118 }
1119 res ^= tmp;
1120 }
1121
1122 return res;
1123 }
1124
1125
1126 @Test(dataProvider = "intUnaryOpProvider")
1127 static void xorLanesInt64VectorTests(IntFunction<int[]> fa) {
1128 int[] a = fa.apply(SPECIES.length());
1129 int[] r = fr.apply(SPECIES.length());
1130 int ra = 0;
1131
1132 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1133 for (int i = 0; i < a.length; i += SPECIES.length()) {
1134 IntVector av = IntVector.fromArray(SPECIES, a, i);
1135 r[i] = av.xorLanes();
1136 }
1137 }
1138
1139 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1140 ra = 0;
1141 for (int i = 0; i < a.length; i += SPECIES.length()) {
1142 IntVector av = IntVector.fromArray(SPECIES, a, i);
1143 ra ^= av.xorLanes();
1144 }
1145 }
1146
1147 assertReductionArraysEquals(a, r, ra, Int64VectorTests::xorLanes, Int64VectorTests::xorLanes);
1148 }
1149
1150 static int addLanes(int[] a, int idx) {
1151 int res = 0;
1152 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1153 res += a[i];
1154 }
1155
1156 return res;
1157 }
1158
1159 static int addLanes(int[] a) {
1160 int res = 0;
1161 for (int i = 0; i < a.length; i += SPECIES.length()) {
1162 int tmp = 0;
1163 for (int j = 0; j < SPECIES.length(); j++) {
1164 tmp += a[i + j];
1165 }
1166 res += tmp;
1167 }
1168
1169 return res;
1170 }
1171 @Test(dataProvider = "intUnaryOpProvider")
1172 static void addLanesInt64VectorTests(IntFunction<int[]> fa) {
1173 int[] a = fa.apply(SPECIES.length());
1174 int[] r = fr.apply(SPECIES.length());
1175 int ra = 0;
1176
1177 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1178 for (int i = 0; i < a.length; i += SPECIES.length()) {
1179 IntVector av = IntVector.fromArray(SPECIES, a, i);
1180 r[i] = av.addLanes();
1181 }
1182 }
1183
1184 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1185 ra = 0;
1186 for (int i = 0; i < a.length; i += SPECIES.length()) {
1187 IntVector av = IntVector.fromArray(SPECIES, a, i);
1188 ra += av.addLanes();
1189 }
1190 }
1191
1192 assertReductionArraysEquals(a, r, ra, Int64VectorTests::addLanes, Int64VectorTests::addLanes);
1193 }
1194 static int mulLanes(int[] a, int idx) {
1195 int res = 1;
1196 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1197 res *= a[i];
1198 }
1199
1200 return res;
1201 }
1202
1203 static int mulLanes(int[] a) {
1204 int res = 1;
1205 for (int i = 0; i < a.length; i += SPECIES.length()) {
1206 int tmp = 1;
1207 for (int j = 0; j < SPECIES.length(); j++) {
1208 tmp *= a[i + j];
1209 }
1210 res *= tmp;
1211 }
1212
1213 return res;
1214 }
1215 @Test(dataProvider = "intUnaryOpProvider")
1216 static void mulLanesInt64VectorTests(IntFunction<int[]> fa) {
1217 int[] a = fa.apply(SPECIES.length());
1218 int[] r = fr.apply(SPECIES.length());
1219 int ra = 1;
1220
1221 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1222 for (int i = 0; i < a.length; i += SPECIES.length()) {
1223 IntVector av = IntVector.fromArray(SPECIES, a, i);
1224 r[i] = av.mulLanes();
1225 }
1226 }
1227
1228 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1229 ra = 1;
1230 for (int i = 0; i < a.length; i += SPECIES.length()) {
1231 IntVector av = IntVector.fromArray(SPECIES, a, i);
1232 ra *= av.mulLanes();
1233 }
1234 }
1235
1236 assertReductionArraysEquals(a, r, ra, Int64VectorTests::mulLanes, Int64VectorTests::mulLanes);
1237 }
1238 static int minLanes(int[] a, int idx) {
1239 int res = Integer.MAX_VALUE;
1240 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1241 res = (int)Math.min(res, a[i]);
1242 }
1243
1244 return res;
1245 }
1246
1247 static int minLanes(int[] a) {
1248 int res = Integer.MAX_VALUE;
1249 for (int i = 0; i < a.length; i++) {
1250 res = (int)Math.min(res, a[i]);
1251 }
1252
1253 return res;
1254 }
1255 @Test(dataProvider = "intUnaryOpProvider")
1256 static void minLanesInt64VectorTests(IntFunction<int[]> fa) {
1257 int[] a = fa.apply(SPECIES.length());
1258 int[] r = fr.apply(SPECIES.length());
1259 int ra = Integer.MAX_VALUE;
1260
1261 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1262 for (int i = 0; i < a.length; i += SPECIES.length()) {
1263 IntVector av = IntVector.fromArray(SPECIES, a, i);
1264 r[i] = av.minLanes();
1265 }
1266 }
1267
1268 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1269 ra = Integer.MAX_VALUE;
1270 for (int i = 0; i < a.length; i += SPECIES.length()) {
1271 IntVector av = IntVector.fromArray(SPECIES, a, i);
1272 ra = (int)Math.min(ra, av.minLanes());
1273 }
1274 }
1275
1276 assertReductionArraysEquals(a, r, ra, Int64VectorTests::minLanes, Int64VectorTests::minLanes);
1277 }
1278 static int maxLanes(int[] a, int idx) {
1279 int res = Integer.MIN_VALUE;
1280 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1281 res = (int)Math.max(res, a[i]);
1282 }
1283
1284 return res;
1285 }
1286
1287 static int maxLanes(int[] a) {
1288 int res = Integer.MIN_VALUE;
1289 for (int i = 0; i < a.length; i++) {
1290 res = (int)Math.max(res, a[i]);
1291 }
1292
1293 return res;
1294 }
1295 @Test(dataProvider = "intUnaryOpProvider")
1296 static void maxLanesInt64VectorTests(IntFunction<int[]> fa) {
1297 int[] a = fa.apply(SPECIES.length());
1298 int[] r = fr.apply(SPECIES.length());
1299 int ra = Integer.MIN_VALUE;
1300
1301 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1302 for (int i = 0; i < a.length; i += SPECIES.length()) {
1303 IntVector av = IntVector.fromArray(SPECIES, a, i);
1304 r[i] = av.maxLanes();
1305 }
1306 }
1307
1308 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1309 ra = Integer.MIN_VALUE;
1310 for (int i = 0; i < a.length; i += SPECIES.length()) {
1311 IntVector av = IntVector.fromArray(SPECIES, a, i);
1312 ra = (int)Math.max(ra, av.maxLanes());
1313 }
1314 }
1315
1316 assertReductionArraysEquals(a, r, ra, Int64VectorTests::maxLanes, Int64VectorTests::maxLanes);
1317 }
1318
1319 static boolean anyTrue(boolean[] a, int idx) {
1320 boolean res = false;
1321 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1322 res |= a[i];
1323 }
1324
1325 return res;
1326 }
1327
1328
1329 @Test(dataProvider = "boolUnaryOpProvider")
1330 static void anyTrueInt64VectorTests(IntFunction<boolean[]> fm) {
1331 boolean[] mask = fm.apply(SPECIES.length());
1332 boolean[] r = fmr.apply(SPECIES.length());
1333
1334 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1335 for (int i = 0; i < mask.length; i += SPECIES.length()) {
1336 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
|