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 Double64Vector extends DoubleVector<Shapes.S64Bit> { 35 static final Double64Species SPECIES = new Double64Species(); 36 37 static final Double64Vector ZERO = new Double64Vector(); 38 39 static final int LENGTH = SPECIES.length(); 40 41 private final double[] vec; // Don't access directly, use getElements() instead. 42 43 private double[] getElements() { 44 return VectorIntrinsics.maybeRebox(this).vec; 45 } 46 47 Double64Vector() { 48 vec = new double[SPECIES.length()]; 49 } 50 51 Double64Vector(double[] v) { 52 vec = v; 53 } 54 55 @Override 56 public int length() { return LENGTH; } 57 58 // Unary operator 59 60 @Override 61 Double64Vector uOp(FUnOp f) { 62 double[] vec = getElements(); 63 double[] res = new double[length()]; 64 for (int i = 0; i < length(); i++) { 65 res[i] = f.apply(i, vec[i]); 66 } 67 return new Double64Vector(res); 68 } 69 70 @Override 71 Double64Vector uOp(Mask<Double, Shapes.S64Bit> o, FUnOp f) { 72 double[] vec = getElements(); 73 double[] res = new double[length()]; 74 boolean[] mbits = ((Double64Mask)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 Double64Vector(res); 79 } 80 81 // Binary operator 82 83 @Override 84 Double64Vector bOp(Vector<Double, Shapes.S64Bit> o, FBinOp f) { 85 double[] res = new double[length()]; 86 double[] vec1 = this.getElements(); 87 double[] vec2 = ((Double64Vector)o).getElements(); 88 for (int i = 0; i < length(); i++) { 89 res[i] = f.apply(i, vec1[i], vec2[i]); 90 } 91 return new Double64Vector(res); 92 } 93 94 @Override 95 Double64Vector bOp(Vector<Double, Shapes.S64Bit> o1, Mask<Double, Shapes.S64Bit> o2, FBinOp f) { 96 double[] res = new double[length()]; 97 double[] vec1 = this.getElements(); 98 double[] vec2 = ((Double64Vector)o1).getElements(); 99 boolean[] mbits = ((Double64Mask)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 Double64Vector(res); 104 } 105 106 // Trinary operator 107 108 @Override 109 Double64Vector tOp(Vector<Double, Shapes.S64Bit> o1, Vector<Double, Shapes.S64Bit> o2, FTriOp f) { 110 double[] res = new double[length()]; 111 double[] vec1 = this.getElements(); 112 double[] vec2 = ((Double64Vector)o1).getElements(); 113 double[] vec3 = ((Double64Vector)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 Double64Vector(res); 118 } 119 120 @Override 121 Double64Vector tOp(Vector<Double, Shapes.S64Bit> o1, Vector<Double, Shapes.S64Bit> o2, Mask<Double, Shapes.S64Bit> o3, FTriOp f) { 122 double[] res = new double[length()]; 123 double[] vec1 = getElements(); 124 double[] vec2 = ((Double64Vector)o1).getElements(); 125 double[] vec3 = ((Double64Vector)o2).getElements(); 126 boolean[] mbits = ((Double64Mask)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 Double64Vector(res); 131 } 132 133 @Override 134 double rOp(double v, FBinOp f) { 135 double[] 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 DoubleVector<Shapes.S64Bit> add(double o) { 147 return add(SPECIES.broadcast(o)); 148 } 149 150 @Override 151 @ForceInline 152 public DoubleVector<Shapes.S64Bit> add(double o, Mask<Double,Shapes.S64Bit> m) { 153 return add(SPECIES.broadcast(o), m); 154 } 155 156 @Override 157 @ForceInline 158 public DoubleVector<Shapes.S64Bit> addSaturate(double o) { 159 return addSaturate(SPECIES.broadcast(o)); 160 } 161 162 @Override 163 @ForceInline 164 public DoubleVector<Shapes.S64Bit> addSaturate(double o, Mask<Double,Shapes.S64Bit> m) { 165 return addSaturate(SPECIES.broadcast(o), m); 166 } 167 168 @Override 169 @ForceInline 170 public DoubleVector<Shapes.S64Bit> sub(double o) { 171 return sub(SPECIES.broadcast(o)); 172 } 173 174 @Override 175 @ForceInline 176 public DoubleVector<Shapes.S64Bit> sub(double o, Mask<Double,Shapes.S64Bit> m) { 177 return sub(SPECIES.broadcast(o), m); 178 } 179 180 @Override 181 @ForceInline 182 public DoubleVector<Shapes.S64Bit> subSaturate(double o) { 183 return subSaturate(SPECIES.broadcast(o)); 184 } 185 186 @Override 187 @ForceInline 188 public DoubleVector<Shapes.S64Bit> subSaturate(double o, Mask<Double,Shapes.S64Bit> m) { 189 return subSaturate(SPECIES.broadcast(o), m); 190 } 191 192 @Override 193 @ForceInline 194 public DoubleVector<Shapes.S64Bit> mul(double o) { 195 return mul(SPECIES.broadcast(o)); 196 } 197 198 @Override 199 @ForceInline 200 public DoubleVector<Shapes.S64Bit> mul(double o, Mask<Double,Shapes.S64Bit> m) { 201 return mul(SPECIES.broadcast(o), m); 202 } 203 204 @Override 205 @ForceInline 206 public DoubleVector<Shapes.S64Bit> min(double o) { 207 return min(SPECIES.broadcast(o)); 208 } 209 210 @Override 211 @ForceInline 212 public DoubleVector<Shapes.S64Bit> max(double o) { 213 return max(SPECIES.broadcast(o)); 214 } 215 216 @Override 217 @ForceInline 218 public Mask<Double, Shapes.S64Bit> equal(double o) { 219 return equal(SPECIES.broadcast(o)); 220 } 221 222 @Override 223 @ForceInline 224 public Mask<Double, Shapes.S64Bit> notEqual(double o) { 225 return notEqual(SPECIES.broadcast(o)); 226 } 227 228 @Override 229 @ForceInline 230 public Mask<Double, Shapes.S64Bit> lessThan(double o) { 231 return lessThan(SPECIES.broadcast(o)); 232 } 233 234 @Override 235 @ForceInline 236 public Mask<Double, Shapes.S64Bit> lessThanEq(double o) { 237 return lessThanEq(SPECIES.broadcast(o)); 238 } 239 240 @Override 241 @ForceInline 242 public Mask<Double, Shapes.S64Bit> greaterThan(double o) { 243 return greaterThan(SPECIES.broadcast(o)); 244 } 245 246 @Override 247 @ForceInline 248 public Mask<Double, Shapes.S64Bit> greaterThanEq(double o) { 249 return greaterThanEq(SPECIES.broadcast(o)); 250 } 251 252 @Override 253 @ForceInline 254 public DoubleVector<Shapes.S64Bit> blend(double o, Mask<Double,Shapes.S64Bit> m) { 255 return blend(SPECIES.broadcast(o), m); 256 } 257 258 @Override 259 @ForceInline 260 public DoubleVector<Shapes.S64Bit> div(double o) { 261 return div(SPECIES.broadcast(o)); 262 } 263 264 @Override 265 @ForceInline 266 public DoubleVector<Shapes.S64Bit> div(double o, Mask<Double,Shapes.S64Bit> m) { 267 return div(SPECIES.broadcast(o), m); 268 } 269 270 @Override 271 @ForceInline 272 public DoubleVector<Shapes.S64Bit> atan2(double o) { 273 return atan2(SPECIES.broadcast(o)); 274 } 275 276 @Override 277 @ForceInline 278 public DoubleVector<Shapes.S64Bit> atan2(double o, Mask<Double,Shapes.S64Bit> m) { 279 return atan2(SPECIES.broadcast(o), m); 280 } 281 282 @Override 283 @ForceInline 284 public DoubleVector<Shapes.S64Bit> pow(double o) { 285 return pow(SPECIES.broadcast(o)); 286 } 287 288 @Override 289 @ForceInline 290 public DoubleVector<Shapes.S64Bit> pow(double o, Mask<Double,Shapes.S64Bit> m) { 291 return pow(SPECIES.broadcast(o), m); 292 } 293 294 @Override 295 @ForceInline 296 public DoubleVector<Shapes.S64Bit> fma(double o1, double o2) { 297 return fma(SPECIES.broadcast(o1), SPECIES.broadcast(o2)); 298 } 299 300 @Override 301 @ForceInline 302 public DoubleVector<Shapes.S64Bit> fma(double o1, double o2, Mask<Double,Shapes.S64Bit> m) { 303 return fma(SPECIES.broadcast(o1), SPECIES.broadcast(o2), m); 304 } 305 306 @Override 307 @ForceInline 308 public DoubleVector<Shapes.S64Bit> hypot(double o) { 309 return hypot(SPECIES.broadcast(o)); 310 } 311 312 @Override 313 @ForceInline 314 public DoubleVector<Shapes.S64Bit> hypot(double o, Mask<Double,Shapes.S64Bit> m) { 315 return hypot(SPECIES.broadcast(o), m); 316 } 317 318 319 320 // Unary operations 321 322 @Override 323 @ForceInline 324 public Double64Vector abs() { 325 return (Double64Vector) VectorIntrinsics.unaryOp( 326 VECTOR_OP_ABS, Double64Vector.class, double.class, LENGTH, 327 this, 328 v1 -> ((Double64Vector)v1).uOp((i, a) -> (double) Math.abs(a))); 329 } 330 331 @Override 332 @ForceInline 333 public Double64Vector neg() { 334 return (Double64Vector) VectorIntrinsics.unaryOp( 335 VECTOR_OP_NEG, Double64Vector.class, double.class, LENGTH, 336 this, 337 v1 -> ((Double64Vector)v1).uOp((i, a) -> (double) -a)); 338 } 339 340 @Override 341 @ForceInline 342 public Double64Vector div(Vector<Double,Shapes.S64Bit> o) { 343 Objects.requireNonNull(o); 344 Double64Vector v = (Double64Vector)o; 345 return (Double64Vector) VectorIntrinsics.binaryOp( 346 VECTOR_OP_DIV, Double64Vector.class, double.class, LENGTH, 347 this, v, 348 (v1, v2) -> ((Double64Vector)v1).bOp(v2, (i, a, b) -> (double)(a / b))); 349 } 350 351 @Override 352 @ForceInline 353 public Double64Vector sqrt() { 354 return (Double64Vector) VectorIntrinsics.unaryOp( 355 VECTOR_OP_SQRT, Double64Vector.class, double.class, LENGTH, 356 this, 357 v1 -> ((Double64Vector)v1).uOp((i, a) -> (double) Math.sqrt((double) a))); 358 } 359 360 // Binary operations 361 362 @Override 363 @ForceInline 364 public Double64Vector add(Vector<Double,Shapes.S64Bit> o) { 365 Objects.requireNonNull(o); 366 Double64Vector v = (Double64Vector)o; 367 return (Double64Vector) VectorIntrinsics.binaryOp( 368 VECTOR_OP_ADD, Double64Vector.class, double.class, LENGTH, 369 this, v, 370 (v1, v2) -> ((Double64Vector)v1).bOp(v2, (i, a, b) -> (double)(a + b))); 371 } 372 373 @Override 374 @ForceInline 375 public Double64Vector sub(Vector<Double,Shapes.S64Bit> o) { 376 Objects.requireNonNull(o); 377 Double64Vector v = (Double64Vector)o; 378 return (Double64Vector) VectorIntrinsics.binaryOp( 379 VECTOR_OP_SUB, Double64Vector.class, double.class, LENGTH, 380 this, v, 381 (v1, v2) -> ((Double64Vector)v1).bOp(v2, (i, a, b) -> (double)(a - b))); 382 } 383 384 @Override 385 @ForceInline 386 public Double64Vector mul(Vector<Double,Shapes.S64Bit> o) { 387 Objects.requireNonNull(o); 388 Double64Vector v = (Double64Vector)o; 389 return (Double64Vector) VectorIntrinsics.binaryOp( 390 VECTOR_OP_MUL, Double64Vector.class, double.class, LENGTH, 391 this, v, 392 (v1, v2) -> ((Double64Vector)v1).bOp(v2, (i, a, b) -> (double)(a * b))); 393 } 394 395 @Override 396 @ForceInline 397 public Double64Vector min(Vector<Double,Shapes.S64Bit> o) { 398 Objects.requireNonNull(o); 399 Double64Vector v = (Double64Vector)o; 400 return (Double64Vector) VectorIntrinsics.binaryOp( 401 VECTOR_OP_MIN, Double64Vector.class, double.class, LENGTH, 402 this, v, 403 (v1, v2) -> ((Double64Vector)v1).bOp(v2, (i, a, b) -> (double) ((a < b) ? a : b))); 404 } 405 406 @Override 407 @ForceInline 408 public Double64Vector max(Vector<Double,Shapes.S64Bit> o) { 409 Objects.requireNonNull(o); 410 Double64Vector v = (Double64Vector)o; 411 return (Double64Vector) VectorIntrinsics.binaryOp( 412 VECTOR_OP_MAX, Double64Vector.class, double.class, LENGTH, 413 this, v, 414 (v1, v2) -> ((Double64Vector)v1).bOp(v2, (i, a, b) -> (double) ((a > b) ? a : b))); 415 } 416 417 @Override 418 @ForceInline 419 public Double64Vector add(Vector<Double,Shapes.S64Bit> v, Mask<Double, Shapes.S64Bit> m) { 420 // TODO: use better default impl: bOp(o, m, (i, a, b) -> (double)(a + b)); 421 return blend(add(v), m); 422 } 423 424 @Override 425 @ForceInline 426 public Double64Vector sub(Vector<Double,Shapes.S64Bit> v, Mask<Double, Shapes.S64Bit> m) { 427 // TODO: use better default impl: bOp(o, m, (i, a, b) -> (double)(a - b)); 428 return blend(sub(v), m); 429 } 430 431 @Override 432 @ForceInline 433 public Double64Vector mul(Vector<Double,Shapes.S64Bit> v, Mask<Double, Shapes.S64Bit> m) { 434 // TODO: use better default impl: bOp(o, m, (i, a, b) -> (double)(a * b)); 435 return blend(mul(v), m); 436 } 437 438 @Override 439 @ForceInline 440 public Double64Vector div(Vector<Double,Shapes.S64Bit> v, Mask<Double, Shapes.S64Bit> m) { 441 // TODO: use better default impl: bOp(o, m, (i, a, b) -> (double)(a / b)); 442 return blend(div(v), m); 443 } 444 445 446 // Ternary operations 447 448 @Override 449 @ForceInline 450 public Double64Vector fma(Vector<Double,Shapes.S64Bit> o1, Vector<Double,Shapes.S64Bit> o2) { 451 Objects.requireNonNull(o1); 452 Objects.requireNonNull(o2); 453 Double64Vector v1 = (Double64Vector)o1; 454 Double64Vector v2 = (Double64Vector)o2; 455 return (Double64Vector) VectorIntrinsics.ternaryOp( 456 VECTOR_OP_FMA, Double64Vector.class, double.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 double addAll() { 466 long bits = (long) VectorIntrinsics.reductionCoerced( 467 VECTOR_OP_ADD, Double64Vector.class, double.class, LENGTH, 468 this, 469 v -> { 470 double r = v.rOp((double) 0, (i, a, b) -> (double) (a + b)); 471 return (long)Double.doubleToLongBits(r); 472 }); 473 return Double.longBitsToDouble(bits); 474 } 475 476 @Override 477 @ForceInline 478 public double mulAll() { 479 long bits = (long) VectorIntrinsics.reductionCoerced( 480 VECTOR_OP_MUL, Double64Vector.class, double.class, LENGTH, 481 this, 482 v -> { 483 double r = v.rOp((double) 1, (i, a, b) -> (double) (a * b)); 484 return (long)Double.doubleToLongBits(r); 485 }); 486 return Double.longBitsToDouble(bits); 487 } 488 489 // Memory operations 490 491 @Override 492 @ForceInline 493 public void intoArray(double[] a, int ix) { 494 Objects.requireNonNull(a); 495 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH); 496 VectorIntrinsics.store(Double64Vector.class, double.class, LENGTH, 497 a, ix, this, 498 (arr, idx, v) -> v.forEach((i, a_) -> ((double[])arr)[idx + i] = a_)); 499 } 500 501 @Override 502 @ForceInline 503 public void intoArray(double[] a, int ax, Mask<Double, Shapes.S64Bit> m) { 504 // TODO: use better default impl: forEach(m, (i, a_) -> a[ax + i] = a_); 505 Double64Vector oldVal = SPECIES.fromArray(a, ax); 506 Double64Vector 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 Double64Vector that = (Double64Vector) 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 Double64Mask bTest(Vector<Double, Shapes.S64Bit> o, FBinTest f) { 535 double[] vec1 = getElements(); 536 double[] vec2 = ((Double64Vector)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 Double64Mask(bits); 542 } 543 544 // Comparisons 545 546 @Override 547 @ForceInline 548 public Double64Mask equal(Vector<Double, Shapes.S64Bit> o) { 549 Objects.requireNonNull(o); 550 Double64Vector v = (Double64Vector)o; 551 552 return (Double64Mask) VectorIntrinsics.compare( 553 BT_eq, Double64Vector.class, Double64Mask.class, double.class, LENGTH, 554 this, v, 555 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a == b)); 556 } 557 558 @Override 559 @ForceInline 560 public Double64Mask notEqual(Vector<Double, Shapes.S64Bit> o) { 561 Objects.requireNonNull(o); 562 Double64Vector v = (Double64Vector)o; 563 564 return (Double64Mask) VectorIntrinsics.compare( 565 BT_ne, Double64Vector.class, Double64Mask.class, double.class, LENGTH, 566 this, v, 567 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a != b)); 568 } 569 570 @Override 571 @ForceInline 572 public Double64Mask lessThan(Vector<Double, Shapes.S64Bit> o) { 573 Objects.requireNonNull(o); 574 Double64Vector v = (Double64Vector)o; 575 576 return (Double64Mask) VectorIntrinsics.compare( 577 BT_lt, Double64Vector.class, Double64Mask.class, double.class, LENGTH, 578 this, v, 579 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a < b)); 580 } 581 582 @Override 583 @ForceInline 584 public Double64Mask lessThanEq(Vector<Double, Shapes.S64Bit> o) { 585 Objects.requireNonNull(o); 586 Double64Vector v = (Double64Vector)o; 587 588 return (Double64Mask) VectorIntrinsics.compare( 589 BT_le, Double64Vector.class, Double64Mask.class, double.class, LENGTH, 590 this, v, 591 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a <= b)); 592 } 593 594 @Override 595 @ForceInline 596 public Double64Mask greaterThan(Vector<Double, Shapes.S64Bit> o) { 597 Objects.requireNonNull(o); 598 Double64Vector v = (Double64Vector)o; 599 600 return (Double64Mask) VectorIntrinsics.compare( 601 BT_gt, Double64Vector.class, Double64Mask.class, double.class, LENGTH, 602 this, v, 603 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a > b)); 604 } 605 606 @Override 607 @ForceInline 608 public Double64Mask greaterThanEq(Vector<Double, Shapes.S64Bit> o) { 609 Objects.requireNonNull(o); 610 Double64Vector v = (Double64Vector)o; 611 612 return (Double64Mask) VectorIntrinsics.compare( 613 BT_ge, Double64Vector.class, Double64Mask.class, double.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 double[] 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<Double, Shapes.S64Bit> o, FUnCon f) { 630 boolean[] mbits = ((Double64Mask)o).getBits(); 631 forEach((i, a) -> { 632 if (mbits[i]) { f.apply(i, a); } 633 }); 634 } 635 636 Long64Vector toBits() { 637 double[] vec = getElements(); 638 long[] res = new long[this.species().length()]; 639 for(int i = 0; i < this.species().length(); i++){ 640 res[i] = Double.doubleToLongBits(vec[i]); 641 } 642 return new Long64Vector(res); 643 } 644 645 646 @Override 647 public Double64Vector rotateEL(int j) { 648 double[] vec = getElements(); 649 double[] res = new double[length()]; 650 for (int i = 0; i < length(); i++){ 651 res[(j + i) % length()] = vec[i]; 652 } 653 return new Double64Vector(res); 654 } 655 656 @Override 657 public Double64Vector rotateER(int j) { 658 double[] vec = getElements(); 659 double[] res = new double[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 Double64Vector(res); 669 } 670 671 @Override 672 public Double64Vector shiftEL(int j) { 673 double[] vec = getElements(); 674 double[] res = new double[length()]; 675 for (int i = 0; i < length() - j; i++) { 676 res[i] = vec[i + j]; 677 } 678 return new Double64Vector(res); 679 } 680 681 @Override 682 public Double64Vector shiftER(int j) { 683 double[] vec = getElements(); 684 double[] res = new double[length()]; 685 for (int i = 0; i < length() - j; i++){ 686 res[i + j] = vec[i]; 687 } 688 return new Double64Vector(res); 689 } 690 691 @Override 692 public Double64Vector shuffle(Vector<Double, Shapes.S64Bit> o, Shuffle<Double, Shapes.S64Bit> s) { 693 Double64Vector v = (Double64Vector) o; 694 return uOp((i, a) -> { 695 double[] 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 Double64Vector swizzle(Shuffle<Double, Shapes.S64Bit> s) { 711 return uOp((i, a) -> { 712 double[] 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 Double64Vector blend(Vector<Double, Shapes.S64Bit> o1, Mask<Double, Shapes.S64Bit> o2) { 725 Objects.requireNonNull(o1); 726 Objects.requireNonNull(o2); 727 Double64Vector v = (Double64Vector)o1; 728 Double64Mask m = (Double64Mask)o2; 729 730 return (Double64Vector) VectorIntrinsics.blend( 731 Double64Vector.class, Double64Mask.class, double.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 double get(int i) { 740 double[] vec = getElements(); 741 return vec[i]; 742 } 743 744 @Override 745 public Double64Vector with(int i, double e) { 746 double[] res = vec.clone(); 747 res[i] = e; 748 return new Double64Vector(res); 749 } 750 751 // Mask 752 753 static final class Double64Mask extends AbstractMask<Double, Shapes.S64Bit> { 754 static final Double64Mask TRUE_MASK = new Double64Mask(true); 755 static final Double64Mask FALSE_MASK = new Double64Mask(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 Double64Mask(boolean[] bits) { 761 this(bits, 0); 762 } 763 764 public Double64Mask(boolean[] bits, int i) { 765 this.bits = Arrays.copyOfRange(bits, i, i + species().length()); 766 } 767 768 public Double64Mask(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 Double64Mask 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 Double64Mask(res); 786 } 787 788 @Override 789 Double64Mask bOp(Mask<Double, Shapes.S64Bit> o, MBinOp f) { 790 boolean[] res = new boolean[species().length()]; 791 boolean[] bits = getBits(); 792 boolean[] mbits = ((Double64Mask)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 Double64Mask(res); 797 } 798 799 @Override 800 public Double64Species species() { 801 return SPECIES; 802 } 803 804 @Override 805 public Double64Vector toVector() { 806 double[] res = new double[species().length()]; 807 boolean[] bits = getBits(); 808 for (int i = 0; i < species().length(); i++) { 809 res[i] = (double) (bits[i] ? -1 : 0); 810 } 811 return new Double64Vector(res); 812 } 813 814 @Override 815 @ForceInline 816 @SuppressWarnings("unchecked") 817 public <Z> Mask<Z, Shapes.S64Bit> rebracket(Species<Z, Shapes.S64Bit> species) { 818 Objects.requireNonNull(species); 819 // TODO: check proper element type 820 return VectorIntrinsics.reinterpret( 821 Double64Mask.class, double.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 Double64Mask and(Mask<Double,Shapes.S64Bit> o) { 836 Objects.requireNonNull(o); 837 Double64Mask m = (Double64Mask)o; 838 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, Double64Mask.class, long.class, LENGTH, 839 this, m, 840 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b)); 841 } 842 843 @Override 844 @ForceInline 845 public Double64Mask or(Mask<Double,Shapes.S64Bit> o) { 846 Objects.requireNonNull(o); 847 Double64Mask m = (Double64Mask)o; 848 return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Double64Mask.class, long.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, Double64Mask.class, long.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, Double64Mask.class, long.class, LENGTH, 867 this, species().maskAllTrue(), 868 (m1, m2) -> super.allTrue()); 869 } 870 } 871 872 // Shuffle 873 874 static final class Double64Shuffle extends AbstractShuffle<Double, Shapes.S64Bit> { 875 static final IntVector.IntSpecies<Shapes.S64Bit> INT_SPECIES = IntVector.speciesInstance(Shapes.S_64_BIT); 876 877 public Double64Shuffle(int[] reorder) { 878 super(reorder); 879 } 880 881 public Double64Shuffle(int[] reorder, int i) { 882 super(reorder, i); 883 } 884 885 @Override 886 public Double64Species species() { 887 return SPECIES; 888 } 889 890 @Override 891 public IntVector.IntSpecies<Shapes.S64Bit> intSpecies() { 892 return INT_SPECIES; 893 } 894 } 895 896 // Species 897 898 @Override 899 public Double64Species species() { 900 return SPECIES; 901 } 902 903 static final class Double64Species extends DoubleSpecies<Shapes.S64Bit> { 904 static final int BIT_SIZE = Shapes.S_64_BIT.bitSize(); 905 906 static final int LENGTH = BIT_SIZE / Double.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(double.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<Double> elementType() { 933 return double.class; 934 } 935 936 @Override 937 @ForceInline 938 public int elementSize() { 939 return Double.SIZE; 940 } 941 942 @Override 943 @ForceInline 944 public Shapes.S64Bit shape() { 945 return Shapes.S_64_BIT; 946 } 947 948 @Override 949 Double64Vector op(FOp f) { 950 double[] res = new double[length()]; 951 for (int i = 0; i < length(); i++) { 952 res[i] = f.apply(i); 953 } 954 return new Double64Vector(res); 955 } 956 957 @Override 958 Double64Vector op(Mask<Double, Shapes.S64Bit> o, FOp f) { 959 double[] res = new double[length()]; 960 boolean[] mbits = ((Double64Mask)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 Double64Vector(res); 967 } 968 969 // Factories 970 971 @Override 972 public Double64Mask maskFromValues(boolean... bits) { 973 return new Double64Mask(bits); 974 } 975 976 @Override 977 public Double64Mask maskFromArray(boolean[] bits, int i) { 978 return new Double64Mask(bits, i); 979 } 980 981 @Override 982 public Double64Shuffle shuffleFromValues(int... ixs) { 983 return new Double64Shuffle(ixs); 984 } 985 986 @Override 987 public Double64Shuffle shuffleFromArray(int[] ixs, int i) { 988 return new Double64Shuffle(ixs, i); 989 } 990 991 @Override 992 public Double64Shuffle shuffleFromVector(Vector<Integer, Shapes.S64Bit> v) { 993 int[] a = ((IntVector<Shapes.S64Bit>) v).toArray(); 994 return new Double64Shuffle(a, 0); 995 } 996 997 @Override 998 @ForceInline 999 public Double64Vector zero() { 1000 return VectorIntrinsics.broadcastCoerced(Double64Vector.class, double.class, LENGTH, 1001 Double.doubleToLongBits(0.0f), 1002 (z -> ZERO)); 1003 } 1004 1005 @Override 1006 @ForceInline 1007 public Double64Vector broadcast(double e) { 1008 return VectorIntrinsics.broadcastCoerced( 1009 Double64Vector.class, double.class, LENGTH, 1010 Double.doubleToLongBits(e), 1011 ((long bits) -> SPECIES.op(i -> Double.longBitsToDouble((long)bits)))); 1012 } 1013 1014 @Override 1015 @ForceInline 1016 public Double64Mask maskAllTrue() { 1017 return VectorIntrinsics.broadcastCoerced(Double64Mask.class, long.class, LENGTH, 1018 (long)-1, 1019 (z -> Double64Mask.TRUE_MASK)); 1020 } 1021 1022 @Override 1023 @ForceInline 1024 public Double64Mask maskAllFalse() { 1025 return VectorIntrinsics.broadcastCoerced(Double64Mask.class, long.class, LENGTH, 1026 0, 1027 (z -> Double64Mask.FALSE_MASK)); 1028 } 1029 1030 @Override 1031 @ForceInline 1032 public Double64Vector fromArray(double[] a, int ix) { 1033 Objects.requireNonNull(a); 1034 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH); 1035 return (Double64Vector) VectorIntrinsics.load(Double64Vector.class, double.class, LENGTH, 1036 a, ix, 1037 (arr, idx) -> super.fromArray((double[]) arr, idx)); 1038 } 1039 1040 @Override 1041 @ForceInline 1042 public Double64Vector fromArray(double[] a, int ax, Mask<Double, Shapes.S64Bit> 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> Double64Vector 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 double.class, LENGTH, so, 1054 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1061 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1068 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1075 (v, t) -> (Double64Vector)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> Double64Vector 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 double.class, LENGTH, so, 1090 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1097 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1104 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1111 (v, t) -> (Double64Vector)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> Double64Vector 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 double.class, LENGTH, so, 1126 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1133 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1140 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1147 (v, t) -> (Double64Vector)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> Double64Vector 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 double.class, LENGTH, so, 1162 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1169 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1176 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1183 (v, t) -> (Double64Vector)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> Double64Vector 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 double.class, LENGTH, so, 1198 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1205 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1212 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1219 (v, t) -> (Double64Vector)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> Double64Vector 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 double.class, LENGTH, so, 1234 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1241 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1248 (v, t) -> (Double64Vector)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 double.class, LENGTH, so, 1255 (v, t) -> (Double64Vector)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> Double64Vector 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> Double64Vector rebracket(Vector<F, Shapes.S64Bit> o) { 1294 Objects.requireNonNull(o); 1295 if (o.elementType() == byte.class) { 1296 Byte64Vector so = (Byte64Vector)o; 1297 return VectorIntrinsics.reinterpret( 1298 Byte64Vector.class, byte.class, so.length(), 1299 double.class, LENGTH, so, 1300 (v, t) -> (Double64Vector)reshape(v) 1301 ); 1302 } else if (o.elementType() == short.class) { 1303 Short64Vector so = (Short64Vector)o; 1304 return VectorIntrinsics.reinterpret( 1305 Short64Vector.class, short.class, so.length(), 1306 double.class, LENGTH, so, 1307 (v, t) -> (Double64Vector)reshape(v) 1308 ); 1309 } else if (o.elementType() == int.class) { 1310 Int64Vector so = (Int64Vector)o; 1311 return VectorIntrinsics.reinterpret( 1312 Int64Vector.class, int.class, so.length(), 1313 double.class, LENGTH, so, 1314 (v, t) -> (Double64Vector)reshape(v) 1315 ); 1316 } else if (o.elementType() == long.class) { 1317 Long64Vector so = (Long64Vector)o; 1318 return VectorIntrinsics.reinterpret( 1319 Long64Vector.class, long.class, so.length(), 1320 double.class, LENGTH, so, 1321 (v, t) -> (Double64Vector)reshape(v) 1322 ); 1323 } else if (o.elementType() == float.class) { 1324 Float64Vector so = (Float64Vector)o; 1325 return VectorIntrinsics.reinterpret( 1326 Float64Vector.class, float.class, so.length(), 1327 double.class, LENGTH, so, 1328 (v, t) -> (Double64Vector)reshape(v) 1329 ); 1330 } else if (o.elementType() == double.class) { 1331 Double64Vector so = (Double64Vector)o; 1332 return VectorIntrinsics.reinterpret( 1333 Double64Vector.class, double.class, so.length(), 1334 double.class, LENGTH, so, 1335 (v, t) -> (Double64Vector)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> Double64Vector resize(Vector<Double, T> o) { 1346 Objects.requireNonNull(o); 1347 if (o.bitSize() == 64) { 1348 Double64Vector so = (Double64Vector)o; 1349 return VectorIntrinsics.reinterpret( 1350 Double64Vector.class, double.class, so.length(), 1351 double.class, LENGTH, so, 1352 (v, t) -> (Double64Vector)reshape(v) 1353 ); 1354 } else if (o.bitSize() == 128) { 1355 Double128Vector so = (Double128Vector)o; 1356 return VectorIntrinsics.reinterpret( 1357 Double128Vector.class, double.class, so.length(), 1358 double.class, LENGTH, so, 1359 (v, t) -> (Double64Vector)reshape(v) 1360 ); 1361 } else if (o.bitSize() == 256) { 1362 Double256Vector so = (Double256Vector)o; 1363 return VectorIntrinsics.reinterpret( 1364 Double256Vector.class, double.class, so.length(), 1365 double.class, LENGTH, so, 1366 (v, t) -> (Double64Vector)reshape(v) 1367 ); 1368 } else if (o.bitSize() == 512) { 1369 Double512Vector so = (Double512Vector)o; 1370 return VectorIntrinsics.reinterpret( 1371 Double512Vector.class, double.class, so.length(), 1372 double.class, LENGTH, so, 1373 (v, t) -> (Double64Vector)reshape(v) 1374 ); 1375 } else { 1376 throw new InternalError("Unimplemented size"); 1377 } 1378 } 1379 } 1380 }