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.util.Arrays;
29 import java.util.Objects;
30 import jdk.internal.vm.annotation.ForceInline;
31 import static jdk.incubator.vector.VectorIntrinsics.*;
32
33 @SuppressWarnings("cast")
34 final class Long64Vector extends LongVector<Shapes.S64Bit> {
35 static final Long64Species SPECIES = new Long64Species();
36
37 static final Long64Vector ZERO = new Long64Vector();
38
39 static final int LENGTH = SPECIES.length();
40
41 private final long[] vec; // Don't access directly, use getElements() instead.
42
43 private long[] getElements() {
44 return VectorIntrinsics.maybeRebox(this).vec;
45 }
46
47 Long64Vector() {
48 vec = new long[SPECIES.length()];
49 }
50
51 Long64Vector(long[] v) {
52 vec = v;
53 }
54
55 @Override
56 public int length() { return LENGTH; }
57
58 // Unary operator
59
60 @Override
61 Long64Vector uOp(FUnOp f) {
62 long[] vec = getElements();
63 long[] res = new long[length()];
64 for (int i = 0; i < length(); i++) {
65 res[i] = f.apply(i, vec[i]);
66 }
67 return new Long64Vector(res);
68 }
69
70 @Override
71 Long64Vector uOp(Mask<Long, Shapes.S64Bit> o, FUnOp f) {
72 long[] vec = getElements();
73 long[] res = new long[length()];
74 boolean[] mbits = ((Long64Mask)o).getBits();
75 for (int i = 0; i < length(); i++) {
76 res[i] = mbits[i] ? f.apply(i, vec[i]) : vec[i];
77 }
78 return new Long64Vector(res);
79 }
80
81 // Binary operator
82
83 @Override
84 Long64Vector bOp(Vector<Long, Shapes.S64Bit> o, FBinOp f) {
85 long[] res = new long[length()];
86 long[] vec1 = this.getElements();
87 long[] vec2 = ((Long64Vector)o).getElements();
88 for (int i = 0; i < length(); i++) {
89 res[i] = f.apply(i, vec1[i], vec2[i]);
90 }
91 return new Long64Vector(res);
92 }
93
94 @Override
95 Long64Vector bOp(Vector<Long, Shapes.S64Bit> o1, Mask<Long, Shapes.S64Bit> o2, FBinOp f) {
96 long[] res = new long[length()];
97 long[] vec1 = this.getElements();
98 long[] vec2 = ((Long64Vector)o1).getElements();
99 boolean[] mbits = ((Long64Mask)o2).getBits();
100 for (int i = 0; i < length(); i++) {
101 res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i]) : vec1[i];
102 }
103 return new Long64Vector(res);
104 }
105
106 // Trinary operator
107
108 @Override
109 Long64Vector tOp(Vector<Long, Shapes.S64Bit> o1, Vector<Long, Shapes.S64Bit> o2, FTriOp f) {
110 long[] res = new long[length()];
111 long[] vec1 = this.getElements();
112 long[] vec2 = ((Long64Vector)o1).getElements();
113 long[] vec3 = ((Long64Vector)o2).getElements();
114 for (int i = 0; i < length(); i++) {
115 res[i] = f.apply(i, vec1[i], vec2[i], vec3[i]);
116 }
117 return new Long64Vector(res);
118 }
119
120 @Override
121 Long64Vector tOp(Vector<Long, Shapes.S64Bit> o1, Vector<Long, Shapes.S64Bit> o2, Mask<Long, Shapes.S64Bit> o3, FTriOp f) {
122 long[] res = new long[length()];
123 long[] vec1 = getElements();
124 long[] vec2 = ((Long64Vector)o1).getElements();
125 long[] vec3 = ((Long64Vector)o2).getElements();
126 boolean[] mbits = ((Long64Mask)o3).getBits();
127 for (int i = 0; i < length(); i++) {
128 res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i], vec3[i]) : vec1[i];
129 }
130 return new Long64Vector(res);
131 }
132
133 @Override
134 long rOp(long v, FBinOp f) {
135 long[] vec = getElements();
136 for (int i = 0; i < length(); i++) {
137 v = f.apply(i, v, vec[i]);
138 }
139 return v;
140 }
141
142 // Binary operations with scalars
143
144 @Override
145 @ForceInline
146 public LongVector<Shapes.S64Bit> add(long o) {
147 return add(SPECIES.broadcast(o));
148 }
149
150 @Override
151 @ForceInline
152 public LongVector<Shapes.S64Bit> add(long o, Mask<Long,Shapes.S64Bit> m) {
153 return add(SPECIES.broadcast(o), m);
154 }
155
156 @Override
157 @ForceInline
158 public LongVector<Shapes.S64Bit> addSaturate(long o) {
159 return addSaturate(SPECIES.broadcast(o));
160 }
161
162 @Override
163 @ForceInline
164 public LongVector<Shapes.S64Bit> addSaturate(long o, Mask<Long,Shapes.S64Bit> m) {
165 return addSaturate(SPECIES.broadcast(o), m);
166 }
167
168 @Override
169 @ForceInline
170 public LongVector<Shapes.S64Bit> sub(long o) {
171 return sub(SPECIES.broadcast(o));
172 }
173
174 @Override
175 @ForceInline
176 public LongVector<Shapes.S64Bit> sub(long o, Mask<Long,Shapes.S64Bit> m) {
177 return sub(SPECIES.broadcast(o), m);
178 }
179
180 @Override
181 @ForceInline
182 public LongVector<Shapes.S64Bit> subSaturate(long o) {
183 return subSaturate(SPECIES.broadcast(o));
184 }
185
186 @Override
187 @ForceInline
188 public LongVector<Shapes.S64Bit> subSaturate(long o, Mask<Long,Shapes.S64Bit> m) {
189 return subSaturate(SPECIES.broadcast(o), m);
190 }
191
192 @Override
193 @ForceInline
194 public LongVector<Shapes.S64Bit> mul(long o) {
195 return mul(SPECIES.broadcast(o));
196 }
197
198 @Override
199 @ForceInline
200 public LongVector<Shapes.S64Bit> mul(long o, Mask<Long,Shapes.S64Bit> m) {
201 return mul(SPECIES.broadcast(o), m);
202 }
203
204 @Override
205 @ForceInline
206 public LongVector<Shapes.S64Bit> min(long o) {
207 return min(SPECIES.broadcast(o));
208 }
209
210 @Override
211 @ForceInline
212 public LongVector<Shapes.S64Bit> max(long o) {
213 return max(SPECIES.broadcast(o));
214 }
215
216 @Override
217 @ForceInline
218 public Mask<Long, Shapes.S64Bit> equal(long o) {
219 return equal(SPECIES.broadcast(o));
220 }
221
222 @Override
223 @ForceInline
224 public Mask<Long, Shapes.S64Bit> notEqual(long o) {
225 return notEqual(SPECIES.broadcast(o));
226 }
227
228 @Override
229 @ForceInline
230 public Mask<Long, Shapes.S64Bit> lessThan(long o) {
231 return lessThan(SPECIES.broadcast(o));
232 }
233
234 @Override
235 @ForceInline
236 public Mask<Long, Shapes.S64Bit> lessThanEq(long o) {
237 return lessThanEq(SPECIES.broadcast(o));
238 }
239
240 @Override
241 @ForceInline
242 public Mask<Long, Shapes.S64Bit> greaterThan(long o) {
243 return greaterThan(SPECIES.broadcast(o));
244 }
245
246 @Override
247 @ForceInline
248 public Mask<Long, Shapes.S64Bit> greaterThanEq(long o) {
249 return greaterThanEq(SPECIES.broadcast(o));
250 }
251
252 @Override
253 @ForceInline
254 public LongVector<Shapes.S64Bit> blend(long o, Mask<Long,Shapes.S64Bit> m) {
255 return blend(SPECIES.broadcast(o), m);
256 }
257
258
259 @Override
260 @ForceInline
261 public LongVector<Shapes.S64Bit> and(long o) {
262 return and(SPECIES.broadcast(o));
263 }
264
265 @Override
266 @ForceInline
267 public LongVector<Shapes.S64Bit> and(long o, Mask<Long,Shapes.S64Bit> m) {
268 return and(SPECIES.broadcast(o), m);
269 }
270
271 @Override
272 @ForceInline
273 public LongVector<Shapes.S64Bit> or(long o) {
274 return or(SPECIES.broadcast(o));
275 }
276
277 @Override
278 @ForceInline
279 public LongVector<Shapes.S64Bit> or(long o, Mask<Long,Shapes.S64Bit> m) {
280 return or(SPECIES.broadcast(o), m);
281 }
282
283 @Override
284 @ForceInline
285 public LongVector<Shapes.S64Bit> xor(long o) {
286 return xor(SPECIES.broadcast(o));
287 }
288
289 @Override
290 @ForceInline
291 public LongVector<Shapes.S64Bit> xor(long o, Mask<Long,Shapes.S64Bit> m) {
292 return xor(SPECIES.broadcast(o), m);
293 }
294
295
296 // Unary operations
297
298 @Override
299 @ForceInline
300 public Long64Vector abs() {
301 return (Long64Vector) VectorIntrinsics.unaryOp(
302 VECTOR_OP_ABS, Long64Vector.class, long.class, LENGTH,
303 this,
304 v1 -> ((Long64Vector)v1).uOp((i, a) -> (long) Math.abs(a)));
305 }
306
307
308
309 @Override
310 @ForceInline
311 public Long64Vector not() {
312 return (Long64Vector) VectorIntrinsics.unaryOp(
313 VECTOR_OP_NOT, Long64Vector.class, long.class, LENGTH,
314 this,
315 v1 -> ((Long64Vector)v1).uOp((i, a) -> (long) ~a));
316 }
317 // Binary operations
318
319 @Override
320 @ForceInline
321 public Long64Vector add(Vector<Long,Shapes.S64Bit> o) {
322 Objects.requireNonNull(o);
323 Long64Vector v = (Long64Vector)o;
324 return (Long64Vector) VectorIntrinsics.binaryOp(
325 VECTOR_OP_ADD, Long64Vector.class, long.class, LENGTH,
326 this, v,
327 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a + b)));
328 }
329
330 @Override
331 @ForceInline
332 public Long64Vector sub(Vector<Long,Shapes.S64Bit> o) {
333 Objects.requireNonNull(o);
334 Long64Vector v = (Long64Vector)o;
335 return (Long64Vector) VectorIntrinsics.binaryOp(
336 VECTOR_OP_SUB, Long64Vector.class, long.class, LENGTH,
337 this, v,
338 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a - b)));
339 }
340
341 @Override
342 @ForceInline
343 public Long64Vector mul(Vector<Long,Shapes.S64Bit> o) {
344 Objects.requireNonNull(o);
345 Long64Vector v = (Long64Vector)o;
346 return (Long64Vector) VectorIntrinsics.binaryOp(
347 VECTOR_OP_MUL, Long64Vector.class, long.class, LENGTH,
348 this, v,
349 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a * b)));
350 }
351
352 @Override
353 @ForceInline
354 public Long64Vector min(Vector<Long,Shapes.S64Bit> o) {
355 Objects.requireNonNull(o);
356 Long64Vector v = (Long64Vector)o;
357 return (Long64Vector) VectorIntrinsics.binaryOp(
358 VECTOR_OP_MIN, Long64Vector.class, long.class, LENGTH,
359 this, v,
360 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long) ((a < b) ? a : b)));
361 }
362
363 @Override
364 @ForceInline
365 public Long64Vector max(Vector<Long,Shapes.S64Bit> o) {
366 Objects.requireNonNull(o);
367 Long64Vector v = (Long64Vector)o;
368 return (Long64Vector) VectorIntrinsics.binaryOp(
369 VECTOR_OP_MAX, Long64Vector.class, long.class, LENGTH,
370 this, v,
371 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long) ((a > b) ? a : b)));
372 }
373
374
375
376 @Override
377 @ForceInline
378 public Long64Vector and(Vector<Long,Shapes.S64Bit> o) {
379 Objects.requireNonNull(o);
380 Long64Vector v = (Long64Vector)o;
381 return (Long64Vector) VectorIntrinsics.binaryOp(
382 VECTOR_OP_AND, Long64Vector.class, long.class, LENGTH,
383 this, v,
384 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a & b)));
385 }
386
387 @Override
388 @ForceInline
389 public Long64Vector or(Vector<Long,Shapes.S64Bit> o) {
390 Objects.requireNonNull(o);
391 Long64Vector v = (Long64Vector)o;
392 return (Long64Vector) VectorIntrinsics.binaryOp(
393 VECTOR_OP_OR, Long64Vector.class, long.class, LENGTH,
394 this, v,
395 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a | b)));
396 }
397
398 @Override
399 @ForceInline
400 public Long64Vector xor(Vector<Long,Shapes.S64Bit> o) {
401 Objects.requireNonNull(o);
402 Long64Vector v = (Long64Vector)o;
403 return (Long64Vector) VectorIntrinsics.binaryOp(
404 VECTOR_OP_XOR, Long64Vector.class, long.class, LENGTH,
405 this, v,
406 (v1, v2) -> ((Long64Vector)v1).bOp(v2, (i, a, b) -> (long)(a ^ b)));
407 }
408
409 @Override
410 @ForceInline
411 public Long64Vector and(Vector<Long,Shapes.S64Bit> v, Mask<Long, Shapes.S64Bit> m) {
412 return blend(and(v), m);
413 }
414
415 @Override
416 @ForceInline
417 public Long64Vector or(Vector<Long,Shapes.S64Bit> v, Mask<Long, Shapes.S64Bit> m) {
418 return blend(or(v), m);
419 }
420
421 @Override
422 @ForceInline
423 public Long64Vector xor(Vector<Long,Shapes.S64Bit> v, Mask<Long, Shapes.S64Bit> m) {
424 return blend(xor(v), m);
425 }
426
427 @Override
428 @ForceInline
429 public Long64Vector shiftL(int s) {
430 return (Long64Vector) VectorIntrinsics.broadcastInt(
431 VECTOR_OP_LSHIFT, Long64Vector.class, long.class, LENGTH,
432 this, s,
433 (v, i) -> v.uOp((__, a) -> (long) (a << i)));
434 }
435
436 @Override
437 @ForceInline
438 public Long64Vector shiftR(int s) {
439 return (Long64Vector) VectorIntrinsics.broadcastInt(
440 VECTOR_OP_URSHIFT, Long64Vector.class, long.class, LENGTH,
441 this, s,
442 (v, i) -> v.uOp((__, a) -> (long) (a >>> i)));
443 }
444
445 @Override
446 @ForceInline
447 public Long64Vector aShiftR(int s) {
448 return (Long64Vector) VectorIntrinsics.broadcastInt(
449 VECTOR_OP_RSHIFT, Long64Vector.class, long.class, LENGTH,
450 this, s,
451 (v, i) -> v.uOp((__, a) -> (long) (a >> i)));
452 }
453
454 @Override
455 @ForceInline
456 public Long64Vector shiftL(Vector<Long,Shapes.S64Bit> s) {
457 Long64Vector v = (Long64Vector)s;
458 return (Long64Vector) VectorIntrinsics.binaryOp(
459 VECTOR_OP_LSHIFT, Long64Vector.class, long.class, LENGTH,
460 this, v,
461 (v1, v2) -> ((Long64Vector)v1).bOp(v2,(i,a, b) -> (long) (a << b)));
462 }
463
464 @Override
465 @ForceInline
466 public Long64Vector shiftR(Vector<Long,Shapes.S64Bit> s) {
467 Long64Vector v = (Long64Vector)s;
468 return (Long64Vector) VectorIntrinsics.binaryOp(
469 VECTOR_OP_URSHIFT, Long64Vector.class, long.class, LENGTH,
470 this, v,
471 (v1, v2) -> ((Long64Vector)v1).bOp(v2,(i,a, b) -> (long) (a >>> b)));
472 }
473
474 @Override
475 @ForceInline
476 public Long64Vector ashiftR(Vector<Long,Shapes.S64Bit> s) {
477 Long64Vector v = (Long64Vector)s;
478 return (Long64Vector) VectorIntrinsics.binaryOp(
479 VECTOR_OP_RSHIFT, Long64Vector.class, long.class, LENGTH,
480 this, v,
481 (v1, v2) -> ((Long64Vector)v1).bOp(v2,(i,a, b) -> (long) (a >> b)));
482 }
483 // Ternary operations
484
485
486 // Type specific horizontal reductions
487
488 @Override
489 @ForceInline
490 public long addAll() {
491 return (long) VectorIntrinsics.reductionCoerced(
492 VECTOR_OP_ADD, Long64Vector.class, long.class, LENGTH,
493 this,
494 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a + b)));
495 }
496
497 @Override
498 @ForceInline
499 public long andAll() {
500 return (long) VectorIntrinsics.reductionCoerced(
501 VECTOR_OP_AND, Long64Vector.class, long.class, LENGTH,
502 this,
503 v -> (long) v.rOp((long) -1, (i, a, b) -> (long) (a & b)));
504 }
505
506 @Override
507 @ForceInline
508 public long mulAll() {
509 return (long) VectorIntrinsics.reductionCoerced(
510 VECTOR_OP_MUL, Long64Vector.class, long.class, LENGTH,
511 this,
512 v -> (long) v.rOp((long) 1, (i, a, b) -> (long) (a * b)));
513 }
514
515 @Override
516 @ForceInline
517 public long orAll() {
518 return (long) VectorIntrinsics.reductionCoerced(
519 VECTOR_OP_OR, Long64Vector.class, long.class, LENGTH,
520 this,
521 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a | b)));
522 }
523
524 @Override
525 @ForceInline
526 public long xorAll() {
527 return (long) VectorIntrinsics.reductionCoerced(
528 VECTOR_OP_XOR, Long64Vector.class, long.class, LENGTH,
529 this,
530 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a ^ b)));
531 }
532
533 @Override
534 @ForceInline
535 public long subAll() {
536 return (long) VectorIntrinsics.reductionCoerced(
537 VECTOR_OP_SUB, Long64Vector.class, long.class, LENGTH,
538 this,
539 v -> (long) v.rOp((long) 0, (i, a, b) -> (long) (a - b)));
540 }
541
542 // Memory operations
543
544 @Override
545 @ForceInline
546 public void intoArray(long[] a, int ix) {
547 Objects.requireNonNull(a);
548 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
549 VectorIntrinsics.store(Long64Vector.class, long.class, LENGTH,
550 a, ix, this,
551 (arr, idx, v) -> v.forEach((i, a_) -> ((long[])arr)[idx + i] = a_));
552 }
553
554 @Override
555 @ForceInline
556 public void intoArray(long[] a, int ax, Mask<Long, Shapes.S64Bit> m) {
557 // TODO: use better default impl: forEach(m, (i, a_) -> a[ax + i] = a_);
558 Long64Vector oldVal = SPECIES.fromArray(a, ax);
559 Long64Vector newVal = oldVal.blend(this, m);
560 newVal.intoArray(a, ax);
561 }
562
563 //
564
565 @Override
566 public String toString() {
567 return Arrays.toString(getElements());
568 }
569
570 @Override
571 public boolean equals(Object o) {
572 if (this == o) return true;
573 if (o == null || this.getClass() != o.getClass()) return false;
574
575 Long64Vector that = (Long64Vector) o;
576 return Arrays.equals(this.getElements(), that.getElements());
577 }
578
579 @Override
580 public int hashCode() {
581 return Arrays.hashCode(vec);
582 }
583
584 // Binary test
585
586 @Override
587 Long64Mask bTest(Vector<Long, Shapes.S64Bit> o, FBinTest f) {
588 long[] vec1 = getElements();
589 long[] vec2 = ((Long64Vector)o).getElements();
590 boolean[] bits = new boolean[length()];
591 for (int i = 0; i < length(); i++){
592 bits[i] = f.apply(i, vec1[i], vec2[i]);
593 }
594 return new Long64Mask(bits);
595 }
596
597 // Comparisons
598
599 @Override
600 @ForceInline
601 public Long64Mask equal(Vector<Long, Shapes.S64Bit> o) {
602 Objects.requireNonNull(o);
603 Long64Vector v = (Long64Vector)o;
604
605 return (Long64Mask) VectorIntrinsics.compare(
606 BT_eq, Long64Vector.class, Long64Mask.class, long.class, LENGTH,
607 this, v,
608 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a == b));
609 }
610
611 @Override
612 @ForceInline
613 public Long64Mask notEqual(Vector<Long, Shapes.S64Bit> o) {
614 Objects.requireNonNull(o);
615 Long64Vector v = (Long64Vector)o;
616
617 return (Long64Mask) VectorIntrinsics.compare(
618 BT_ne, Long64Vector.class, Long64Mask.class, long.class, LENGTH,
619 this, v,
620 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a != b));
621 }
622
623 @Override
624 @ForceInline
625 public Long64Mask lessThan(Vector<Long, Shapes.S64Bit> o) {
626 Objects.requireNonNull(o);
627 Long64Vector v = (Long64Vector)o;
628
629 return (Long64Mask) VectorIntrinsics.compare(
630 BT_lt, Long64Vector.class, Long64Mask.class, long.class, LENGTH,
631 this, v,
632 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a < b));
633 }
634
635 @Override
636 @ForceInline
637 public Long64Mask lessThanEq(Vector<Long, Shapes.S64Bit> o) {
638 Objects.requireNonNull(o);
639 Long64Vector v = (Long64Vector)o;
640
641 return (Long64Mask) VectorIntrinsics.compare(
642 BT_le, Long64Vector.class, Long64Mask.class, long.class, LENGTH,
643 this, v,
644 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a <= b));
645 }
646
647 @Override
648 @ForceInline
649 public Long64Mask greaterThan(Vector<Long, Shapes.S64Bit> o) {
650 Objects.requireNonNull(o);
651 Long64Vector v = (Long64Vector)o;
652
653 return (Long64Mask) VectorIntrinsics.compare(
654 BT_gt, Long64Vector.class, Long64Mask.class, long.class, LENGTH,
655 this, v,
656 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a > b));
657 }
658
659 @Override
660 @ForceInline
661 public Long64Mask greaterThanEq(Vector<Long, Shapes.S64Bit> o) {
662 Objects.requireNonNull(o);
663 Long64Vector v = (Long64Vector)o;
664
665 return (Long64Mask) VectorIntrinsics.compare(
666 BT_ge, Long64Vector.class, Long64Mask.class, long.class, LENGTH,
667 this, v,
668 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a >= b));
669 }
670
671 // Foreach
672
673 @Override
674 void forEach(FUnCon f) {
675 long[] vec = getElements();
676 for (int i = 0; i < length(); i++) {
677 f.apply(i, vec[i]);
678 }
679 }
680
681 @Override
682 void forEach(Mask<Long, Shapes.S64Bit> o, FUnCon f) {
683 boolean[] mbits = ((Long64Mask)o).getBits();
684 forEach((i, a) -> {
685 if (mbits[i]) { f.apply(i, a); }
686 });
687 }
688
689
690 Double64Vector toFP() {
691 long[] vec = getElements();
692 double[] res = new double[this.species().length()];
693 for(int i = 0; i < this.species().length(); i++){
694 res[i] = Double.longBitsToDouble(vec[i]);
695 }
696 return new Double64Vector(res);
697 }
698
699 @Override
700 public Long64Vector rotateEL(int j) {
701 long[] vec = getElements();
702 long[] res = new long[length()];
703 for (int i = 0; i < length(); i++){
704 res[(j + i) % length()] = vec[i];
705 }
706 return new Long64Vector(res);
707 }
708
709 @Override
710 public Long64Vector rotateER(int j) {
711 long[] vec = getElements();
712 long[] res = new long[length()];
713 for (int i = 0; i < length(); i++){
714 int z = i - j;
715 if(j < 0) {
716 res[length() + z] = vec[i];
717 } else {
718 res[z] = vec[i];
719 }
720 }
721 return new Long64Vector(res);
722 }
723
724 @Override
725 public Long64Vector shiftEL(int j) {
726 long[] vec = getElements();
727 long[] res = new long[length()];
728 for (int i = 0; i < length() - j; i++) {
729 res[i] = vec[i + j];
730 }
731 return new Long64Vector(res);
732 }
733
734 @Override
735 public Long64Vector shiftER(int j) {
736 long[] vec = getElements();
737 long[] res = new long[length()];
738 for (int i = 0; i < length() - j; i++){
739 res[i + j] = vec[i];
740 }
741 return new Long64Vector(res);
742 }
743
744 @Override
745 public Long64Vector shuffle(Vector<Long, Shapes.S64Bit> o, Shuffle<Long, Shapes.S64Bit> s) {
746 Long64Vector v = (Long64Vector) o;
747 return uOp((i, a) -> {
748 long[] vec = this.getElements();
749 int e = s.getElement(i);
750 if(e >= 0 && e < length()) {
751 //from this
752 return vec[e];
753 } else if(e < length() * 2) {
754 //from o
755 return v.getElements()[e - length()];
756 } else {
757 throw new ArrayIndexOutOfBoundsException("Bad reordering for shuffle");
758 }
759 });
760 }
761
762 @Override
763 public Long64Vector swizzle(Shuffle<Long, Shapes.S64Bit> s) {
764 return uOp((i, a) -> {
765 long[] vec = this.getElements();
766 int e = s.getElement(i);
767 if(e >= 0 && e < length()) {
768 return vec[e];
769 } else {
770 throw new ArrayIndexOutOfBoundsException("Bad reordering for shuffle");
771 }
772 });
773 }
774
775 @Override
776 @ForceInline
777 public Long64Vector blend(Vector<Long, Shapes.S64Bit> o1, Mask<Long, Shapes.S64Bit> o2) {
778 Objects.requireNonNull(o1);
779 Objects.requireNonNull(o2);
780 Long64Vector v = (Long64Vector)o1;
781 Long64Mask m = (Long64Mask)o2;
782
783 return (Long64Vector) VectorIntrinsics.blend(
784 Long64Vector.class, Long64Mask.class, long.class, LENGTH,
785 this, v, m,
786 (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.getElement(i) ? b : a));
787 }
788
789 // Accessors
790
791 @Override
792 public long get(int i) {
793 long[] vec = getElements();
794 return vec[i];
795 }
796
797 @Override
798 public Long64Vector with(int i, long e) {
799 long[] res = vec.clone();
800 res[i] = e;
801 return new Long64Vector(res);
802 }
803
804 // Mask
805
806 static final class Long64Mask extends AbstractMask<Long, Shapes.S64Bit> {
807 static final Long64Mask TRUE_MASK = new Long64Mask(true);
808 static final Long64Mask FALSE_MASK = new Long64Mask(false);
809
810 // FIXME: was temporarily put here to simplify rematerialization support in the JVM
811 private final boolean[] bits; // Don't access directly, use getBits() instead.
812
813 public Long64Mask(boolean[] bits) {
814 this(bits, 0);
815 }
816
817 public Long64Mask(boolean[] bits, int i) {
818 this.bits = Arrays.copyOfRange(bits, i, i + species().length());
819 }
820
821 public Long64Mask(boolean val) {
822 boolean[] bits = new boolean[species().length()];
823 Arrays.fill(bits, val);
824 this.bits = bits;
825 }
826
827 boolean[] getBits() {
828 return VectorIntrinsics.maybeRebox(this).bits;
829 }
830
831 @Override
832 Long64Mask uOp(MUnOp f) {
833 boolean[] res = new boolean[species().length()];
834 boolean[] bits = getBits();
835 for (int i = 0; i < species().length(); i++) {
836 res[i] = f.apply(i, bits[i]);
837 }
838 return new Long64Mask(res);
839 }
840
841 @Override
842 Long64Mask bOp(Mask<Long, Shapes.S64Bit> o, MBinOp f) {
843 boolean[] res = new boolean[species().length()];
844 boolean[] bits = getBits();
845 boolean[] mbits = ((Long64Mask)o).getBits();
846 for (int i = 0; i < species().length(); i++) {
847 res[i] = f.apply(i, bits[i], mbits[i]);
848 }
849 return new Long64Mask(res);
850 }
851
852 @Override
853 public Long64Species species() {
854 return SPECIES;
855 }
856
857 @Override
858 public Long64Vector toVector() {
859 long[] res = new long[species().length()];
860 boolean[] bits = getBits();
861 for (int i = 0; i < species().length(); i++) {
862 res[i] = (long) (bits[i] ? -1 : 0);
863 }
864 return new Long64Vector(res);
865 }
866
867 @Override
868 @ForceInline
869 @SuppressWarnings("unchecked")
870 public <Z> Mask<Z, Shapes.S64Bit> rebracket(Species<Z, Shapes.S64Bit> species) {
871 Objects.requireNonNull(species);
872 // TODO: check proper element type
873 return VectorIntrinsics.reinterpret(
874 Long64Mask.class, long.class, LENGTH,
875 species.elementType(), species.length(), this,
876 (m, t) -> m.reshape(species)
877 );
878 }
879
880 // Unary operations
881
882 //Mask<E, S> not();
883
884 // Binary operations
885
886 @Override
887 @ForceInline
888 public Long64Mask and(Mask<Long,Shapes.S64Bit> o) {
889 Objects.requireNonNull(o);
890 Long64Mask m = (Long64Mask)o;
891 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Long64Mask.class, long.class, LENGTH,
892 this, m,
893 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b));
894 }
895
896 @Override
897 @ForceInline
898 public Long64Mask or(Mask<Long,Shapes.S64Bit> o) {
899 Objects.requireNonNull(o);
900 Long64Mask m = (Long64Mask)o;
901 return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Long64Mask.class, long.class, LENGTH,
902 this, m,
903 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b));
904 }
905
906 // Reductions
907
908 @Override
909 @ForceInline
910 public boolean anyTrue() {
911 return VectorIntrinsics.test(COND_notZero, Long64Mask.class, long.class, LENGTH,
912 this, this,
913 (m1, m2) -> super.anyTrue());
914 }
915
916 @Override
917 @ForceInline
918 public boolean allTrue() {
919 return VectorIntrinsics.test(COND_carrySet, Long64Mask.class, long.class, LENGTH,
920 this, species().maskAllTrue(),
921 (m1, m2) -> super.allTrue());
922 }
923 }
924
925 // Shuffle
926
927 static final class Long64Shuffle extends AbstractShuffle<Long, Shapes.S64Bit> {
928 static final IntVector.IntSpecies<Shapes.S64Bit> INT_SPECIES = IntVector.speciesInstance(Shapes.S_64_BIT);
929
930 public Long64Shuffle(int[] reorder) {
931 super(reorder);
932 }
933
934 public Long64Shuffle(int[] reorder, int i) {
935 super(reorder, i);
936 }
937
938 @Override
939 public Long64Species species() {
940 return SPECIES;
941 }
942
943 @Override
944 public IntVector.IntSpecies<Shapes.S64Bit> intSpecies() {
945 return INT_SPECIES;
946 }
947 }
948
949 // Species
950
951 @Override
952 public Long64Species species() {
953 return SPECIES;
954 }
955
956 static final class Long64Species extends LongSpecies<Shapes.S64Bit> {
957 static final int BIT_SIZE = Shapes.S_64_BIT.bitSize();
958
959 static final int LENGTH = BIT_SIZE / Long.SIZE;
960
961 @Override
962 public String toString() {
963 StringBuilder sb = new StringBuilder("Shape[");
964 sb.append(bitSize()).append(" bits, ");
965 sb.append(length()).append(" ").append(long.class.getSimpleName()).append("s x ");
966 sb.append(elementSize()).append(" bits");
967 sb.append("]");
968 return sb.toString();
969 }
970
971 @Override
972 @ForceInline
973 public int bitSize() {
974 return BIT_SIZE;
975 }
976
977 @Override
978 @ForceInline
979 public int length() {
980 return LENGTH;
981 }
982
983 @Override
984 @ForceInline
985 public Class<Long> elementType() {
986 return long.class;
987 }
988
989 @Override
990 @ForceInline
991 public int elementSize() {
992 return Long.SIZE;
993 }
994
995 @Override
996 @ForceInline
997 public Shapes.S64Bit shape() {
998 return Shapes.S_64_BIT;
999 }
1000
1001 @Override
1002 Long64Vector op(FOp f) {
1003 long[] res = new long[length()];
1004 for (int i = 0; i < length(); i++) {
1005 res[i] = f.apply(i);
1006 }
1007 return new Long64Vector(res);
1008 }
1009
1010 @Override
1011 Long64Vector op(Mask<Long, Shapes.S64Bit> o, FOp f) {
1012 long[] res = new long[length()];
1013 boolean[] mbits = ((Long64Mask)o).getBits();
1014 for (int i = 0; i < length(); i++) {
1015 if (mbits[i]) {
1016 res[i] = f.apply(i);
1017 }
1018 }
1019 return new Long64Vector(res);
1020 }
1021
1022 // Factories
1023
1024 @Override
1025 public Long64Mask maskFromValues(boolean... bits) {
1026 return new Long64Mask(bits);
1027 }
1028
1029 @Override
1030 public Long64Mask maskFromArray(boolean[] bits, int i) {
1031 return new Long64Mask(bits, i);
1032 }
1033
1034 @Override
1035 public Long64Shuffle shuffleFromValues(int... ixs) {
1036 return new Long64Shuffle(ixs);
1037 }
1038
1039 @Override
1040 public Long64Shuffle shuffleFromArray(int[] ixs, int i) {
1041 return new Long64Shuffle(ixs, i);
1042 }
1043
1044 @Override
1045 public Long64Shuffle shuffleFromVector(Vector<Integer, Shapes.S64Bit> v) {
1046 int[] a = ((IntVector<Shapes.S64Bit>) v).toArray();
1047 return new Long64Shuffle(a, 0);
1048 }
1049
1050 @Override
1051 @ForceInline
1052 public Long64Vector zero() {
1053 return VectorIntrinsics.broadcastCoerced(Long64Vector.class, long.class, LENGTH,
1054 0,
1055 (z -> ZERO));
1056 }
1057
1058 @Override
1059 @ForceInline
1060 public Long64Vector broadcast(long e) {
1061 return VectorIntrinsics.broadcastCoerced(
1062 Long64Vector.class, long.class, LENGTH,
1063 e,
1064 ((long bits) -> SPECIES.op(i -> (long)bits)));
1065 }
1066
1067 @Override
1068 @ForceInline
1069 public Long64Mask maskAllTrue() {
1070 return VectorIntrinsics.broadcastCoerced(Long64Mask.class, long.class, LENGTH,
1071 (long)-1,
1072 (z -> Long64Mask.TRUE_MASK));
1073 }
1074
1075 @Override
1076 @ForceInline
1077 public Long64Mask maskAllFalse() {
1078 return VectorIntrinsics.broadcastCoerced(Long64Mask.class, long.class, LENGTH,
1079 0,
1080 (z -> Long64Mask.FALSE_MASK));
1081 }
1082
1083 @Override
1084 @ForceInline
1085 public Long64Vector fromArray(long[] a, int ix) {
1086 Objects.requireNonNull(a);
1087 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
1088 return (Long64Vector) VectorIntrinsics.load(Long64Vector.class, long.class, LENGTH,
1089 a, ix,
1090 (arr, idx) -> super.fromArray((long[]) arr, idx));
1091 }
1092
1093 @Override
1094 @ForceInline
1095 public Long64Vector fromArray(long[] a, int ax, Mask<Long, Shapes.S64Bit> m) {
1096 return zero().blend(fromArray(a, ax), m); // TODO: use better default impl: op(m, i -> a[ax + i]);
1097 }
1098
1099 @ForceInline
1100 @SuppressWarnings("unchecked")
1101 private <S extends Shape> Long64Vector castFromByte(ByteVector<S> o) {
1102 if (o.bitSize() == 64) {
1103 Byte64Vector so = (Byte64Vector)o;
1104 return VectorIntrinsics.cast(
1105 Byte64Vector.class, byte.class, so.length(),
1106 long.class, LENGTH, so,
1107 (v, t) -> (Long64Vector)super.cast(v)
1108 );
1109 } else if (o.bitSize() == 128) {
1110 Byte128Vector so = (Byte128Vector)o;
1111 return VectorIntrinsics.cast(
1112 Byte128Vector.class, byte.class, so.length(),
1113 long.class, LENGTH, so,
1114 (v, t) -> (Long64Vector)super.cast(v)
1115 );
1116 } else if (o.bitSize() == 256) {
1117 Byte256Vector so = (Byte256Vector)o;
1118 return VectorIntrinsics.cast(
1119 Byte256Vector.class, byte.class, so.length(),
1120 long.class, LENGTH, so,
1121 (v, t) -> (Long64Vector)super.cast(v)
1122 );
1123 } else if (o.bitSize() == 512) {
1124 Byte512Vector so = (Byte512Vector)o;
1125 return VectorIntrinsics.cast(
1126 Byte512Vector.class, byte.class, so.length(),
1127 long.class, LENGTH, so,
1128 (v, t) -> (Long64Vector)super.cast(v)
1129 );
1130 } else {
1131 throw new InternalError("Unimplemented size");
1132 }
1133 }
1134
1135 @ForceInline
1136 @SuppressWarnings("unchecked")
1137 private <S extends Shape> Long64Vector castFromShort(ShortVector<S> o) {
1138 if (o.bitSize() == 64) {
1139 Short64Vector so = (Short64Vector)o;
1140 return VectorIntrinsics.cast(
1141 Short64Vector.class, short.class, so.length(),
1142 long.class, LENGTH, so,
1143 (v, t) -> (Long64Vector)super.cast(v)
1144 );
1145 } else if (o.bitSize() == 128) {
1146 Short128Vector so = (Short128Vector)o;
1147 return VectorIntrinsics.cast(
1148 Short128Vector.class, short.class, so.length(),
1149 long.class, LENGTH, so,
1150 (v, t) -> (Long64Vector)super.cast(v)
1151 );
1152 } else if (o.bitSize() == 256) {
1153 Short256Vector so = (Short256Vector)o;
1154 return VectorIntrinsics.cast(
1155 Short256Vector.class, short.class, so.length(),
1156 long.class, LENGTH, so,
1157 (v, t) -> (Long64Vector)super.cast(v)
1158 );
1159 } else if (o.bitSize() == 512) {
1160 Short512Vector so = (Short512Vector)o;
1161 return VectorIntrinsics.cast(
1162 Short512Vector.class, short.class, so.length(),
1163 long.class, LENGTH, so,
1164 (v, t) -> (Long64Vector)super.cast(v)
1165 );
1166 } else {
1167 throw new InternalError("Unimplemented size");
1168 }
1169 }
1170
1171 @ForceInline
1172 @SuppressWarnings("unchecked")
1173 private <S extends Shape> Long64Vector castFromInt(IntVector<S> o) {
1174 if (o.bitSize() == 64) {
1175 Int64Vector so = (Int64Vector)o;
1176 return VectorIntrinsics.cast(
1177 Int64Vector.class, int.class, so.length(),
1178 long.class, LENGTH, so,
1179 (v, t) -> (Long64Vector)super.cast(v)
1180 );
1181 } else if (o.bitSize() == 128) {
1182 Int128Vector so = (Int128Vector)o;
1183 return VectorIntrinsics.cast(
1184 Int128Vector.class, int.class, so.length(),
1185 long.class, LENGTH, so,
1186 (v, t) -> (Long64Vector)super.cast(v)
1187 );
1188 } else if (o.bitSize() == 256) {
1189 Int256Vector so = (Int256Vector)o;
1190 return VectorIntrinsics.cast(
1191 Int256Vector.class, int.class, so.length(),
1192 long.class, LENGTH, so,
1193 (v, t) -> (Long64Vector)super.cast(v)
1194 );
1195 } else if (o.bitSize() == 512) {
1196 Int512Vector so = (Int512Vector)o;
1197 return VectorIntrinsics.cast(
1198 Int512Vector.class, int.class, so.length(),
1199 long.class, LENGTH, so,
1200 (v, t) -> (Long64Vector)super.cast(v)
1201 );
1202 } else {
1203 throw new InternalError("Unimplemented size");
1204 }
1205 }
1206
1207 @ForceInline
1208 @SuppressWarnings("unchecked")
1209 private <S extends Shape> Long64Vector castFromLong(LongVector<S> o) {
1210 if (o.bitSize() == 64) {
1211 Long64Vector so = (Long64Vector)o;
1212 return VectorIntrinsics.cast(
1213 Long64Vector.class, long.class, so.length(),
1214 long.class, LENGTH, so,
1215 (v, t) -> (Long64Vector)super.cast(v)
1216 );
1217 } else if (o.bitSize() == 128) {
1218 Long128Vector so = (Long128Vector)o;
1219 return VectorIntrinsics.cast(
1220 Long128Vector.class, long.class, so.length(),
1221 long.class, LENGTH, so,
1222 (v, t) -> (Long64Vector)super.cast(v)
1223 );
1224 } else if (o.bitSize() == 256) {
1225 Long256Vector so = (Long256Vector)o;
1226 return VectorIntrinsics.cast(
1227 Long256Vector.class, long.class, so.length(),
1228 long.class, LENGTH, so,
1229 (v, t) -> (Long64Vector)super.cast(v)
1230 );
1231 } else if (o.bitSize() == 512) {
1232 Long512Vector so = (Long512Vector)o;
1233 return VectorIntrinsics.cast(
1234 Long512Vector.class, long.class, so.length(),
1235 long.class, LENGTH, so,
1236 (v, t) -> (Long64Vector)super.cast(v)
1237 );
1238 } else {
1239 throw new InternalError("Unimplemented size");
1240 }
1241 }
1242
1243 @ForceInline
1244 @SuppressWarnings("unchecked")
1245 private <S extends Shape> Long64Vector castFromFloat(FloatVector<S> o) {
1246 if (o.bitSize() == 64) {
1247 Float64Vector so = (Float64Vector)o;
1248 return VectorIntrinsics.cast(
1249 Float64Vector.class, float.class, so.length(),
1250 long.class, LENGTH, so,
1251 (v, t) -> (Long64Vector)super.cast(v)
1252 );
1253 } else if (o.bitSize() == 128) {
1254 Float128Vector so = (Float128Vector)o;
1255 return VectorIntrinsics.cast(
1256 Float128Vector.class, float.class, so.length(),
1257 long.class, LENGTH, so,
1258 (v, t) -> (Long64Vector)super.cast(v)
1259 );
1260 } else if (o.bitSize() == 256) {
1261 Float256Vector so = (Float256Vector)o;
1262 return VectorIntrinsics.cast(
1263 Float256Vector.class, float.class, so.length(),
1264 long.class, LENGTH, so,
1265 (v, t) -> (Long64Vector)super.cast(v)
1266 );
1267 } else if (o.bitSize() == 512) {
1268 Float512Vector so = (Float512Vector)o;
1269 return VectorIntrinsics.cast(
1270 Float512Vector.class, float.class, so.length(),
1271 long.class, LENGTH, so,
1272 (v, t) -> (Long64Vector)super.cast(v)
1273 );
1274 } else {
1275 throw new InternalError("Unimplemented size");
1276 }
1277 }
1278
1279 @ForceInline
1280 @SuppressWarnings("unchecked")
1281 private <S extends Shape> Long64Vector castFromDouble(DoubleVector<S> o) {
1282 if (o.bitSize() == 64) {
1283 Double64Vector so = (Double64Vector)o;
1284 return VectorIntrinsics.cast(
1285 Double64Vector.class, double.class, so.length(),
1286 long.class, LENGTH, so,
1287 (v, t) -> (Long64Vector)super.cast(v)
1288 );
1289 } else if (o.bitSize() == 128) {
1290 Double128Vector so = (Double128Vector)o;
1291 return VectorIntrinsics.cast(
1292 Double128Vector.class, double.class, so.length(),
1293 long.class, LENGTH, so,
1294 (v, t) -> (Long64Vector)super.cast(v)
1295 );
1296 } else if (o.bitSize() == 256) {
1297 Double256Vector so = (Double256Vector)o;
1298 return VectorIntrinsics.cast(
1299 Double256Vector.class, double.class, so.length(),
1300 long.class, LENGTH, so,
1301 (v, t) -> (Long64Vector)super.cast(v)
1302 );
1303 } else if (o.bitSize() == 512) {
1304 Double512Vector so = (Double512Vector)o;
1305 return VectorIntrinsics.cast(
1306 Double512Vector.class, double.class, so.length(),
1307 long.class, LENGTH, so,
1308 (v, t) -> (Long64Vector)super.cast(v)
1309 );
1310 } else {
1311 throw new InternalError("Unimplemented size");
1312 }
1313 }
1314
1315 @Override
1316 @ForceInline
1317 @SuppressWarnings("unchecked")
1318 public <E, S extends Shape> Long64Vector cast(Vector<E, S> o) {
1319 Objects.requireNonNull(o);
1320 if (o.elementType() == byte.class) {
1321 ByteVector<S> so = (ByteVector<S>)o;
1322 return castFromByte(so);
1323 } else if (o.elementType() == short.class) {
1324 ShortVector<S> so = (ShortVector<S>)o;
1325 return castFromShort(so);
1326 } else if (o.elementType() == int.class) {
1327 IntVector<S> so = (IntVector<S>)o;
1328 return castFromInt(so);
1329 } else if (o.elementType() == long.class) {
1330 LongVector<S> so = (LongVector<S>)o;
1331 return castFromLong(so);
1332 } else if (o.elementType() == float.class) {
1333 FloatVector<S> so = (FloatVector<S>)o;
1334 return castFromFloat(so);
1335 } else if (o.elementType() == double.class) {
1336 DoubleVector<S> so = (DoubleVector<S>)o;
1337 return castFromDouble(so);
1338 } else {
1339 throw new InternalError("Unimplemented type");
1340 }
1341 }
1342
1343 @Override
1344 @ForceInline
1345 @SuppressWarnings("unchecked")
1346 public <F> Long64Vector rebracket(Vector<F, Shapes.S64Bit> o) {
1347 Objects.requireNonNull(o);
1348 if (o.elementType() == byte.class) {
1349 Byte64Vector so = (Byte64Vector)o;
1350 return VectorIntrinsics.reinterpret(
1351 Byte64Vector.class, byte.class, so.length(),
1352 long.class, LENGTH, so,
1353 (v, t) -> (Long64Vector)reshape(v)
1354 );
1355 } else if (o.elementType() == short.class) {
1356 Short64Vector so = (Short64Vector)o;
1357 return VectorIntrinsics.reinterpret(
1358 Short64Vector.class, short.class, so.length(),
1359 long.class, LENGTH, so,
1360 (v, t) -> (Long64Vector)reshape(v)
1361 );
1362 } else if (o.elementType() == int.class) {
1363 Int64Vector so = (Int64Vector)o;
1364 return VectorIntrinsics.reinterpret(
1365 Int64Vector.class, int.class, so.length(),
1366 long.class, LENGTH, so,
1367 (v, t) -> (Long64Vector)reshape(v)
1368 );
1369 } else if (o.elementType() == long.class) {
1370 Long64Vector so = (Long64Vector)o;
1371 return VectorIntrinsics.reinterpret(
1372 Long64Vector.class, long.class, so.length(),
1373 long.class, LENGTH, so,
1374 (v, t) -> (Long64Vector)reshape(v)
1375 );
1376 } else if (o.elementType() == float.class) {
1377 Float64Vector so = (Float64Vector)o;
1378 return VectorIntrinsics.reinterpret(
1379 Float64Vector.class, float.class, so.length(),
1380 long.class, LENGTH, so,
1381 (v, t) -> (Long64Vector)reshape(v)
1382 );
1383 } else if (o.elementType() == double.class) {
1384 Double64Vector so = (Double64Vector)o;
1385 return VectorIntrinsics.reinterpret(
1386 Double64Vector.class, double.class, so.length(),
1387 long.class, LENGTH, so,
1388 (v, t) -> (Long64Vector)reshape(v)
1389 );
1390 } else {
1391 throw new InternalError("Unimplemented type");
1392 }
1393 }
1394
1395 @Override
1396 @ForceInline
1397 @SuppressWarnings("unchecked")
1398 public <T extends Shape> Long64Vector resize(Vector<Long, T> o) {
1399 Objects.requireNonNull(o);
1400 if (o.bitSize() == 64) {
1401 Long64Vector so = (Long64Vector)o;
1402 return VectorIntrinsics.reinterpret(
1403 Long64Vector.class, long.class, so.length(),
1404 long.class, LENGTH, so,
1405 (v, t) -> (Long64Vector)reshape(v)
1406 );
1407 } else if (o.bitSize() == 128) {
1408 Long128Vector so = (Long128Vector)o;
1409 return VectorIntrinsics.reinterpret(
1410 Long128Vector.class, long.class, so.length(),
1411 long.class, LENGTH, so,
1412 (v, t) -> (Long64Vector)reshape(v)
1413 );
1414 } else if (o.bitSize() == 256) {
1415 Long256Vector so = (Long256Vector)o;
1416 return VectorIntrinsics.reinterpret(
1417 Long256Vector.class, long.class, so.length(),
1418 long.class, LENGTH, so,
1419 (v, t) -> (Long64Vector)reshape(v)
1420 );
1421 } else if (o.bitSize() == 512) {
1422 Long512Vector so = (Long512Vector)o;
1423 return VectorIntrinsics.reinterpret(
1424 Long512Vector.class, long.class, so.length(),
1425 long.class, LENGTH, so,
1426 (v, t) -> (Long64Vector)reshape(v)
1427 );
1428 } else {
1429 throw new InternalError("Unimplemented size");
1430 }
1431 }
1432 }
1433 }