162
163 return VectorIntrinsics.cast(
164 IntMaxVector.class,
165 int.class, LENGTH,
166 s.boxType(),
167 s.elementType(), LENGTH,
168 this, s,
169 (species, vector) -> vector.castDefault(species)
170 );
171 }
172
173 @SuppressWarnings("unchecked")
174 @ForceInline
175 private <F> Vector<F> castDefault(VectorSpecies<F> s) {
176 int limit = s.length();
177
178 Class<?> stype = s.elementType();
179 if (stype == byte.class) {
180 byte[] a = new byte[limit];
181 for (int i = 0; i < limit; i++) {
182 a[i] = (byte) this.get(i);
183 }
184 return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
185 } else if (stype == short.class) {
186 short[] a = new short[limit];
187 for (int i = 0; i < limit; i++) {
188 a[i] = (short) this.get(i);
189 }
190 return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
191 } else if (stype == int.class) {
192 int[] a = new int[limit];
193 for (int i = 0; i < limit; i++) {
194 a[i] = (int) this.get(i);
195 }
196 return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
197 } else if (stype == long.class) {
198 long[] a = new long[limit];
199 for (int i = 0; i < limit; i++) {
200 a[i] = (long) this.get(i);
201 }
202 return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
203 } else if (stype == float.class) {
204 float[] a = new float[limit];
205 for (int i = 0; i < limit; i++) {
206 a[i] = (float) this.get(i);
207 }
208 return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
209 } else if (stype == double.class) {
210 double[] a = new double[limit];
211 for (int i = 0; i < limit; i++) {
212 a[i] = (double) this.get(i);
213 }
214 return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
215 } else {
216 throw new UnsupportedOperationException("Bad lane type for casting.");
217 }
218 }
219
220 @Override
221 @ForceInline
222 @SuppressWarnings("unchecked")
223 public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
224 Objects.requireNonNull(s);
225
226 if(s.elementType().equals(int.class)) {
227 return (Vector<F>) reshape((VectorSpecies<Integer>)s);
228 }
229 if(s.bitSize() == bitSize()) {
230 return reinterpretType(s);
231 }
232
1151 return new IntMaxVector(res);
1152 }
1153
1154 @Override
1155 @ForceInline
1156 public IntMaxVector 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 IntMaxVector rearrange(VectorShuffle<Integer> o1) {
1164 Objects.requireNonNull(o1);
1165 IntMaxShuffle s = (IntMaxShuffle)o1;
1166
1167 return VectorIntrinsics.rearrangeOp(
1168 IntMaxVector.class, IntMaxShuffle.class, int.class, LENGTH,
1169 this, s,
1170 (v1, s_) -> v1.uOp((i, a) -> {
1171 int ei = s_.getElement(i);
1172 return v1.get(ei);
1173 }));
1174 }
1175
1176 @Override
1177 @ForceInline
1178 public IntMaxVector blend(Vector<Integer> o1, VectorMask<Integer> o2) {
1179 Objects.requireNonNull(o1);
1180 Objects.requireNonNull(o2);
1181 IntMaxVector v = (IntMaxVector)o1;
1182 IntMaxMask m = (IntMaxMask)o2;
1183
1184 return VectorIntrinsics.blend(
1185 IntMaxVector.class, IntMaxMask.class, int.class, LENGTH,
1186 this, v, m,
1187 (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.getElement(i) ? b : a));
1188 }
1189
1190 // Accessors
1191
1192 @Override
1193 public int get(int i) {
1194 if (i < 0 || i >= LENGTH) {
1195 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1196 }
1197 return (int) VectorIntrinsics.extract(
1198 IntMaxVector.class, int.class, LENGTH,
1199 this, i,
1200 (vec, ix) -> {
1201 int[] vecarr = vec.getElements();
1202 return (long)vecarr[ix];
1203 });
1204 }
1205
1206 @Override
1207 public IntMaxVector with(int i, int e) {
1208 if (i < 0 || i >= LENGTH) {
1209 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1210 }
1211 return VectorIntrinsics.insert(
1212 IntMaxVector.class, int.class, LENGTH,
1213 this, i, (long)e,
1374 super(reorder);
1375 }
1376
1377 public IntMaxShuffle(int[] reorder, int i) {
1378 super(reorder, i);
1379 }
1380
1381 public IntMaxShuffle(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) getElement(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 ByteMaxVector.ByteMaxShuffle(shuffleArray);
1409 } else if (stype == short.class) {
1410 return (VectorShuffle<F>) new ShortMaxVector.ShortMaxShuffle(shuffleArray);
1411 } else if (stype == int.class) {
1412 return (VectorShuffle<F>) new IntMaxVector.IntMaxShuffle(shuffleArray);
1413 } else if (stype == long.class) {
1414 return (VectorShuffle<F>) new LongMaxVector.LongMaxShuffle(shuffleArray);
|
162
163 return VectorIntrinsics.cast(
164 IntMaxVector.class,
165 int.class, LENGTH,
166 s.boxType(),
167 s.elementType(), LENGTH,
168 this, s,
169 (species, vector) -> vector.castDefault(species)
170 );
171 }
172
173 @SuppressWarnings("unchecked")
174 @ForceInline
175 private <F> Vector<F> castDefault(VectorSpecies<F> s) {
176 int limit = s.length();
177
178 Class<?> stype = s.elementType();
179 if (stype == byte.class) {
180 byte[] a = new byte[limit];
181 for (int i = 0; i < limit; i++) {
182 a[i] = (byte) this.lane(i);
183 }
184 return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0);
185 } else if (stype == short.class) {
186 short[] a = new short[limit];
187 for (int i = 0; i < limit; i++) {
188 a[i] = (short) this.lane(i);
189 }
190 return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0);
191 } else if (stype == int.class) {
192 int[] a = new int[limit];
193 for (int i = 0; i < limit; i++) {
194 a[i] = (int) this.lane(i);
195 }
196 return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0);
197 } else if (stype == long.class) {
198 long[] a = new long[limit];
199 for (int i = 0; i < limit; i++) {
200 a[i] = (long) this.lane(i);
201 }
202 return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0);
203 } else if (stype == float.class) {
204 float[] a = new float[limit];
205 for (int i = 0; i < limit; i++) {
206 a[i] = (float) this.lane(i);
207 }
208 return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0);
209 } else if (stype == double.class) {
210 double[] a = new double[limit];
211 for (int i = 0; i < limit; i++) {
212 a[i] = (double) this.lane(i);
213 }
214 return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0);
215 } else {
216 throw new UnsupportedOperationException("Bad lane type for casting.");
217 }
218 }
219
220 @Override
221 @ForceInline
222 @SuppressWarnings("unchecked")
223 public <F> Vector<F> reinterpret(VectorSpecies<F> s) {
224 Objects.requireNonNull(s);
225
226 if(s.elementType().equals(int.class)) {
227 return (Vector<F>) reshape((VectorSpecies<Integer>)s);
228 }
229 if(s.bitSize() == bitSize()) {
230 return reinterpretType(s);
231 }
232
1151 return new IntMaxVector(res);
1152 }
1153
1154 @Override
1155 @ForceInline
1156 public IntMaxVector 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 IntMaxVector rearrange(VectorShuffle<Integer> o1) {
1164 Objects.requireNonNull(o1);
1165 IntMaxShuffle s = (IntMaxShuffle)o1;
1166
1167 return VectorIntrinsics.rearrangeOp(
1168 IntMaxVector.class, IntMaxShuffle.class, int.class, LENGTH,
1169 this, s,
1170 (v1, s_) -> v1.uOp((i, a) -> {
1171 int ei = s_.lane(i);
1172 return v1.lane(ei);
1173 }));
1174 }
1175
1176 @Override
1177 @ForceInline
1178 public IntMaxVector blend(Vector<Integer> o1, VectorMask<Integer> o2) {
1179 Objects.requireNonNull(o1);
1180 Objects.requireNonNull(o2);
1181 IntMaxVector v = (IntMaxVector)o1;
1182 IntMaxMask m = (IntMaxMask)o2;
1183
1184 return VectorIntrinsics.blend(
1185 IntMaxVector.class, IntMaxMask.class, int.class, LENGTH,
1186 this, v, m,
1187 (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.lane(i) ? b : a));
1188 }
1189
1190 // Accessors
1191
1192 @Override
1193 public int lane(int i) {
1194 if (i < 0 || i >= LENGTH) {
1195 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1196 }
1197 return (int) VectorIntrinsics.extract(
1198 IntMaxVector.class, int.class, LENGTH,
1199 this, i,
1200 (vec, ix) -> {
1201 int[] vecarr = vec.getElements();
1202 return (long)vecarr[ix];
1203 });
1204 }
1205
1206 @Override
1207 public IntMaxVector with(int i, int e) {
1208 if (i < 0 || i >= LENGTH) {
1209 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1210 }
1211 return VectorIntrinsics.insert(
1212 IntMaxVector.class, int.class, LENGTH,
1213 this, i, (long)e,
1374 super(reorder);
1375 }
1376
1377 public IntMaxShuffle(int[] reorder, int i) {
1378 super(reorder, i);
1379 }
1380
1381 public IntMaxShuffle(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 ByteMaxVector.ByteMaxShuffle(shuffleArray);
1409 } else if (stype == short.class) {
1410 return (VectorShuffle<F>) new ShortMaxVector.ShortMaxShuffle(shuffleArray);
1411 } else if (stype == int.class) {
1412 return (VectorShuffle<F>) new IntMaxVector.IntMaxShuffle(shuffleArray);
1413 } else if (stype == long.class) {
1414 return (VectorShuffle<F>) new LongMaxVector.LongMaxShuffle(shuffleArray);
|