1 /*
2 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have
23 * questions.
24 */
25 package jdk.incubator.vector;
26
27 import java.nio.ByteBuffer;
28 import java.nio.ByteOrder;
29 import java.nio.IntBuffer;
30 import java.nio.ReadOnlyBufferException;
31 import java.util.Arrays;
32 import java.util.Objects;
33 import java.util.function.IntUnaryOperator;
34
35 import jdk.internal.misc.Unsafe;
36 import jdk.internal.vm.annotation.ForceInline;
37 import static jdk.incubator.vector.VectorIntrinsics.*;
38
39 @SuppressWarnings("cast")
40 final class Int256Vector extends IntVector {
41 static final Int256Species SPECIES = new Int256Species();
42
43 static final Int256Vector ZERO = new Int256Vector();
44
45 static final int LENGTH = SPECIES.length();
46
47 // Index vector species
48 private static final IntVector.IntSpecies INDEX_SPEC;
49 static {
50 int bitSize = Vector.bitSizeForVectorLength(int.class, LENGTH);
51 Vector.Shape shape = Shape.forBitSize(bitSize);
52 INDEX_SPEC = (IntVector.IntSpecies) Species.of(int.class, shape);
53 }
54 private final int[] vec; // Don't access directly, use getElements() instead.
55
56 private int[] getElements() {
57 return VectorIntrinsics.maybeRebox(this).vec;
58 }
59
60 Int256Vector() {
61 vec = new int[SPECIES.length()];
62 }
63
64 Int256Vector(int[] v) {
65 vec = v;
66 }
67
68 @Override
69 public int length() { return LENGTH; }
70
71 // Unary operator
72
73 @Override
74 Int256Vector uOp(FUnOp f) {
75 int[] vec = getElements();
76 int[] res = new int[length()];
77 for (int i = 0; i < length(); i++) {
78 res[i] = f.apply(i, vec[i]);
79 }
80 return new Int256Vector(res);
81 }
82
83 @Override
84 Int256Vector uOp(Mask<Integer> o, FUnOp f) {
85 int[] vec = getElements();
86 int[] res = new int[length()];
87 boolean[] mbits = ((Int256Mask)o).getBits();
88 for (int i = 0; i < length(); i++) {
89 res[i] = mbits[i] ? f.apply(i, vec[i]) : vec[i];
90 }
91 return new Int256Vector(res);
92 }
93
94 // Binary operator
95
96 @Override
97 Int256Vector bOp(Vector<Integer> o, FBinOp f) {
98 int[] res = new int[length()];
99 int[] vec1 = this.getElements();
100 int[] vec2 = ((Int256Vector)o).getElements();
101 for (int i = 0; i < length(); i++) {
102 res[i] = f.apply(i, vec1[i], vec2[i]);
103 }
104 return new Int256Vector(res);
105 }
106
107 @Override
108 Int256Vector bOp(Vector<Integer> o1, Mask<Integer> o2, FBinOp f) {
109 int[] res = new int[length()];
110 int[] vec1 = this.getElements();
111 int[] vec2 = ((Int256Vector)o1).getElements();
112 boolean[] mbits = ((Int256Mask)o2).getBits();
113 for (int i = 0; i < length(); i++) {
114 res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i]) : vec1[i];
115 }
116 return new Int256Vector(res);
117 }
118
119 // Trinary operator
120
121 @Override
122 Int256Vector tOp(Vector<Integer> o1, Vector<Integer> o2, FTriOp f) {
123 int[] res = new int[length()];
124 int[] vec1 = this.getElements();
125 int[] vec2 = ((Int256Vector)o1).getElements();
126 int[] vec3 = ((Int256Vector)o2).getElements();
127 for (int i = 0; i < length(); i++) {
128 res[i] = f.apply(i, vec1[i], vec2[i], vec3[i]);
129 }
130 return new Int256Vector(res);
131 }
132
133 @Override
134 Int256Vector tOp(Vector<Integer> o1, Vector<Integer> o2, Mask<Integer> o3, FTriOp f) {
135 int[] res = new int[length()];
136 int[] vec1 = getElements();
137 int[] vec2 = ((Int256Vector)o1).getElements();
138 int[] vec3 = ((Int256Vector)o2).getElements();
139 boolean[] mbits = ((Int256Mask)o3).getBits();
140 for (int i = 0; i < length(); i++) {
141 res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i], vec3[i]) : vec1[i];
142 }
143 return new Int256Vector(res);
144 }
145
146 @Override
147 int rOp(int v, FBinOp f) {
148 int[] vec = getElements();
149 for (int i = 0; i < length(); i++) {
150 v = f.apply(i, v, vec[i]);
151 }
152 return v;
153 }
154
155 @Override
156 @ForceInline
157 public <F> Vector<F> cast(Species<F> s) {
158 Objects.requireNonNull(s);
159 if (s.length() != LENGTH)
160 throw new IllegalArgumentException("Vector length this species length differ");
161
162 return VectorIntrinsics.cast(
163 Int256Vector.class,
164 int.class, LENGTH,
165 s.vectorType(),
166 s.elementType(), LENGTH,
167 this, s,
168 (species, vector) -> vector.castDefault(species)
169 );
170 }
171
172 @SuppressWarnings("unchecked")
173 @ForceInline
174 private <F> Vector<F> castDefault(Species<F> s) {
175 int limit = s.length();
176
177 Class<?> stype = s.elementType();
178 if (stype == byte.class) {
179 byte[] a = new byte[limit];
180 for (int i = 0; i < limit; i++) {
181 a[i] = (byte) this.get(i);
182 }
183 return (Vector) ByteVector.fromArray((ByteVector.ByteSpecies) s, a, 0);
184 } else if (stype == short.class) {
185 short[] a = new short[limit];
186 for (int i = 0; i < limit; i++) {
187 a[i] = (short) this.get(i);
188 }
189 return (Vector) ShortVector.fromArray((ShortVector.ShortSpecies) s, a, 0);
190 } else if (stype == int.class) {
191 int[] a = new int[limit];
192 for (int i = 0; i < limit; i++) {
193 a[i] = (int) this.get(i);
194 }
195 return (Vector) IntVector.fromArray((IntVector.IntSpecies) s, a, 0);
196 } else if (stype == long.class) {
197 long[] a = new long[limit];
198 for (int i = 0; i < limit; i++) {
199 a[i] = (long) this.get(i);
200 }
201 return (Vector) LongVector.fromArray((LongVector.LongSpecies) s, a, 0);
202 } else if (stype == float.class) {
203 float[] a = new float[limit];
204 for (int i = 0; i < limit; i++) {
205 a[i] = (float) this.get(i);
206 }
207 return (Vector) FloatVector.fromArray((FloatVector.FloatSpecies) s, a, 0);
208 } else if (stype == double.class) {
209 double[] a = new double[limit];
210 for (int i = 0; i < limit; i++) {
211 a[i] = (double) this.get(i);
212 }
213 return (Vector) DoubleVector.fromArray((DoubleVector.DoubleSpecies) s, a, 0);
214 } else {
215 throw new UnsupportedOperationException("Bad lane type for casting.");
216 }
217 }
218
219 @Override
220 @ForceInline
221 @SuppressWarnings("unchecked")
222 public <F> Vector<F> reinterpret(Species<F> s) {
223 Objects.requireNonNull(s);
224
225 if(s.elementType().equals(int.class)) {
226 return (Vector<F>) reshape((Species<Integer>)s);
227 }
228 if(s.bitSize() == bitSize()) {
229 return reinterpretType(s);
230 }
231
232 return defaultReinterpret(s);
233 }
234
235 @ForceInline
236 private <F> Vector<F> reinterpretType(Species<F> s) {
237 Objects.requireNonNull(s);
238
239 Class<?> stype = s.elementType();
240 if (stype == byte.class) {
241 return VectorIntrinsics.reinterpret(
242 Int256Vector.class,
243 int.class, LENGTH,
244 Byte256Vector.class,
245 byte.class, Byte256Vector.LENGTH,
246 this, s,
247 (species, vector) -> vector.defaultReinterpret(species)
248 );
249 } else if (stype == short.class) {
250 return VectorIntrinsics.reinterpret(
251 Int256Vector.class,
252 int.class, LENGTH,
253 Short256Vector.class,
254 short.class, Short256Vector.LENGTH,
255 this, s,
256 (species, vector) -> vector.defaultReinterpret(species)
257 );
258 } else if (stype == int.class) {
259 return VectorIntrinsics.reinterpret(
260 Int256Vector.class,
261 int.class, LENGTH,
262 Int256Vector.class,
263 int.class, Int256Vector.LENGTH,
264 this, s,
265 (species, vector) -> vector.defaultReinterpret(species)
266 );
267 } else if (stype == long.class) {
268 return VectorIntrinsics.reinterpret(
269 Int256Vector.class,
270 int.class, LENGTH,
271 Long256Vector.class,
272 long.class, Long256Vector.LENGTH,
273 this, s,
274 (species, vector) -> vector.defaultReinterpret(species)
275 );
276 } else if (stype == float.class) {
277 return VectorIntrinsics.reinterpret(
278 Int256Vector.class,
279 int.class, LENGTH,
280 Float256Vector.class,
281 float.class, Float256Vector.LENGTH,
282 this, s,
283 (species, vector) -> vector.defaultReinterpret(species)
284 );
285 } else if (stype == double.class) {
286 return VectorIntrinsics.reinterpret(
287 Int256Vector.class,
288 int.class, LENGTH,
289 Double256Vector.class,
290 double.class, Double256Vector.LENGTH,
291 this, s,
292 (species, vector) -> vector.defaultReinterpret(species)
293 );
294 } else {
295 throw new UnsupportedOperationException("Bad lane type for casting.");
296 }
297 }
298
299 @Override
300 @ForceInline
301 public IntVector reshape(Species<Integer> s) {
302 Objects.requireNonNull(s);
303 if (s.bitSize() == 64 && (s instanceof Int64Vector.Int64Species)) {
304 Int64Vector.Int64Species ts = (Int64Vector.Int64Species)s;
305 return VectorIntrinsics.reinterpret(
306 Int256Vector.class,
307 int.class, LENGTH,
308 Int64Vector.class,
309 int.class, Int64Vector.LENGTH,
310 this, ts,
311 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
312 );
313 } else if (s.bitSize() == 128 && (s instanceof Int128Vector.Int128Species)) {
314 Int128Vector.Int128Species ts = (Int128Vector.Int128Species)s;
315 return VectorIntrinsics.reinterpret(
316 Int256Vector.class,
317 int.class, LENGTH,
318 Int128Vector.class,
319 int.class, Int128Vector.LENGTH,
320 this, ts,
321 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
322 );
323 } else if (s.bitSize() == 256 && (s instanceof Int256Vector.Int256Species)) {
324 Int256Vector.Int256Species ts = (Int256Vector.Int256Species)s;
325 return VectorIntrinsics.reinterpret(
326 Int256Vector.class,
327 int.class, LENGTH,
328 Int256Vector.class,
329 int.class, Int256Vector.LENGTH,
330 this, ts,
331 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
332 );
333 } else if (s.bitSize() == 512 && (s instanceof Int512Vector.Int512Species)) {
334 Int512Vector.Int512Species ts = (Int512Vector.Int512Species)s;
335 return VectorIntrinsics.reinterpret(
336 Int256Vector.class,
337 int.class, LENGTH,
338 Int512Vector.class,
339 int.class, Int512Vector.LENGTH,
340 this, ts,
341 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
342 );
343 } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
344 && (s.bitSize() % 128 == 0) && (s instanceof IntMaxVector.IntMaxSpecies)) {
345 IntMaxVector.IntMaxSpecies ts = (IntMaxVector.IntMaxSpecies)s;
346 return VectorIntrinsics.reinterpret(
347 Int256Vector.class,
348 int.class, LENGTH,
349 IntMaxVector.class,
350 int.class, IntMaxVector.LENGTH,
351 this, ts,
352 (species, vector) -> (IntVector) vector.defaultReinterpret(species)
353 );
354 } else {
355 throw new InternalError("Unimplemented size");
356 }
357 }
358
359 // Binary operations with scalars
360
361 @Override
362 @ForceInline
363 public IntVector add(int o) {
364 return add(SPECIES.broadcast(o));
365 }
366
367 @Override
368 @ForceInline
369 public IntVector add(int o, Mask<Integer> m) {
370 return add(SPECIES.broadcast(o), m);
371 }
372
373 @Override
374 @ForceInline
375 public IntVector sub(int o) {
376 return sub(SPECIES.broadcast(o));
377 }
378
379 @Override
380 @ForceInline
381 public IntVector sub(int o, Mask<Integer> m) {
382 return sub(SPECIES.broadcast(o), m);
383 }
384
385 @Override
386 @ForceInline
387 public IntVector mul(int o) {
388 return mul(SPECIES.broadcast(o));
389 }
390
391 @Override
392 @ForceInline
393 public IntVector mul(int o, Mask<Integer> m) {
394 return mul(SPECIES.broadcast(o), m);
395 }
396
397 @Override
398 @ForceInline
399 public IntVector min(int o) {
400 return min(SPECIES.broadcast(o));
401 }
402
403 @Override
404 @ForceInline
405 public IntVector max(int o) {
406 return max(SPECIES.broadcast(o));
407 }
408
409 @Override
410 @ForceInline
411 public Mask<Integer> equal(int o) {
412 return equal(SPECIES.broadcast(o));
413 }
414
415 @Override
416 @ForceInline
417 public Mask<Integer> notEqual(int o) {
418 return notEqual(SPECIES.broadcast(o));
419 }
420
421 @Override
422 @ForceInline
423 public Mask<Integer> lessThan(int o) {
424 return lessThan(SPECIES.broadcast(o));
425 }
426
427 @Override
428 @ForceInline
429 public Mask<Integer> lessThanEq(int o) {
430 return lessThanEq(SPECIES.broadcast(o));
431 }
432
433 @Override
434 @ForceInline
435 public Mask<Integer> greaterThan(int o) {
436 return greaterThan(SPECIES.broadcast(o));
437 }
438
439 @Override
440 @ForceInline
441 public Mask<Integer> greaterThanEq(int o) {
442 return greaterThanEq(SPECIES.broadcast(o));
443 }
444
445 @Override
446 @ForceInline
447 public IntVector blend(int o, Mask<Integer> m) {
448 return blend(SPECIES.broadcast(o), m);
449 }
450
451
452 @Override
453 @ForceInline
454 public IntVector and(int o) {
455 return and(SPECIES.broadcast(o));
456 }
457
458 @Override
459 @ForceInline
460 public IntVector and(int o, Mask<Integer> m) {
461 return and(SPECIES.broadcast(o), m);
462 }
463
464 @Override
465 @ForceInline
466 public IntVector or(int o) {
467 return or(SPECIES.broadcast(o));
468 }
469
470 @Override
471 @ForceInline
472 public IntVector or(int o, Mask<Integer> m) {
473 return or(SPECIES.broadcast(o), m);
474 }
475
476 @Override
477 @ForceInline
478 public IntVector xor(int o) {
479 return xor(SPECIES.broadcast(o));
480 }
481
482 @Override
483 @ForceInline
484 public IntVector xor(int o, Mask<Integer> m) {
485 return xor(SPECIES.broadcast(o), m);
486 }
487
488 @Override
489 @ForceInline
490 public Int256Vector neg() {
491 return (Int256Vector)zero(SPECIES).sub(this);
492 }
493
494 // Unary operations
495
496 @ForceInline
497 @Override
498 public Int256Vector neg(Mask<Integer> m) {
499 return blend(neg(), m);
500 }
501
502 @Override
503 @ForceInline
504 public Int256Vector abs() {
505 return VectorIntrinsics.unaryOp(
506 VECTOR_OP_ABS, Int256Vector.class, int.class, LENGTH,
507 this,
508 v1 -> v1.uOp((i, a) -> (int) Math.abs(a)));
509 }
510
511 @ForceInline
512 @Override
513 public Int256Vector abs(Mask<Integer> m) {
514 return blend(abs(), m);
515 }
516
517
518 @Override
519 @ForceInline
520 public Int256Vector not() {
521 return VectorIntrinsics.unaryOp(
522 VECTOR_OP_NOT, Int256Vector.class, int.class, LENGTH,
523 this,
524 v1 -> v1.uOp((i, a) -> (int) ~a));
525 }
526
527 @ForceInline
528 @Override
529 public Int256Vector not(Mask<Integer> m) {
530 return blend(not(), m);
531 }
532 // Binary operations
533
534 @Override
535 @ForceInline
536 public Int256Vector add(Vector<Integer> o) {
537 Objects.requireNonNull(o);
538 Int256Vector v = (Int256Vector)o;
539 return VectorIntrinsics.binaryOp(
540 VECTOR_OP_ADD, Int256Vector.class, int.class, LENGTH,
541 this, v,
542 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (int)(a + b)));
543 }
544
545 @Override
546 @ForceInline
547 public Int256Vector add(Vector<Integer> v, Mask<Integer> m) {
548 return blend(add(v), m);
549 }
550
551 @Override
552 @ForceInline
553 public Int256Vector sub(Vector<Integer> o) {
554 Objects.requireNonNull(o);
555 Int256Vector v = (Int256Vector)o;
556 return VectorIntrinsics.binaryOp(
557 VECTOR_OP_SUB, Int256Vector.class, int.class, LENGTH,
558 this, v,
559 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (int)(a - b)));
560 }
561
562 @Override
563 @ForceInline
564 public Int256Vector sub(Vector<Integer> v, Mask<Integer> m) {
565 return blend(sub(v), m);
566 }
567
568 @Override
569 @ForceInline
570 public Int256Vector mul(Vector<Integer> o) {
571 Objects.requireNonNull(o);
572 Int256Vector v = (Int256Vector)o;
573 return VectorIntrinsics.binaryOp(
574 VECTOR_OP_MUL, Int256Vector.class, int.class, LENGTH,
575 this, v,
576 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (int)(a * b)));
577 }
578
579 @Override
580 @ForceInline
581 public Int256Vector mul(Vector<Integer> v, Mask<Integer> m) {
582 return blend(mul(v), m);
583 }
584
585 @Override
586 @ForceInline
587 public Int256Vector min(Vector<Integer> o) {
588 Objects.requireNonNull(o);
589 Int256Vector v = (Int256Vector)o;
590 return (Int256Vector) VectorIntrinsics.binaryOp(
591 VECTOR_OP_MIN, Int256Vector.class, int.class, LENGTH,
592 this, v,
593 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (int) Math.min(a, b)));
594 }
595
596 @Override
597 @ForceInline
598 public Int256Vector min(Vector<Integer> v, Mask<Integer> m) {
599 return blend(min(v), m);
600 }
601
602 @Override
603 @ForceInline
604 public Int256Vector max(Vector<Integer> o) {
605 Objects.requireNonNull(o);
606 Int256Vector v = (Int256Vector)o;
607 return VectorIntrinsics.binaryOp(
608 VECTOR_OP_MAX, Int256Vector.class, int.class, LENGTH,
609 this, v,
610 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (int) Math.max(a, b)));
611 }
612
613 @Override
614 @ForceInline
615 public Int256Vector max(Vector<Integer> v, Mask<Integer> m) {
616 return blend(max(v), m);
617 }
618
619 @Override
620 @ForceInline
621 public Int256Vector and(Vector<Integer> o) {
622 Objects.requireNonNull(o);
623 Int256Vector v = (Int256Vector)o;
624 return VectorIntrinsics.binaryOp(
625 VECTOR_OP_AND, Int256Vector.class, int.class, LENGTH,
626 this, v,
627 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (int)(a & b)));
628 }
629
630 @Override
631 @ForceInline
632 public Int256Vector or(Vector<Integer> o) {
633 Objects.requireNonNull(o);
634 Int256Vector v = (Int256Vector)o;
635 return VectorIntrinsics.binaryOp(
636 VECTOR_OP_OR, Int256Vector.class, int.class, LENGTH,
637 this, v,
638 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (int)(a | b)));
639 }
640
641 @Override
642 @ForceInline
643 public Int256Vector xor(Vector<Integer> o) {
644 Objects.requireNonNull(o);
645 Int256Vector v = (Int256Vector)o;
646 return VectorIntrinsics.binaryOp(
647 VECTOR_OP_XOR, Int256Vector.class, int.class, LENGTH,
648 this, v,
649 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (int)(a ^ b)));
650 }
651
652 @Override
653 @ForceInline
654 public Int256Vector and(Vector<Integer> v, Mask<Integer> m) {
655 return blend(and(v), m);
656 }
657
658 @Override
659 @ForceInline
660 public Int256Vector or(Vector<Integer> v, Mask<Integer> m) {
661 return blend(or(v), m);
662 }
663
664 @Override
665 @ForceInline
666 public Int256Vector xor(Vector<Integer> v, Mask<Integer> m) {
667 return blend(xor(v), m);
668 }
669
670 @Override
671 @ForceInline
672 public Int256Vector shiftL(int s) {
673 return VectorIntrinsics.broadcastInt(
674 VECTOR_OP_LSHIFT, Int256Vector.class, int.class, LENGTH,
675 this, s,
676 (v, i) -> v.uOp((__, a) -> (int) (a << i)));
677 }
678
679 @Override
680 @ForceInline
681 public Int256Vector shiftL(int s, Mask<Integer> m) {
682 return blend(shiftL(s), m);
683 }
684
685 @Override
686 @ForceInline
687 public Int256Vector shiftR(int s) {
688 return VectorIntrinsics.broadcastInt(
689 VECTOR_OP_URSHIFT, Int256Vector.class, int.class, LENGTH,
690 this, s,
691 (v, i) -> v.uOp((__, a) -> (int) (a >>> i)));
692 }
693
694 @Override
695 @ForceInline
696 public Int256Vector shiftR(int s, Mask<Integer> m) {
697 return blend(shiftR(s), m);
698 }
699
700 @Override
701 @ForceInline
702 public Int256Vector aShiftR(int s) {
703 return VectorIntrinsics.broadcastInt(
704 VECTOR_OP_RSHIFT, Int256Vector.class, int.class, LENGTH,
705 this, s,
706 (v, i) -> v.uOp((__, a) -> (int) (a >> i)));
707 }
708
709 @Override
710 @ForceInline
711 public Int256Vector aShiftR(int s, Mask<Integer> m) {
712 return blend(aShiftR(s), m);
713 }
714
715 @Override
716 @ForceInline
717 public Int256Vector shiftL(Vector<Integer> s) {
718 Int256Vector shiftv = (Int256Vector)s;
719 // As per shift specification for Java, mask the shift count.
720 shiftv = shiftv.and(species().broadcast(0x1f));
721 return VectorIntrinsics.binaryOp(
722 VECTOR_OP_LSHIFT, Int256Vector.class, int.class, LENGTH,
723 this, shiftv,
724 (v1, v2) -> v1.bOp(v2,(i,a, b) -> (int) (a << b)));
725 }
726
727 @Override
728 @ForceInline
729 public Int256Vector shiftR(Vector<Integer> s) {
730 Int256Vector shiftv = (Int256Vector)s;
731 // As per shift specification for Java, mask the shift count.
732 shiftv = shiftv.and(species().broadcast(0x1f));
733 return VectorIntrinsics.binaryOp(
734 VECTOR_OP_URSHIFT, Int256Vector.class, int.class, LENGTH,
735 this, shiftv,
736 (v1, v2) -> v1.bOp(v2,(i,a, b) -> (int) (a >>> b)));
737 }
738
739 @Override
740 @ForceInline
741 public Int256Vector aShiftR(Vector<Integer> s) {
742 Int256Vector shiftv = (Int256Vector)s;
743 // As per shift specification for Java, mask the shift count.
744 shiftv = shiftv.and(species().broadcast(0x1f));
745 return VectorIntrinsics.binaryOp(
746 VECTOR_OP_RSHIFT, Int256Vector.class, int.class, LENGTH,
747 this, shiftv,
748 (v1, v2) -> v1.bOp(v2,(i,a, b) -> (int) (a >> b)));
749 }
750 // Ternary operations
751
752
753 // Type specific horizontal reductions
754
755 @Override
756 @ForceInline
757 public int addAll() {
758 return (int) VectorIntrinsics.reductionCoerced(
759 VECTOR_OP_ADD, Int256Vector.class, int.class, LENGTH,
760 this,
761 v -> (long) v.rOp((int) 0, (i, a, b) -> (int) (a + b)));
762 }
763
764 @Override
765 @ForceInline
766 public int andAll() {
767 return (int) VectorIntrinsics.reductionCoerced(
768 VECTOR_OP_AND, Int256Vector.class, int.class, LENGTH,
769 this,
770 v -> (long) v.rOp((int) -1, (i, a, b) -> (int) (a & b)));
771 }
772
773 @Override
774 @ForceInline
775 public int andAll(Mask<Integer> m) {
776 return SPECIES.broadcast((int) -1).blend(this, m).andAll();
777 }
778
779 @Override
780 @ForceInline
781 public int minAll() {
782 return (int) VectorIntrinsics.reductionCoerced(
783 VECTOR_OP_MIN, Int256Vector.class, int.class, LENGTH,
784 this,
785 v -> (long) v.rOp(Integer.MAX_VALUE , (i, a, b) -> (int) Math.min(a, b)));
786 }
787
788 @Override
789 @ForceInline
790 public int maxAll() {
791 return (int) VectorIntrinsics.reductionCoerced(
792 VECTOR_OP_MAX, Int256Vector.class, int.class, LENGTH,
793 this,
794 v -> (long) v.rOp(Integer.MIN_VALUE , (i, a, b) -> (int) Math.max(a, b)));
795 }
796
797 @Override
798 @ForceInline
799 public int mulAll() {
800 return (int) VectorIntrinsics.reductionCoerced(
801 VECTOR_OP_MUL, Int256Vector.class, int.class, LENGTH,
802 this,
803 v -> (long) v.rOp((int) 1, (i, a, b) -> (int) (a * b)));
804 }
805
806 @Override
807 @ForceInline
808 public int orAll() {
809 return (int) VectorIntrinsics.reductionCoerced(
810 VECTOR_OP_OR, Int256Vector.class, int.class, LENGTH,
811 this,
812 v -> (long) v.rOp((int) 0, (i, a, b) -> (int) (a | b)));
813 }
814
815 @Override
816 @ForceInline
817 public int orAll(Mask<Integer> m) {
818 return SPECIES.broadcast((int) 0).blend(this, m).orAll();
819 }
820
821 @Override
822 @ForceInline
823 public int xorAll() {
824 return (int) VectorIntrinsics.reductionCoerced(
825 VECTOR_OP_XOR, Int256Vector.class, int.class, LENGTH,
826 this,
827 v -> (long) v.rOp((int) 0, (i, a, b) -> (int) (a ^ b)));
828 }
829
830 @Override
831 @ForceInline
832 public int xorAll(Mask<Integer> m) {
833 return SPECIES.broadcast((int) 0).blend(this, m).xorAll();
834 }
835
836
837 @Override
838 @ForceInline
839 public int addAll(Mask<Integer> m) {
840 return SPECIES.broadcast((int) 0).blend(this, m).addAll();
841 }
842
843
844 @Override
845 @ForceInline
846 public int mulAll(Mask<Integer> m) {
847 return SPECIES.broadcast((int) 1).blend(this, m).mulAll();
848 }
849
850 @Override
851 @ForceInline
852 public int minAll(Mask<Integer> m) {
853 return SPECIES.broadcast(Integer.MAX_VALUE).blend(this, m).minAll();
854 }
855
856 @Override
857 @ForceInline
858 public int maxAll(Mask<Integer> m) {
859 return SPECIES.broadcast(Integer.MIN_VALUE).blend(this, m).maxAll();
860 }
861
862 @Override
863 @ForceInline
864 public Shuffle<Integer> toShuffle() {
865 int[] a = toArray();
866 int[] sa = new int[a.length];
867 for (int i = 0; i < a.length; i++) {
868 sa[i] = (int) a[i];
869 }
870 return IntVector.shuffleFromArray(SPECIES, sa, 0);
871 }
872
873 // Memory operations
874
875 private static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_INT_INDEX_SCALE);
876 private static final int BOOLEAN_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BOOLEAN_INDEX_SCALE);
877
878 @Override
879 @ForceInline
880 public void intoArray(int[] a, int ix) {
881 Objects.requireNonNull(a);
882 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
883 intoArrayWithoutCheck(a, ix);
884 }
885
886 @ForceInline
887 private void intoArrayWithoutCheck(int[] a, int ix) {
888 VectorIntrinsics.store(Int256Vector.class, int.class, LENGTH,
889 a, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_INT_BASE_OFFSET,
890 this,
891 a, ix,
892 (arr, idx, v) -> v.forEach((i, e) -> arr[idx + i] = e));
893 }
894
895 @Override
896 @ForceInline
897 public final void intoArray(int[] a, int ax, Mask<Integer> m) {
898 Objects.requireNonNull(a);
899 if (ax + LENGTH <= a.length) {
900 IntVector oldVal = IntVector.fromArrayWithoutCheck(SPECIES, a, ax);
901 IntVector newVal = oldVal.blend(this, m);
902 ((Int256Vector)newVal).intoArrayWithoutCheck(a, ax);
903 } else {
904 forEach(m, (i, e) -> a[ax + i] = e);
905 }
906 }
907
908 @Override
909 @ForceInline
910 public void intoArray(int[] a, int ix, int[] b, int iy) {
911 Objects.requireNonNull(a);
912 Objects.requireNonNull(b);
913
914 // Index vector: vix[0:n] = i -> ix + indexMap[iy + i]
915 IntVector vix = IntVector.fromArray(INDEX_SPEC, b, iy).add(ix);
916
917 vix = VectorIntrinsics.checkIndex(vix, a.length);
918
919 intoArrayWithoutCheck(a, ix, b, iy, vix);
920 }
921
922 @ForceInline
923 private void intoArrayWithoutCheck(int[] a, int ix, int[] b, int iy, IntVector vix) {
924 VectorIntrinsics.storeWithMap(Int256Vector.class, int.class, LENGTH, Int256Vector.class,
925 a, Unsafe.ARRAY_INT_BASE_OFFSET, vix,
926 this,
927 a, ix, b, iy,
928 (arr, idx, v, indexMap, idy) -> v.forEach((i, e) -> arr[idx+indexMap[idy+i]] = e));
929 }
930
931 @Override
932 @ForceInline
933 public final void intoArray(int[] a, int ax, Mask<Integer> m, int[] b, int iy) {
934 Objects.requireNonNull(a);
935 Objects.requireNonNull(b);
936
937 // Index vector: vix[0:n] = i -> ax + b[iy + i]
938 IntVector vix = IntVector.fromArray(INDEX_SPEC, b, iy).add(ax);
939
940 if(vix.lessThan(0).anyTrue() || vix.greaterThanEq(a.length).anyTrue()) {
941 forEach(m, (i, e) -> a[ax + b[iy+i]] = e);
942 } else {
943 IntVector oldVal = IntVector.fromArrayWithoutCheck(SPECIES, a, ax, b, iy, vix);
944 IntVector newVal = oldVal.blend(this, m);
945 ((Int256Vector)newVal).intoArrayWithoutCheck(a, ax, b, iy, vix);
946 }
947 }
948
949 @Override
950 @ForceInline
951 public void intoByteArray(byte[] a, int ix) {
952 Objects.requireNonNull(a);
953 ix = VectorIntrinsics.checkIndex(ix, a.length, bitSize() / Byte.SIZE);
954 VectorIntrinsics.store(Int256Vector.class, int.class, LENGTH,
955 a, ((long) ix) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
956 this,
957 a, ix,
958 (c, idx, v) -> {
959 ByteBuffer bbc = ByteBuffer.wrap(c, idx, c.length - idx).order(ByteOrder.nativeOrder());
960 IntBuffer tb = bbc.asIntBuffer();
961 v.forEach((i, e) -> tb.put(e));
962 });
963 }
964
965 @Override
966 @ForceInline
967 public final void intoByteArray(byte[] a, int ix, Mask<Integer> m) {
968 Int256Vector oldVal = (Int256Vector) IntVector.fromByteArray(SPECIES, a, ix);
969 Int256Vector newVal = oldVal.blend(this, m);
970 newVal.intoByteArray(a, ix);
971 }
972
973 @Override
974 @ForceInline
975 public void intoByteBuffer(ByteBuffer bb, int ix) {
976 if (bb.order() != ByteOrder.nativeOrder()) {
977 throw new IllegalArgumentException();
978 }
979 if (bb.isReadOnly()) {
980 throw new ReadOnlyBufferException();
981 }
982 ix = VectorIntrinsics.checkIndex(ix, bb.limit(), bitSize() / Byte.SIZE);
983 VectorIntrinsics.store(Int256Vector.class, int.class, LENGTH,
984 U.getReference(bb, BYTE_BUFFER_HB), ix + U.getLong(bb, BUFFER_ADDRESS),
985 this,
986 bb, ix,
987 (c, idx, v) -> {
988 ByteBuffer bbc = c.duplicate().position(idx).order(ByteOrder.nativeOrder());
989 IntBuffer tb = bbc.asIntBuffer();
990 v.forEach((i, e) -> tb.put(e));
991 });
992 }
993
994 @Override
995 @ForceInline
996 public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Integer> m) {
997 Int256Vector oldVal = (Int256Vector) IntVector.fromByteBuffer(SPECIES, bb, ix);
998 Int256Vector newVal = oldVal.blend(this, m);
999 newVal.intoByteBuffer(bb, ix);
1000 }
1001
1002 //
1003
1004 @Override
1005 public String toString() {
1006 return Arrays.toString(getElements());
1007 }
1008
1009 @Override
1010 public boolean equals(Object o) {
1011 if (this == o) return true;
1012 if (o == null || this.getClass() != o.getClass()) return false;
1013
1014 Int256Vector that = (Int256Vector) o;
1015 return this.equal(that).allTrue();
1016 }
1017
1018 @Override
1019 public int hashCode() {
1020 return Arrays.hashCode(vec);
1021 }
1022
1023 // Binary test
1024
1025 @Override
1026 Int256Mask bTest(Vector<Integer> o, FBinTest f) {
1027 int[] vec1 = getElements();
1028 int[] vec2 = ((Int256Vector)o).getElements();
1029 boolean[] bits = new boolean[length()];
1030 for (int i = 0; i < length(); i++){
1031 bits[i] = f.apply(i, vec1[i], vec2[i]);
1032 }
1033 return new Int256Mask(bits);
1034 }
1035
1036 // Comparisons
1037
1038 @Override
1039 @ForceInline
1040 public Int256Mask equal(Vector<Integer> o) {
1041 Objects.requireNonNull(o);
1042 Int256Vector v = (Int256Vector)o;
1043
1044 return VectorIntrinsics.compare(
1045 BT_eq, Int256Vector.class, Int256Mask.class, int.class, LENGTH,
1046 this, v,
1047 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a == b));
1048 }
1049
1050 @Override
1051 @ForceInline
1052 public Int256Mask notEqual(Vector<Integer> o) {
1053 Objects.requireNonNull(o);
1054 Int256Vector v = (Int256Vector)o;
1055
1056 return VectorIntrinsics.compare(
1057 BT_ne, Int256Vector.class, Int256Mask.class, int.class, LENGTH,
1058 this, v,
1059 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a != b));
1060 }
1061
1062 @Override
1063 @ForceInline
1064 public Int256Mask lessThan(Vector<Integer> o) {
1065 Objects.requireNonNull(o);
1066 Int256Vector v = (Int256Vector)o;
1067
1068 return VectorIntrinsics.compare(
1069 BT_lt, Int256Vector.class, Int256Mask.class, int.class, LENGTH,
1070 this, v,
1071 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a < b));
1072 }
1073
1074 @Override
1075 @ForceInline
1076 public Int256Mask lessThanEq(Vector<Integer> o) {
1077 Objects.requireNonNull(o);
1078 Int256Vector v = (Int256Vector)o;
1079
1080 return VectorIntrinsics.compare(
1081 BT_le, Int256Vector.class, Int256Mask.class, int.class, LENGTH,
1082 this, v,
1083 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a <= b));
1084 }
1085
1086 @Override
1087 @ForceInline
1088 public Int256Mask greaterThan(Vector<Integer> o) {
1089 Objects.requireNonNull(o);
1090 Int256Vector v = (Int256Vector)o;
1091
1092 return (Int256Mask) VectorIntrinsics.compare(
1093 BT_gt, Int256Vector.class, Int256Mask.class, int.class, LENGTH,
1094 this, v,
1095 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a > b));
1096 }
1097
1098 @Override
1099 @ForceInline
1100 public Int256Mask greaterThanEq(Vector<Integer> o) {
1101 Objects.requireNonNull(o);
1102 Int256Vector v = (Int256Vector)o;
1103
1104 return VectorIntrinsics.compare(
1105 BT_ge, Int256Vector.class, Int256Mask.class, int.class, LENGTH,
1106 this, v,
1107 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a >= b));
1108 }
1109
1110 // Foreach
1111
1112 @Override
1113 void forEach(FUnCon f) {
1114 int[] vec = getElements();
1115 for (int i = 0; i < length(); i++) {
1116 f.apply(i, vec[i]);
1117 }
1118 }
1119
1120 @Override
1121 void forEach(Mask<Integer> o, FUnCon f) {
1122 boolean[] mbits = ((Int256Mask)o).getBits();
1123 forEach((i, a) -> {
1124 if (mbits[i]) { f.apply(i, a); }
1125 });
1126 }
1127
1128
1129 Float256Vector toFP() {
1130 int[] vec = getElements();
1131 float[] res = new float[this.species().length()];
1132 for(int i = 0; i < this.species().length(); i++){
1133 res[i] = Float.intBitsToFloat(vec[i]);
1134 }
1135 return new Float256Vector(res);
1136 }
1137
1138 @Override
1139 public Int256Vector rotateEL(int j) {
1140 int[] vec = getElements();
1141 int[] res = new int[length()];
1142 for (int i = 0; i < length(); i++){
1143 res[(j + i) % length()] = vec[i];
1144 }
1145 return new Int256Vector(res);
1146 }
1147
1148 @Override
1149 public Int256Vector rotateER(int j) {
1150 int[] vec = getElements();
1151 int[] res = new int[length()];
1152 for (int i = 0; i < length(); i++){
1153 int z = i - j;
1154 if(j < 0) {
1155 res[length() + z] = vec[i];
1156 } else {
1157 res[z] = vec[i];
1158 }
1159 }
1160 return new Int256Vector(res);
1161 }
1162
1163 @Override
1164 public Int256Vector shiftEL(int j) {
1165 int[] vec = getElements();
1166 int[] res = new int[length()];
1167 for (int i = 0; i < length() - j; i++) {
1168 res[i] = vec[i + j];
1169 }
1170 return new Int256Vector(res);
1171 }
1172
1173 @Override
1174 public Int256Vector shiftER(int j) {
1175 int[] vec = getElements();
1176 int[] res = new int[length()];
1177 for (int i = 0; i < length() - j; i++){
1178 res[i + j] = vec[i];
1179 }
1180 return new Int256Vector(res);
1181 }
1182
1183 @Override
1184 @ForceInline
1185 public Int256Vector rearrange(Vector<Integer> v,
1186 Shuffle<Integer> s, Mask<Integer> m) {
1187 return this.rearrange(s).blend(v.rearrange(s), m);
1188 }
1189
1190 @Override
1191 @ForceInline
1192 public Int256Vector rearrange(Shuffle<Integer> o1) {
1193 Objects.requireNonNull(o1);
1194 Int256Shuffle s = (Int256Shuffle)o1;
1195
1196 return VectorIntrinsics.rearrangeOp(
1197 Int256Vector.class, Int256Shuffle.class, int.class, LENGTH,
1198 this, s,
1199 (v1, s_) -> v1.uOp((i, a) -> {
1200 int ei = s_.getElement(i);
1201 return v1.get(ei);
1202 }));
1203 }
1204
1205 @Override
1206 @ForceInline
1207 public Int256Vector blend(Vector<Integer> o1, Mask<Integer> o2) {
1208 Objects.requireNonNull(o1);
1209 Objects.requireNonNull(o2);
1210 Int256Vector v = (Int256Vector)o1;
1211 Int256Mask m = (Int256Mask)o2;
1212
1213 return VectorIntrinsics.blend(
1214 Int256Vector.class, Int256Mask.class, int.class, LENGTH,
1215 this, v, m,
1216 (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.getElement(i) ? b : a));
1217 }
1218
1219 // Accessors
1220
1221 @Override
1222 public int get(int i) {
1223 if (i < 0 || i >= LENGTH) {
1224 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1225 }
1226 return (int) VectorIntrinsics.extract(
1227 Int256Vector.class, int.class, LENGTH,
1228 this, i,
1229 (vec, ix) -> {
1230 int[] vecarr = vec.getElements();
1231 return (long)vecarr[ix];
1232 });
1233 }
1234
1235 @Override
1236 public Int256Vector with(int i, int e) {
1237 if (i < 0 || i >= LENGTH) {
1238 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1239 }
1240 return VectorIntrinsics.insert(
1241 Int256Vector.class, int.class, LENGTH,
1242 this, i, (long)e,
1243 (v, ix, bits) -> {
1244 int[] res = v.getElements().clone();
1245 res[ix] = (int)bits;
1246 return new Int256Vector(res);
1247 });
1248 }
1249
1250 // Mask
1251
1252 static final class Int256Mask extends AbstractMask<Integer> {
1253 static final Int256Mask TRUE_MASK = new Int256Mask(true);
1254 static final Int256Mask FALSE_MASK = new Int256Mask(false);
1255
1256 private final boolean[] bits; // Don't access directly, use getBits() instead.
1257
1258 public Int256Mask(boolean[] bits) {
1259 this(bits, 0);
1260 }
1261
1262 public Int256Mask(boolean[] bits, int offset) {
1263 boolean[] a = new boolean[species().length()];
1264 for (int i = 0; i < a.length; i++) {
1265 a[i] = bits[offset + i];
1266 }
1267 this.bits = a;
1268 }
1269
1270 public Int256Mask(boolean val) {
1271 boolean[] bits = new boolean[species().length()];
1272 Arrays.fill(bits, val);
1273 this.bits = bits;
1274 }
1275
1276 boolean[] getBits() {
1277 return VectorIntrinsics.maybeRebox(this).bits;
1278 }
1279
1280 @Override
1281 Int256Mask uOp(MUnOp f) {
1282 boolean[] res = new boolean[species().length()];
1283 boolean[] bits = getBits();
1284 for (int i = 0; i < species().length(); i++) {
1285 res[i] = f.apply(i, bits[i]);
1286 }
1287 return new Int256Mask(res);
1288 }
1289
1290 @Override
1291 Int256Mask bOp(Mask<Integer> o, MBinOp f) {
1292 boolean[] res = new boolean[species().length()];
1293 boolean[] bits = getBits();
1294 boolean[] mbits = ((Int256Mask)o).getBits();
1295 for (int i = 0; i < species().length(); i++) {
1296 res[i] = f.apply(i, bits[i], mbits[i]);
1297 }
1298 return new Int256Mask(res);
1299 }
1300
1301 @Override
1302 public Int256Species species() {
1303 return SPECIES;
1304 }
1305
1306 @Override
1307 public Int256Vector toVector() {
1308 int[] res = new int[species().length()];
1309 boolean[] bits = getBits();
1310 for (int i = 0; i < species().length(); i++) {
1311 // -1 will result in the most significant bit being set in
1312 // addition to some or all other bits
1313 res[i] = (int) (bits[i] ? -1 : 0);
1314 }
1315 return new Int256Vector(res);
1316 }
1317
1318 // Unary operations
1319
1320 @Override
1321 @ForceInline
1322 public Int256Mask not() {
1323 return (Int256Mask) VectorIntrinsics.unaryOp(
1324 VECTOR_OP_NOT, Int256Mask.class, int.class, LENGTH,
1325 this,
1326 (m1) -> m1.uOp((i, a) -> !a));
1327 }
1328
1329 // Binary operations
1330
1331 @Override
1332 @ForceInline
1333 public Int256Mask and(Mask<Integer> o) {
1334 Objects.requireNonNull(o);
1335 Int256Mask m = (Int256Mask)o;
1336 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Int256Mask.class, int.class, LENGTH,
1337 this, m,
1338 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b));
1339 }
1340
1341 @Override
1342 @ForceInline
1343 public Int256Mask or(Mask<Integer> o) {
1344 Objects.requireNonNull(o);
1345 Int256Mask m = (Int256Mask)o;
1346 return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Int256Mask.class, int.class, LENGTH,
1347 this, m,
1348 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b));
1349 }
1350
1351 // Reductions
1352
1353 @Override
1354 @ForceInline
1355 public boolean anyTrue() {
1356 return VectorIntrinsics.test(BT_ne, Int256Mask.class, int.class, LENGTH,
1357 this, this,
1358 (m, __) -> anyTrueHelper(((Int256Mask)m).getBits()));
1359 }
1360
1361 @Override
1362 @ForceInline
1363 public boolean allTrue() {
1364 return VectorIntrinsics.test(BT_overflow, Int256Mask.class, int.class, LENGTH,
1365 this, IntVector.maskAllTrue(species()),
1366 (m, __) -> allTrueHelper(((Int256Mask)m).getBits()));
1367 }
1368 }
1369
1370 // Shuffle
1371
1372 static final class Int256Shuffle extends AbstractShuffle<Integer> {
1373 Int256Shuffle(byte[] reorder) {
1374 super(reorder);
1375 }
1376
1377 public Int256Shuffle(int[] reorder) {
1378 super(reorder);
1379 }
1380
1381 public Int256Shuffle(int[] reorder, int i) {
1382 super(reorder, i);
1383 }
1384
1385 public Int256Shuffle(IntUnaryOperator f) {
1386 super(f);
1387 }
1388
1389 @Override
1390 public Int256Species species() {
1391 return SPECIES;
1392 }
1393
1394 @Override
1395 public IntVector toVector() {
1396 int[] va = new int[SPECIES.length()];
1397 for (int i = 0; i < va.length; i++) {
1398 va[i] = (int) getElement(i);
1399 }
1400 return IntVector.fromArray(SPECIES, va, 0);
1401 }
1402
1403 @Override
1404 public Int256Shuffle rearrange(Vector.Shuffle<Integer> o) {
1405 Int256Shuffle s = (Int256Shuffle) o;
1406 byte[] r = new byte[reorder.length];
1407 for (int i = 0; i < reorder.length; i++) {
1408 r[i] = reorder[s.reorder[i]];
1409 }
1410 return new Int256Shuffle(r);
1411 }
1412 }
1413
1414 // Species
1415
1416 @Override
1417 public Int256Species species() {
1418 return SPECIES;
1419 }
1420
1421 static final class Int256Species extends IntSpecies {
1422 static final int BIT_SIZE = Shape.S_256_BIT.bitSize();
1423
1424 static final int LENGTH = BIT_SIZE / Integer.SIZE;
1425
1426 @Override
1427 public String toString() {
1428 StringBuilder sb = new StringBuilder("Shape[");
1429 sb.append(bitSize()).append(" bits, ");
1430 sb.append(length()).append(" ").append(int.class.getSimpleName()).append("s x ");
1431 sb.append(elementSize()).append(" bits");
1432 sb.append("]");
1433 return sb.toString();
1434 }
1435
1436 @Override
1437 @ForceInline
1438 public int bitSize() {
1439 return BIT_SIZE;
1440 }
1441
1442 @Override
1443 @ForceInline
1444 public int length() {
1445 return LENGTH;
1446 }
1447
1448 @Override
1449 @ForceInline
1450 public Class<Integer> elementType() {
1451 return int.class;
1452 }
1453
1454 @Override
1455 @ForceInline
1456 public Class<?> boxType() {
1457 return Int256Vector.class;
1458 }
1459
1460 @Override
1461 @ForceInline
1462 public Class<?> maskType() {
1463 return Int256Mask.class;
1464 }
1465
1466 @Override
1467 @ForceInline
1468 public int elementSize() {
1469 return Integer.SIZE;
1470 }
1471
1472 @Override
1473 @ForceInline
1474 @SuppressWarnings("unchecked")
1475 Class<?> vectorType() {
1476 return Int256Vector.class;
1477 }
1478
1479 @Override
1480 @ForceInline
1481 public Shape shape() {
1482 return Shape.S_256_BIT;
1483 }
1484
1485 @Override
1486 IntVector.IntSpecies indexSpecies() {
1487 return INDEX_SPEC;
1488 }
1489
1490 @Override
1491 Int256Vector op(FOp f) {
1492 int[] res = new int[length()];
1493 for (int i = 0; i < length(); i++) {
1494 res[i] = f.apply(i);
1495 }
1496 return new Int256Vector(res);
1497 }
1498
1499 @Override
1500 Int256Vector op(Mask<Integer> o, FOp f) {
1501 int[] res = new int[length()];
1502 boolean[] mbits = ((Int256Mask)o).getBits();
1503 for (int i = 0; i < length(); i++) {
1504 if (mbits[i]) {
1505 res[i] = f.apply(i);
1506 }
1507 }
1508 return new Int256Vector(res);
1509 }
1510
1511 @Override
1512 Int256Mask opm(FOpm f) {
1513 boolean[] res = new boolean[length()];
1514 for (int i = 0; i < length(); i++) {
1515 res[i] = (boolean)f.apply(i);
1516 }
1517 return new Int256Mask(res);
1518 }
1519
1520 // Factories
1521
1522 @Override
1523 @ForceInline
1524 public Int256Vector zero() {
1525 return VectorIntrinsics.broadcastCoerced(Int256Vector.class, int.class, LENGTH,
1526 0, SPECIES,
1527 ((bits, s) -> ((Int256Species)s).op(i -> (int)bits)));
1528 }
1529
1530 @Override
1531 @ForceInline
1532 public Int256Vector broadcast(int e) {
1533 return VectorIntrinsics.broadcastCoerced(
1534 Int256Vector.class, int.class, LENGTH,
1535 e, SPECIES,
1536 ((bits, s) -> ((Int256Species)s).op(i -> (int)bits)));
1537 }
1538
1539 @Override
1540 @ForceInline
1541 public Int256Vector scalars(int... es) {
1542 Objects.requireNonNull(es);
1543 int ix = VectorIntrinsics.checkIndex(0, es.length, LENGTH);
1544 return VectorIntrinsics.load(Int256Vector.class, int.class, LENGTH,
1545 es, Unsafe.ARRAY_INT_BASE_OFFSET,
1546 es, ix, SPECIES,
1547 (c, idx, s) -> ((Int256Species)s).op(n -> c[idx + n]));
1548 }
1549
1550 @Override
1551 @ForceInline
1552 public <E> Int256Mask cast(Mask<E> m) {
1553 if (m.length() != LENGTH)
1554 throw new IllegalArgumentException("Mask length this species length differ");
1555 return new Int256Mask(m.toArray());
1556 }
1557
1558 @Override
1559 @ForceInline
1560 public <E> Int256Shuffle cast(Shuffle<E> s) {
1561 if (s.length() != LENGTH)
1562 throw new IllegalArgumentException("Shuffle length this species length differ");
1563 return new Int256Shuffle(s.toArray());
1564 }
1565 }
1566 }