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