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.DoubleBuffer;
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 Double512Vector extends DoubleVector {
41 static final Double512Species SPECIES = new Double512Species();
42
43 static final Double512Vector ZERO = new Double512Vector();
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 double[] vec; // Don't access directly, use getElements() instead.
55
56 private double[] getElements() {
57 return VectorIntrinsics.maybeRebox(this).vec;
58 }
59
60 Double512Vector() {
61 vec = new double[SPECIES.length()];
62 }
63
64 Double512Vector(double[] v) {
65 vec = v;
66 }
67
68 @Override
69 public int length() { return LENGTH; }
70
71 // Unary operator
72
73 @Override
74 Double512Vector uOp(FUnOp f) {
75 double[] vec = getElements();
76 double[] res = new double[length()];
77 for (int i = 0; i < length(); i++) {
78 res[i] = f.apply(i, vec[i]);
79 }
80 return new Double512Vector(res);
81 }
82
83 @Override
84 Double512Vector uOp(Mask<Double> o, FUnOp f) {
85 double[] vec = getElements();
86 double[] res = new double[length()];
87 boolean[] mbits = ((Double512Mask)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 Double512Vector(res);
92 }
93
94 // Binary operator
95
96 @Override
97 Double512Vector bOp(Vector<Double> o, FBinOp f) {
98 double[] res = new double[length()];
99 double[] vec1 = this.getElements();
100 double[] vec2 = ((Double512Vector)o).getElements();
101 for (int i = 0; i < length(); i++) {
102 res[i] = f.apply(i, vec1[i], vec2[i]);
103 }
104 return new Double512Vector(res);
105 }
106
107 @Override
108 Double512Vector bOp(Vector<Double> o1, Mask<Double> o2, FBinOp f) {
109 double[] res = new double[length()];
110 double[] vec1 = this.getElements();
111 double[] vec2 = ((Double512Vector)o1).getElements();
112 boolean[] mbits = ((Double512Mask)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 Double512Vector(res);
117 }
118
119 // Trinary operator
120
121 @Override
122 Double512Vector tOp(Vector<Double> o1, Vector<Double> o2, FTriOp f) {
123 double[] res = new double[length()];
124 double[] vec1 = this.getElements();
125 double[] vec2 = ((Double512Vector)o1).getElements();
126 double[] vec3 = ((Double512Vector)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 Double512Vector(res);
131 }
132
133 @Override
134 Double512Vector tOp(Vector<Double> o1, Vector<Double> o2, Mask<Double> o3, FTriOp f) {
135 double[] res = new double[length()];
136 double[] vec1 = getElements();
137 double[] vec2 = ((Double512Vector)o1).getElements();
138 double[] vec3 = ((Double512Vector)o2).getElements();
139 boolean[] mbits = ((Double512Mask)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 Double512Vector(res);
144 }
145
146 @Override
147 double rOp(double v, FBinOp f) {
148 double[] 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 Double512Vector.class,
164 double.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(double.class)) {
226 return (Vector<F>) reshape((Species<Double>)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 Double512Vector.class,
243 double.class, LENGTH,
244 Byte512Vector.class,
245 byte.class, Byte512Vector.LENGTH,
246 this, s,
247 (species, vector) -> vector.defaultReinterpret(species)
248 );
249 } else if (stype == short.class) {
250 return VectorIntrinsics.reinterpret(
251 Double512Vector.class,
252 double.class, LENGTH,
253 Short512Vector.class,
254 short.class, Short512Vector.LENGTH,
255 this, s,
256 (species, vector) -> vector.defaultReinterpret(species)
257 );
258 } else if (stype == int.class) {
259 return VectorIntrinsics.reinterpret(
260 Double512Vector.class,
261 double.class, LENGTH,
262 Int512Vector.class,
263 int.class, Int512Vector.LENGTH,
264 this, s,
265 (species, vector) -> vector.defaultReinterpret(species)
266 );
267 } else if (stype == long.class) {
268 return VectorIntrinsics.reinterpret(
269 Double512Vector.class,
270 double.class, LENGTH,
271 Long512Vector.class,
272 long.class, Long512Vector.LENGTH,
273 this, s,
274 (species, vector) -> vector.defaultReinterpret(species)
275 );
276 } else if (stype == float.class) {
277 return VectorIntrinsics.reinterpret(
278 Double512Vector.class,
279 double.class, LENGTH,
280 Float512Vector.class,
281 float.class, Float512Vector.LENGTH,
282 this, s,
283 (species, vector) -> vector.defaultReinterpret(species)
284 );
285 } else if (stype == double.class) {
286 return VectorIntrinsics.reinterpret(
287 Double512Vector.class,
288 double.class, LENGTH,
289 Double512Vector.class,
290 double.class, Double512Vector.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 DoubleVector reshape(Species<Double> s) {
302 Objects.requireNonNull(s);
303 if (s.bitSize() == 64 && (s instanceof Double64Vector.Double64Species)) {
304 Double64Vector.Double64Species ts = (Double64Vector.Double64Species)s;
305 return VectorIntrinsics.reinterpret(
306 Double512Vector.class,
307 double.class, LENGTH,
308 Double64Vector.class,
309 double.class, Double64Vector.LENGTH,
310 this, ts,
311 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
312 );
313 } else if (s.bitSize() == 128 && (s instanceof Double128Vector.Double128Species)) {
314 Double128Vector.Double128Species ts = (Double128Vector.Double128Species)s;
315 return VectorIntrinsics.reinterpret(
316 Double512Vector.class,
317 double.class, LENGTH,
318 Double128Vector.class,
319 double.class, Double128Vector.LENGTH,
320 this, ts,
321 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
322 );
323 } else if (s.bitSize() == 256 && (s instanceof Double256Vector.Double256Species)) {
324 Double256Vector.Double256Species ts = (Double256Vector.Double256Species)s;
325 return VectorIntrinsics.reinterpret(
326 Double512Vector.class,
327 double.class, LENGTH,
328 Double256Vector.class,
329 double.class, Double256Vector.LENGTH,
330 this, ts,
331 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
332 );
333 } else if (s.bitSize() == 512 && (s instanceof Double512Vector.Double512Species)) {
334 Double512Vector.Double512Species ts = (Double512Vector.Double512Species)s;
335 return VectorIntrinsics.reinterpret(
336 Double512Vector.class,
337 double.class, LENGTH,
338 Double512Vector.class,
339 double.class, Double512Vector.LENGTH,
340 this, ts,
341 (species, vector) -> (DoubleVector) vector.defaultReinterpret(species)
342 );
343 } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048)
344 && (s.bitSize() % 128 == 0) && (s instanceof DoubleMaxVector.DoubleMaxSpecies)) {
345 DoubleMaxVector.DoubleMaxSpecies ts = (DoubleMaxVector.DoubleMaxSpecies)s;
346 return VectorIntrinsics.reinterpret(
347 Double512Vector.class,
348 double.class, LENGTH,
349 DoubleMaxVector.class,
350 double.class, DoubleMaxVector.LENGTH,
351 this, ts,
352 (species, vector) -> (DoubleVector) 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 DoubleVector add(double o) {
364 return add(SPECIES.broadcast(o));
365 }
366
367 @Override
368 @ForceInline
369 public DoubleVector add(double o, Mask<Double> m) {
370 return add(SPECIES.broadcast(o), m);
371 }
372
373 @Override
374 @ForceInline
375 public DoubleVector sub(double o) {
376 return sub(SPECIES.broadcast(o));
377 }
378
379 @Override
380 @ForceInline
381 public DoubleVector sub(double o, Mask<Double> m) {
382 return sub(SPECIES.broadcast(o), m);
383 }
384
385 @Override
386 @ForceInline
387 public DoubleVector mul(double o) {
388 return mul(SPECIES.broadcast(o));
389 }
390
391 @Override
392 @ForceInline
393 public DoubleVector mul(double o, Mask<Double> m) {
394 return mul(SPECIES.broadcast(o), m);
395 }
396
397 @Override
398 @ForceInline
399 public DoubleVector min(double o) {
400 return min(SPECIES.broadcast(o));
401 }
402
403 @Override
404 @ForceInline
405 public DoubleVector max(double o) {
406 return max(SPECIES.broadcast(o));
407 }
408
409 @Override
410 @ForceInline
411 public Mask<Double> equal(double o) {
412 return equal(SPECIES.broadcast(o));
413 }
414
415 @Override
416 @ForceInline
417 public Mask<Double> notEqual(double o) {
418 return notEqual(SPECIES.broadcast(o));
419 }
420
421 @Override
422 @ForceInline
423 public Mask<Double> lessThan(double o) {
424 return lessThan(SPECIES.broadcast(o));
425 }
426
427 @Override
428 @ForceInline
429 public Mask<Double> lessThanEq(double o) {
430 return lessThanEq(SPECIES.broadcast(o));
431 }
432
433 @Override
434 @ForceInline
435 public Mask<Double> greaterThan(double o) {
436 return greaterThan(SPECIES.broadcast(o));
437 }
438
439 @Override
440 @ForceInline
441 public Mask<Double> greaterThanEq(double o) {
442 return greaterThanEq(SPECIES.broadcast(o));
443 }
444
445 @Override
446 @ForceInline
447 public DoubleVector blend(double o, Mask<Double> m) {
448 return blend(SPECIES.broadcast(o), m);
449 }
450
451 @Override
452 @ForceInline
453 public DoubleVector div(double o) {
454 return div(SPECIES.broadcast(o));
455 }
456
457 @Override
458 @ForceInline
459 public DoubleVector div(double o, Mask<Double> m) {
460 return div(SPECIES.broadcast(o), m);
461 }
462
463 @Override
464 @ForceInline
465 public Double512Vector div(Vector<Double> v, Mask<Double> m) {
466 return blend(div(v), m);
467 }
468
469 @Override
470 @ForceInline
471 public DoubleVector atan2(double o) {
472 return atan2(SPECIES.broadcast(o));
473 }
474
475 @Override
476 @ForceInline
477 public DoubleVector atan2(double o, Mask<Double> m) {
478 return atan2(SPECIES.broadcast(o), m);
479 }
480
481 @Override
482 @ForceInline
483 public DoubleVector pow(double o) {
484 return pow(SPECIES.broadcast(o));
485 }
486
487 @Override
488 @ForceInline
489 public DoubleVector pow(double o, Mask<Double> m) {
490 return pow(SPECIES.broadcast(o), m);
491 }
492
493 @Override
494 @ForceInline
495 public DoubleVector fma(double o1, double o2) {
496 return fma(SPECIES.broadcast(o1), SPECIES.broadcast(o2));
497 }
498
499 @Override
500 @ForceInline
501 public DoubleVector fma(double o1, double o2, Mask<Double> m) {
502 return fma(SPECIES.broadcast(o1), SPECIES.broadcast(o2), m);
503 }
504
505 @Override
506 @ForceInline
507 public DoubleVector hypot(double o) {
508 return hypot(SPECIES.broadcast(o));
509 }
510
511 @Override
512 @ForceInline
513 public DoubleVector hypot(double o, Mask<Double> m) {
514 return hypot(SPECIES.broadcast(o), m);
515 }
516
517
518 // Unary operations
519
520 @ForceInline
521 @Override
522 public Double512Vector neg(Mask<Double> m) {
523 return blend(neg(), m);
524 }
525
526 @Override
527 @ForceInline
528 public Double512Vector abs() {
529 return VectorIntrinsics.unaryOp(
530 VECTOR_OP_ABS, Double512Vector.class, double.class, LENGTH,
531 this,
532 v1 -> v1.uOp((i, a) -> (double) Math.abs(a)));
533 }
534
535 @ForceInline
536 @Override
537 public Double512Vector abs(Mask<Double> m) {
538 return blend(abs(), m);
539 }
540
541 @Override
542 @ForceInline
543 public Double512Vector neg() {
544 return VectorIntrinsics.unaryOp(
545 VECTOR_OP_NEG, Double512Vector.class, double.class, LENGTH,
546 this,
547 v1 -> v1.uOp((i, a) -> (double) -a));
548 }
549
550 @Override
551 @ForceInline
552 public Double512Vector div(Vector<Double> o) {
553 Objects.requireNonNull(o);
554 Double512Vector v = (Double512Vector)o;
555 return VectorIntrinsics.binaryOp(
556 VECTOR_OP_DIV, Double512Vector.class, double.class, LENGTH,
557 this, v,
558 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double)(a / b)));
559 }
560
561 @Override
562 @ForceInline
563 public Double512Vector sqrt() {
564 return VectorIntrinsics.unaryOp(
565 VECTOR_OP_SQRT, Double512Vector.class, double.class, LENGTH,
566 this,
567 v1 -> v1.uOp((i, a) -> (double) Math.sqrt((double) a)));
568 }
569
570 @Override
571 @ForceInline
572 public Double512Vector exp() {
573 return (Double512Vector) VectorIntrinsics.unaryOp(
574 VECTOR_OP_EXP, Double512Vector.class, double.class, LENGTH,
575 this,
576 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.exp((double) a)));
577 }
578
579 @Override
580 @ForceInline
581 public Double512Vector log1p() {
582 return (Double512Vector) VectorIntrinsics.unaryOp(
583 VECTOR_OP_LOG1P, Double512Vector.class, double.class, LENGTH,
584 this,
585 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.log1p((double) a)));
586 }
587
588 @Override
589 @ForceInline
590 public Double512Vector log() {
591 return (Double512Vector) VectorIntrinsics.unaryOp(
592 VECTOR_OP_LOG, Double512Vector.class, double.class, LENGTH,
593 this,
594 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.log((double) a)));
595 }
596
597 @Override
598 @ForceInline
599 public Double512Vector log10() {
600 return (Double512Vector) VectorIntrinsics.unaryOp(
601 VECTOR_OP_LOG10, Double512Vector.class, double.class, LENGTH,
602 this,
603 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.log10((double) a)));
604 }
605
606 @Override
607 @ForceInline
608 public Double512Vector expm1() {
609 return (Double512Vector) VectorIntrinsics.unaryOp(
610 VECTOR_OP_EXPM1, Double512Vector.class, double.class, LENGTH,
611 this,
612 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.expm1((double) a)));
613 }
614
615 @Override
616 @ForceInline
617 public Double512Vector cbrt() {
618 return (Double512Vector) VectorIntrinsics.unaryOp(
619 VECTOR_OP_CBRT, Double512Vector.class, double.class, LENGTH,
620 this,
621 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.cbrt((double) a)));
622 }
623
624 @Override
625 @ForceInline
626 public Double512Vector sin() {
627 return (Double512Vector) VectorIntrinsics.unaryOp(
628 VECTOR_OP_SIN, Double512Vector.class, double.class, LENGTH,
629 this,
630 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.sin((double) a)));
631 }
632
633 @Override
634 @ForceInline
635 public Double512Vector cos() {
636 return (Double512Vector) VectorIntrinsics.unaryOp(
637 VECTOR_OP_COS, Double512Vector.class, double.class, LENGTH,
638 this,
639 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.cos((double) a)));
640 }
641
642 @Override
643 @ForceInline
644 public Double512Vector tan() {
645 return (Double512Vector) VectorIntrinsics.unaryOp(
646 VECTOR_OP_TAN, Double512Vector.class, double.class, LENGTH,
647 this,
648 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.tan((double) a)));
649 }
650
651 @Override
652 @ForceInline
653 public Double512Vector asin() {
654 return (Double512Vector) VectorIntrinsics.unaryOp(
655 VECTOR_OP_ASIN, Double512Vector.class, double.class, LENGTH,
656 this,
657 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.asin((double) a)));
658 }
659
660 @Override
661 @ForceInline
662 public Double512Vector acos() {
663 return (Double512Vector) VectorIntrinsics.unaryOp(
664 VECTOR_OP_ACOS, Double512Vector.class, double.class, LENGTH,
665 this,
666 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.acos((double) a)));
667 }
668
669 @Override
670 @ForceInline
671 public Double512Vector atan() {
672 return (Double512Vector) VectorIntrinsics.unaryOp(
673 VECTOR_OP_ATAN, Double512Vector.class, double.class, LENGTH,
674 this,
675 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.atan((double) a)));
676 }
677
678 @Override
679 @ForceInline
680 public Double512Vector sinh() {
681 return (Double512Vector) VectorIntrinsics.unaryOp(
682 VECTOR_OP_SINH, Double512Vector.class, double.class, LENGTH,
683 this,
684 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.sinh((double) a)));
685 }
686
687 @Override
688 @ForceInline
689 public Double512Vector cosh() {
690 return (Double512Vector) VectorIntrinsics.unaryOp(
691 VECTOR_OP_COSH, Double512Vector.class, double.class, LENGTH,
692 this,
693 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.cosh((double) a)));
694 }
695
696 @Override
697 @ForceInline
698 public Double512Vector tanh() {
699 return (Double512Vector) VectorIntrinsics.unaryOp(
700 VECTOR_OP_TANH, Double512Vector.class, double.class, LENGTH,
701 this,
702 v1 -> ((Double512Vector)v1).uOp((i, a) -> (double) Math.tanh((double) a)));
703 }
704
705 @Override
706 @ForceInline
707 public Double512Vector pow(Vector<Double> o) {
708 Objects.requireNonNull(o);
709 Double512Vector v = (Double512Vector)o;
710 return (Double512Vector) VectorIntrinsics.binaryOp(
711 VECTOR_OP_POW, Double512Vector.class, double.class, LENGTH,
712 this, v,
713 (v1, v2) -> ((Double512Vector)v1).bOp(v2, (i, a, b) -> (double)(Math.pow(a,b))));
714 }
715
716 @Override
717 @ForceInline
718 public Double512Vector hypot(Vector<Double> o) {
719 Objects.requireNonNull(o);
720 Double512Vector v = (Double512Vector)o;
721 return (Double512Vector) VectorIntrinsics.binaryOp(
722 VECTOR_OP_HYPOT, Double512Vector.class, double.class, LENGTH,
723 this, v,
724 (v1, v2) -> ((Double512Vector)v1).bOp(v2, (i, a, b) -> (double)(Math.hypot(a,b))));
725 }
726
727 @Override
728 @ForceInline
729 public Double512Vector atan2(Vector<Double> o) {
730 Objects.requireNonNull(o);
731 Double512Vector v = (Double512Vector)o;
732 return (Double512Vector) VectorIntrinsics.binaryOp(
733 VECTOR_OP_ATAN2, Double512Vector.class, double.class, LENGTH,
734 this, v,
735 (v1, v2) -> ((Double512Vector)v1).bOp(v2, (i, a, b) -> (double)(Math.atan2(a,b))));
736 }
737
738
739 // Binary operations
740
741 @Override
742 @ForceInline
743 public Double512Vector add(Vector<Double> o) {
744 Objects.requireNonNull(o);
745 Double512Vector v = (Double512Vector)o;
746 return VectorIntrinsics.binaryOp(
747 VECTOR_OP_ADD, Double512Vector.class, double.class, LENGTH,
748 this, v,
749 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double)(a + b)));
750 }
751
752 @Override
753 @ForceInline
754 public Double512Vector add(Vector<Double> v, Mask<Double> m) {
755 return blend(add(v), m);
756 }
757
758 @Override
759 @ForceInline
760 public Double512Vector sub(Vector<Double> o) {
761 Objects.requireNonNull(o);
762 Double512Vector v = (Double512Vector)o;
763 return VectorIntrinsics.binaryOp(
764 VECTOR_OP_SUB, Double512Vector.class, double.class, LENGTH,
765 this, v,
766 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double)(a - b)));
767 }
768
769 @Override
770 @ForceInline
771 public Double512Vector sub(Vector<Double> v, Mask<Double> m) {
772 return blend(sub(v), m);
773 }
774
775 @Override
776 @ForceInline
777 public Double512Vector mul(Vector<Double> o) {
778 Objects.requireNonNull(o);
779 Double512Vector v = (Double512Vector)o;
780 return VectorIntrinsics.binaryOp(
781 VECTOR_OP_MUL, Double512Vector.class, double.class, LENGTH,
782 this, v,
783 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double)(a * b)));
784 }
785
786 @Override
787 @ForceInline
788 public Double512Vector mul(Vector<Double> v, Mask<Double> m) {
789 return blend(mul(v), m);
790 }
791
792 @Override
793 @ForceInline
794 public Double512Vector min(Vector<Double> o) {
795 Objects.requireNonNull(o);
796 Double512Vector v = (Double512Vector)o;
797 return (Double512Vector) VectorIntrinsics.binaryOp(
798 VECTOR_OP_MIN, Double512Vector.class, double.class, LENGTH,
799 this, v,
800 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double) Math.min(a, b)));
801 }
802
803 @Override
804 @ForceInline
805 public Double512Vector min(Vector<Double> v, Mask<Double> m) {
806 return blend(min(v), m);
807 }
808
809 @Override
810 @ForceInline
811 public Double512Vector max(Vector<Double> o) {
812 Objects.requireNonNull(o);
813 Double512Vector v = (Double512Vector)o;
814 return VectorIntrinsics.binaryOp(
815 VECTOR_OP_MAX, Double512Vector.class, double.class, LENGTH,
816 this, v,
817 (v1, v2) -> v1.bOp(v2, (i, a, b) -> (double) Math.max(a, b)));
818 }
819
820 @Override
821 @ForceInline
822 public Double512Vector max(Vector<Double> v, Mask<Double> m) {
823 return blend(max(v), m);
824 }
825
826
827 // Ternary operations
828
829 @Override
830 @ForceInline
831 public Double512Vector fma(Vector<Double> o1, Vector<Double> o2) {
832 Objects.requireNonNull(o1);
833 Objects.requireNonNull(o2);
834 Double512Vector v1 = (Double512Vector)o1;
835 Double512Vector v2 = (Double512Vector)o2;
836 return VectorIntrinsics.ternaryOp(
837 VECTOR_OP_FMA, Double512Vector.class, double.class, LENGTH,
838 this, v1, v2,
839 (w1, w2, w3) -> w1.tOp(w2, w3, (i, a, b, c) -> Math.fma(a, b, c)));
840 }
841
842 // Type specific horizontal reductions
843
844 @Override
845 @ForceInline
846 public double addAll() {
847 long bits = (long) VectorIntrinsics.reductionCoerced(
848 VECTOR_OP_ADD, Double512Vector.class, double.class, LENGTH,
849 this,
850 v -> {
851 double r = v.rOp((double) 0, (i, a, b) -> (double) (a + b));
852 return (long)Double.doubleToLongBits(r);
853 });
854 return Double.longBitsToDouble(bits);
855 }
856
857 @Override
858 @ForceInline
859 public double mulAll() {
860 long bits = (long) VectorIntrinsics.reductionCoerced(
861 VECTOR_OP_MUL, Double512Vector.class, double.class, LENGTH,
862 this,
863 v -> {
864 double r = v.rOp((double) 1, (i, a, b) -> (double) (a * b));
865 return (long)Double.doubleToLongBits(r);
866 });
867 return Double.longBitsToDouble(bits);
868 }
869
870 @Override
871 @ForceInline
872 public double minAll() {
873 long bits = (long) VectorIntrinsics.reductionCoerced(
874 VECTOR_OP_MIN, Double512Vector.class, double.class, LENGTH,
875 this,
876 v -> {
877 double r = v.rOp(Double.MAX_VALUE , (i, a, b) -> (double) Math.min(a, b));
878 return (long)Double.doubleToLongBits(r);
879 });
880 return Double.longBitsToDouble(bits);
881 }
882
883 @Override
884 @ForceInline
885 public double maxAll() {
886 long bits = (long) VectorIntrinsics.reductionCoerced(
887 VECTOR_OP_MAX, Double512Vector.class, double.class, LENGTH,
888 this,
889 v -> {
890 double r = v.rOp(Double.MIN_VALUE , (i, a, b) -> (double) Math.max(a, b));
891 return (long)Double.doubleToLongBits(r);
892 });
893 return Double.longBitsToDouble(bits);
894 }
895
896
897 @Override
898 @ForceInline
899 public double addAll(Mask<Double> m) {
900 return SPECIES.broadcast((double) 0).blend(this, m).addAll();
901 }
902
903
904 @Override
905 @ForceInline
906 public double mulAll(Mask<Double> m) {
907 return SPECIES.broadcast((double) 1).blend(this, m).mulAll();
908 }
909
910 @Override
911 @ForceInline
912 public double minAll(Mask<Double> m) {
913 return SPECIES.broadcast(Double.MAX_VALUE).blend(this, m).minAll();
914 }
915
916 @Override
917 @ForceInline
918 public double maxAll(Mask<Double> m) {
919 return SPECIES.broadcast(Double.MIN_VALUE).blend(this, m).maxAll();
920 }
921
922 @Override
923 @ForceInline
924 public Shuffle<Double> toShuffle() {
925 double[] a = toArray();
926 int[] sa = new int[a.length];
927 for (int i = 0; i < a.length; i++) {
928 sa[i] = (int) a[i];
929 }
930 return DoubleVector.shuffleFromArray(SPECIES, sa, 0);
931 }
932
933 // Memory operations
934
935 private static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_DOUBLE_INDEX_SCALE);
936 private static final int BOOLEAN_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BOOLEAN_INDEX_SCALE);
937
938 @Override
939 @ForceInline
940 public void intoArray(double[] a, int ix) {
941 Objects.requireNonNull(a);
942 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
943 VectorIntrinsics.store(Double512Vector.class, double.class, LENGTH,
944 a, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_DOUBLE_BASE_OFFSET,
945 this,
946 a, ix,
947 (arr, idx, v) -> v.forEach((i, e) -> arr[idx + i] = e));
948 }
949
950 @Override
951 @ForceInline
952 public final void intoArray(double[] a, int ax, Mask<Double> m) {
953 DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax);
954 DoubleVector newVal = oldVal.blend(this, m);
955 newVal.intoArray(a, ax);
956 }
957 @Override
958 @ForceInline
959 public void intoArray(double[] a, int ix, int[] b, int iy) {
960 Objects.requireNonNull(a);
961 Objects.requireNonNull(b);
962
963 // Index vector: vix[0:n] = i -> ix + indexMap[iy + i]
964 IntVector vix = IntVector.fromArray(INDEX_SPEC, b, iy).add(ix);
965
966 vix = VectorIntrinsics.checkIndex(vix, a.length);
967
968 VectorIntrinsics.storeWithMap(Double512Vector.class, double.class, LENGTH, Int256Vector.class,
969 a, Unsafe.ARRAY_DOUBLE_BASE_OFFSET, vix,
970 this,
971 a, ix, b, iy,
972 (arr, idx, v, indexMap, idy) -> v.forEach((i, e) -> arr[idx+indexMap[idy+i]] = e));
973 }
974
975 @Override
976 @ForceInline
977 public final void intoArray(double[] a, int ax, Mask<Double> m, int[] b, int iy) {
978 // @@@ This can result in out of bounds errors for unset mask lanes
979 DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax, b, iy);
980 DoubleVector newVal = oldVal.blend(this, m);
981 newVal.intoArray(a, ax, b, iy);
982 }
983
984 @Override
985 @ForceInline
986 public void intoByteArray(byte[] a, int ix) {
987 Objects.requireNonNull(a);
988 ix = VectorIntrinsics.checkIndex(ix, a.length, bitSize() / Byte.SIZE);
989 VectorIntrinsics.store(Double512Vector.class, double.class, LENGTH,
990 a, ((long) ix) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
991 this,
992 a, ix,
993 (c, idx, v) -> {
994 ByteBuffer bbc = ByteBuffer.wrap(c, idx, c.length - idx).order(ByteOrder.nativeOrder());
995 DoubleBuffer tb = bbc.asDoubleBuffer();
996 v.forEach((i, e) -> tb.put(e));
997 });
998 }
999
1000 @Override
1001 @ForceInline
1002 public final void intoByteArray(byte[] a, int ix, Mask<Double> m) {
1003 Double512Vector oldVal = (Double512Vector) DoubleVector.fromByteArray(SPECIES, a, ix);
1004 Double512Vector newVal = oldVal.blend(this, m);
1005 newVal.intoByteArray(a, ix);
1006 }
1007
1008 @Override
1009 @ForceInline
1010 public void intoByteBuffer(ByteBuffer bb, int ix) {
1011 if (bb.order() != ByteOrder.nativeOrder()) {
1012 throw new IllegalArgumentException();
1013 }
1014 if (bb.isReadOnly()) {
1015 throw new ReadOnlyBufferException();
1016 }
1017 ix = VectorIntrinsics.checkIndex(ix, bb.limit(), bitSize() / Byte.SIZE);
1018 VectorIntrinsics.store(Double512Vector.class, double.class, LENGTH,
1019 U.getReference(bb, BYTE_BUFFER_HB), ix + U.getLong(bb, BUFFER_ADDRESS),
1020 this,
1021 bb, ix,
1022 (c, idx, v) -> {
1023 ByteBuffer bbc = c.duplicate().position(idx).order(ByteOrder.nativeOrder());
1024 DoubleBuffer tb = bbc.asDoubleBuffer();
1025 v.forEach((i, e) -> tb.put(e));
1026 });
1027 }
1028
1029 @Override
1030 @ForceInline
1031 public void intoByteBuffer(ByteBuffer bb, int ix, Mask<Double> m) {
1032 Double512Vector oldVal = (Double512Vector) DoubleVector.fromByteBuffer(SPECIES, bb, ix);
1033 Double512Vector newVal = oldVal.blend(this, m);
1034 newVal.intoByteBuffer(bb, ix);
1035 }
1036
1037 //
1038
1039 @Override
1040 public String toString() {
1041 return Arrays.toString(getElements());
1042 }
1043
1044 @Override
1045 public boolean equals(Object o) {
1046 if (this == o) return true;
1047 if (o == null || this.getClass() != o.getClass()) return false;
1048
1049 Double512Vector that = (Double512Vector) o;
1050 return this.equal(that).allTrue();
1051 }
1052
1053 @Override
1054 public int hashCode() {
1055 return Arrays.hashCode(vec);
1056 }
1057
1058 // Binary test
1059
1060 @Override
1061 Double512Mask bTest(Vector<Double> o, FBinTest f) {
1062 double[] vec1 = getElements();
1063 double[] vec2 = ((Double512Vector)o).getElements();
1064 boolean[] bits = new boolean[length()];
1065 for (int i = 0; i < length(); i++){
1066 bits[i] = f.apply(i, vec1[i], vec2[i]);
1067 }
1068 return new Double512Mask(bits);
1069 }
1070
1071 // Comparisons
1072
1073 @Override
1074 @ForceInline
1075 public Double512Mask equal(Vector<Double> o) {
1076 Objects.requireNonNull(o);
1077 Double512Vector v = (Double512Vector)o;
1078
1079 return VectorIntrinsics.compare(
1080 BT_eq, Double512Vector.class, Double512Mask.class, double.class, LENGTH,
1081 this, v,
1082 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a == b));
1083 }
1084
1085 @Override
1086 @ForceInline
1087 public Double512Mask notEqual(Vector<Double> o) {
1088 Objects.requireNonNull(o);
1089 Double512Vector v = (Double512Vector)o;
1090
1091 return VectorIntrinsics.compare(
1092 BT_ne, Double512Vector.class, Double512Mask.class, double.class, LENGTH,
1093 this, v,
1094 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a != b));
1095 }
1096
1097 @Override
1098 @ForceInline
1099 public Double512Mask lessThan(Vector<Double> o) {
1100 Objects.requireNonNull(o);
1101 Double512Vector v = (Double512Vector)o;
1102
1103 return VectorIntrinsics.compare(
1104 BT_lt, Double512Vector.class, Double512Mask.class, double.class, LENGTH,
1105 this, v,
1106 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a < b));
1107 }
1108
1109 @Override
1110 @ForceInline
1111 public Double512Mask lessThanEq(Vector<Double> o) {
1112 Objects.requireNonNull(o);
1113 Double512Vector v = (Double512Vector)o;
1114
1115 return VectorIntrinsics.compare(
1116 BT_le, Double512Vector.class, Double512Mask.class, double.class, LENGTH,
1117 this, v,
1118 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a <= b));
1119 }
1120
1121 @Override
1122 @ForceInline
1123 public Double512Mask greaterThan(Vector<Double> o) {
1124 Objects.requireNonNull(o);
1125 Double512Vector v = (Double512Vector)o;
1126
1127 return (Double512Mask) VectorIntrinsics.compare(
1128 BT_gt, Double512Vector.class, Double512Mask.class, double.class, LENGTH,
1129 this, v,
1130 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a > b));
1131 }
1132
1133 @Override
1134 @ForceInline
1135 public Double512Mask greaterThanEq(Vector<Double> o) {
1136 Objects.requireNonNull(o);
1137 Double512Vector v = (Double512Vector)o;
1138
1139 return VectorIntrinsics.compare(
1140 BT_ge, Double512Vector.class, Double512Mask.class, double.class, LENGTH,
1141 this, v,
1142 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a >= b));
1143 }
1144
1145 // Foreach
1146
1147 @Override
1148 void forEach(FUnCon f) {
1149 double[] vec = getElements();
1150 for (int i = 0; i < length(); i++) {
1151 f.apply(i, vec[i]);
1152 }
1153 }
1154
1155 @Override
1156 void forEach(Mask<Double> o, FUnCon f) {
1157 boolean[] mbits = ((Double512Mask)o).getBits();
1158 forEach((i, a) -> {
1159 if (mbits[i]) { f.apply(i, a); }
1160 });
1161 }
1162
1163 Long512Vector toBits() {
1164 double[] vec = getElements();
1165 long[] res = new long[this.species().length()];
1166 for(int i = 0; i < this.species().length(); i++){
1167 res[i] = Double.doubleToLongBits(vec[i]);
1168 }
1169 return new Long512Vector(res);
1170 }
1171
1172
1173 @Override
1174 public Double512Vector rotateEL(int j) {
1175 double[] vec = getElements();
1176 double[] res = new double[length()];
1177 for (int i = 0; i < length(); i++){
1178 res[(j + i) % length()] = vec[i];
1179 }
1180 return new Double512Vector(res);
1181 }
1182
1183 @Override
1184 public Double512Vector rotateER(int j) {
1185 double[] vec = getElements();
1186 double[] res = new double[length()];
1187 for (int i = 0; i < length(); i++){
1188 int z = i - j;
1189 if(j < 0) {
1190 res[length() + z] = vec[i];
1191 } else {
1192 res[z] = vec[i];
1193 }
1194 }
1195 return new Double512Vector(res);
1196 }
1197
1198 @Override
1199 public Double512Vector shiftEL(int j) {
1200 double[] vec = getElements();
1201 double[] res = new double[length()];
1202 for (int i = 0; i < length() - j; i++) {
1203 res[i] = vec[i + j];
1204 }
1205 return new Double512Vector(res);
1206 }
1207
1208 @Override
1209 public Double512Vector shiftER(int j) {
1210 double[] vec = getElements();
1211 double[] res = new double[length()];
1212 for (int i = 0; i < length() - j; i++){
1213 res[i + j] = vec[i];
1214 }
1215 return new Double512Vector(res);
1216 }
1217
1218 @Override
1219 @ForceInline
1220 public Double512Vector rearrange(Vector<Double> v,
1221 Shuffle<Double> s, Mask<Double> m) {
1222 return this.rearrange(s).blend(v.rearrange(s), m);
1223 }
1224
1225 @Override
1226 @ForceInline
1227 public Double512Vector rearrange(Shuffle<Double> o1) {
1228 Objects.requireNonNull(o1);
1229 Double512Shuffle s = (Double512Shuffle)o1;
1230
1231 return VectorIntrinsics.rearrangeOp(
1232 Double512Vector.class, Double512Shuffle.class, double.class, LENGTH,
1233 this, s,
1234 (v1, s_) -> v1.uOp((i, a) -> {
1235 int ei = s_.getElement(i);
1236 return v1.get(ei);
1237 }));
1238 }
1239
1240 @Override
1241 @ForceInline
1242 public Double512Vector blend(Vector<Double> o1, Mask<Double> o2) {
1243 Objects.requireNonNull(o1);
1244 Objects.requireNonNull(o2);
1245 Double512Vector v = (Double512Vector)o1;
1246 Double512Mask m = (Double512Mask)o2;
1247
1248 return VectorIntrinsics.blend(
1249 Double512Vector.class, Double512Mask.class, double.class, LENGTH,
1250 this, v, m,
1251 (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.getElement(i) ? b : a));
1252 }
1253
1254 // Accessors
1255
1256 @Override
1257 public double get(int i) {
1258 if (i < 0 || i >= LENGTH) {
1259 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1260 }
1261 long bits = (long) VectorIntrinsics.extract(
1262 Double512Vector.class, double.class, LENGTH,
1263 this, i,
1264 (vec, ix) -> {
1265 double[] vecarr = vec.getElements();
1266 return (long)Double.doubleToLongBits(vecarr[ix]);
1267 });
1268 return Double.longBitsToDouble(bits);
1269 }
1270
1271 @Override
1272 public Double512Vector with(int i, double e) {
1273 if (i < 0 || i >= LENGTH) {
1274 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH);
1275 }
1276 return VectorIntrinsics.insert(
1277 Double512Vector.class, double.class, LENGTH,
1278 this, i, (long)Double.doubleToLongBits(e),
1279 (v, ix, bits) -> {
1280 double[] res = v.getElements().clone();
1281 res[ix] = Double.longBitsToDouble((long)bits);
1282 return new Double512Vector(res);
1283 });
1284 }
1285
1286 // Mask
1287
1288 static final class Double512Mask extends AbstractMask<Double> {
1289 static final Double512Mask TRUE_MASK = new Double512Mask(true);
1290 static final Double512Mask FALSE_MASK = new Double512Mask(false);
1291
1292 private final boolean[] bits; // Don't access directly, use getBits() instead.
1293
1294 public Double512Mask(boolean[] bits) {
1295 this(bits, 0);
1296 }
1297
1298 public Double512Mask(boolean[] bits, int offset) {
1299 boolean[] a = new boolean[species().length()];
1300 for (int i = 0; i < a.length; i++) {
1301 a[i] = bits[offset + i];
1302 }
1303 this.bits = a;
1304 }
1305
1306 public Double512Mask(boolean val) {
1307 boolean[] bits = new boolean[species().length()];
1308 Arrays.fill(bits, val);
1309 this.bits = bits;
1310 }
1311
1312 boolean[] getBits() {
1313 return VectorIntrinsics.maybeRebox(this).bits;
1314 }
1315
1316 @Override
1317 Double512Mask uOp(MUnOp f) {
1318 boolean[] res = new boolean[species().length()];
1319 boolean[] bits = getBits();
1320 for (int i = 0; i < species().length(); i++) {
1321 res[i] = f.apply(i, bits[i]);
1322 }
1323 return new Double512Mask(res);
1324 }
1325
1326 @Override
1327 Double512Mask bOp(Mask<Double> o, MBinOp f) {
1328 boolean[] res = new boolean[species().length()];
1329 boolean[] bits = getBits();
1330 boolean[] mbits = ((Double512Mask)o).getBits();
1331 for (int i = 0; i < species().length(); i++) {
1332 res[i] = f.apply(i, bits[i], mbits[i]);
1333 }
1334 return new Double512Mask(res);
1335 }
1336
1337 @Override
1338 public Double512Species species() {
1339 return SPECIES;
1340 }
1341
1342 @Override
1343 public Double512Vector toVector() {
1344 double[] res = new double[species().length()];
1345 boolean[] bits = getBits();
1346 for (int i = 0; i < species().length(); i++) {
1347 // -1 will result in the most significant bit being set in
1348 // addition to some or all other bits
1349 res[i] = (double) (bits[i] ? -1 : 0);
1350 }
1351 return new Double512Vector(res);
1352 }
1353
1354 // Unary operations
1355
1356 @Override
1357 @ForceInline
1358 public Double512Mask not() {
1359 return (Double512Mask) VectorIntrinsics.unaryOp(
1360 VECTOR_OP_NOT, Double512Mask.class, long.class, LENGTH,
1361 this,
1362 (m1) -> m1.uOp((i, a) -> !a));
1363 }
1364
1365 // Binary operations
1366
1367 @Override
1368 @ForceInline
1369 public Double512Mask and(Mask<Double> o) {
1370 Objects.requireNonNull(o);
1371 Double512Mask m = (Double512Mask)o;
1372 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Double512Mask.class, long.class, LENGTH,
1373 this, m,
1374 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b));
1375 }
1376
1377 @Override
1378 @ForceInline
1379 public Double512Mask or(Mask<Double> o) {
1380 Objects.requireNonNull(o);
1381 Double512Mask m = (Double512Mask)o;
1382 return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Double512Mask.class, long.class, LENGTH,
1383 this, m,
1384 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b));
1385 }
1386
1387 // Reductions
1388
1389 @Override
1390 @ForceInline
1391 public boolean anyTrue() {
1392 return VectorIntrinsics.test(BT_ne, Double512Mask.class, long.class, LENGTH,
1393 this, this,
1394 (m, __) -> anyTrueHelper(((Double512Mask)m).getBits()));
1395 }
1396
1397 @Override
1398 @ForceInline
1399 public boolean allTrue() {
1400 return VectorIntrinsics.test(BT_overflow, Double512Mask.class, long.class, LENGTH,
1401 this, DoubleVector.maskAllTrue(species()),
1402 (m, __) -> allTrueHelper(((Double512Mask)m).getBits()));
1403 }
1404 }
1405
1406 // Shuffle
1407
1408 static final class Double512Shuffle extends AbstractShuffle<Double> {
1409 Double512Shuffle(byte[] reorder) {
1410 super(reorder);
1411 }
1412
1413 public Double512Shuffle(int[] reorder) {
1414 super(reorder);
1415 }
1416
1417 public Double512Shuffle(int[] reorder, int i) {
1418 super(reorder, i);
1419 }
1420
1421 public Double512Shuffle(IntUnaryOperator f) {
1422 super(f);
1423 }
1424
1425 @Override
1426 public Double512Species species() {
1427 return SPECIES;
1428 }
1429
1430 @Override
1431 public DoubleVector toVector() {
1432 double[] va = new double[SPECIES.length()];
1433 for (int i = 0; i < va.length; i++) {
1434 va[i] = (double) getElement(i);
1435 }
1436 return DoubleVector.fromArray(SPECIES, va, 0);
1437 }
1438
1439 @Override
1440 public Double512Shuffle rearrange(Vector.Shuffle<Double> o) {
1441 Double512Shuffle s = (Double512Shuffle) o;
1442 byte[] r = new byte[reorder.length];
1443 for (int i = 0; i < reorder.length; i++) {
1444 r[i] = reorder[s.reorder[i]];
1445 }
1446 return new Double512Shuffle(r);
1447 }
1448 }
1449
1450 // Species
1451
1452 @Override
1453 public Double512Species species() {
1454 return SPECIES;
1455 }
1456
1457 static final class Double512Species extends DoubleSpecies {
1458 static final int BIT_SIZE = Shape.S_512_BIT.bitSize();
1459
1460 static final int LENGTH = BIT_SIZE / Double.SIZE;
1461
1462 @Override
1463 public String toString() {
1464 StringBuilder sb = new StringBuilder("Shape[");
1465 sb.append(bitSize()).append(" bits, ");
1466 sb.append(length()).append(" ").append(double.class.getSimpleName()).append("s x ");
1467 sb.append(elementSize()).append(" bits");
1468 sb.append("]");
1469 return sb.toString();
1470 }
1471
1472 @Override
1473 @ForceInline
1474 public int bitSize() {
1475 return BIT_SIZE;
1476 }
1477
1478 @Override
1479 @ForceInline
1480 public int length() {
1481 return LENGTH;
1482 }
1483
1484 @Override
1485 @ForceInline
1486 public Class<Double> elementType() {
1487 return double.class;
1488 }
1489
1490 @Override
1491 @ForceInline
1492 public Class<?> boxType() {
1493 return Double512Vector.class;
1494 }
1495
1496 @Override
1497 @ForceInline
1498 public Class<?> maskType() {
1499 return Double512Mask.class;
1500 }
1501
1502 @Override
1503 @ForceInline
1504 public int elementSize() {
1505 return Double.SIZE;
1506 }
1507
1508 @Override
1509 @ForceInline
1510 @SuppressWarnings("unchecked")
1511 Class<?> vectorType() {
1512 return Double512Vector.class;
1513 }
1514
1515 @Override
1516 @ForceInline
1517 public Shape shape() {
1518 return Shape.S_512_BIT;
1519 }
1520
1521 @Override
1522 IntVector.IntSpecies indexSpecies() {
1523 return INDEX_SPEC;
1524 }
1525
1526 @Override
1527 Double512Vector op(FOp f) {
1528 double[] res = new double[length()];
1529 for (int i = 0; i < length(); i++) {
1530 res[i] = f.apply(i);
1531 }
1532 return new Double512Vector(res);
1533 }
1534
1535 @Override
1536 Double512Vector op(Mask<Double> o, FOp f) {
1537 double[] res = new double[length()];
1538 boolean[] mbits = ((Double512Mask)o).getBits();
1539 for (int i = 0; i < length(); i++) {
1540 if (mbits[i]) {
1541 res[i] = f.apply(i);
1542 }
1543 }
1544 return new Double512Vector(res);
1545 }
1546
1547 @Override
1548 Double512Mask opm(FOpm f) {
1549 boolean[] res = new boolean[length()];
1550 for (int i = 0; i < length(); i++) {
1551 res[i] = (boolean)f.apply(i);
1552 }
1553 return new Double512Mask(res);
1554 }
1555
1556 // Factories
1557
1558 @Override
1559 @ForceInline
1560 public Double512Vector zero() {
1561 return VectorIntrinsics.broadcastCoerced(Double512Vector.class, double.class, LENGTH,
1562 Double.doubleToLongBits(0.0f), SPECIES,
1563 ((bits, s) -> ((Double512Species)s).op(i -> Double.longBitsToDouble((long)bits))));
1564 }
1565
1566 @Override
1567 @ForceInline
1568 public Double512Vector broadcast(double e) {
1569 return VectorIntrinsics.broadcastCoerced(
1570 Double512Vector.class, double.class, LENGTH,
1571 Double.doubleToLongBits(e), SPECIES,
1572 ((bits, s) -> ((Double512Species)s).op(i -> Double.longBitsToDouble((long)bits))));
1573 }
1574
1575 @Override
1576 @ForceInline
1577 public Double512Vector scalars(double... es) {
1578 Objects.requireNonNull(es);
1579 int ix = VectorIntrinsics.checkIndex(0, es.length, LENGTH);
1580 return VectorIntrinsics.load(Double512Vector.class, double.class, LENGTH,
1581 es, Unsafe.ARRAY_DOUBLE_BASE_OFFSET,
1582 es, ix, SPECIES,
1583 (c, idx, s) -> ((Double512Species)s).op(n -> c[idx + n]));
1584 }
1585
1586 @Override
1587 @ForceInline
1588 public <E> Double512Mask cast(Mask<E> m) {
1589 if (m.length() != LENGTH)
1590 throw new IllegalArgumentException("Mask length this species length differ");
1591 return new Double512Mask(m.toArray());
1592 }
1593
1594 @Override
1595 @ForceInline
1596 public <E> Double512Shuffle cast(Shuffle<E> s) {
1597 if (s.length() != LENGTH)
1598 throw new IllegalArgumentException("Shuffle length this species length differ");
1599 return new Double512Shuffle(s.toArray());
1600 }
1601 }
1602 }