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 #if[!byte] 30 import java.nio.$Type$Buffer; 31 #end[!byte] 32 import java.nio.ReadOnlyBufferException; 33 import java.util.Arrays; 34 import java.util.Objects; 35 import java.util.function.IntUnaryOperator; 36 37 import jdk.internal.misc.Unsafe; 38 import jdk.internal.vm.annotation.ForceInline; 39 import static jdk.incubator.vector.VectorIntrinsics.*; 40 41 @SuppressWarnings("cast") 42 final class $vectortype$ extends $abstractvectortype$ { 43 private static final VectorSpecies<$Boxtype$> SPECIES = $Type$Vector.SPECIES_$BITS$; 44 45 static final $vectortype$ ZERO = new $vectortype$(); 46 47 static final int LENGTH = SPECIES.length(); 48 49 #if[!byteOrShort] 50 // Index vector species 51 private static final IntVector.IntSpecies INDEX_SPECIES; 52 53 static { 54 #if[longOrDouble64] 55 INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(VectorShape.S_64_BIT); 56 #else[longOrDouble64] 57 int bitSize = Vector.bitSizeForVectorLength(int.class, LENGTH); 58 INDEX_SPECIES = (IntVector.IntSpecies) IntVector.species(VectorShape.forBitSize(bitSize)); 59 #end[longOrDouble64] 60 } 61 62 #end[!byteOrShort] 63 private final $type$[] vec; // Don't access directly, use getElements() instead. 64 65 private $type$[] getElements() { 66 return VectorIntrinsics.maybeRebox(this).vec; 67 } 68 69 $vectortype$() { 70 vec = new $type$[SPECIES.length()]; 71 } 72 73 $vectortype$($type$[] v) { 74 vec = v; 75 } 76 77 @Override 78 public int length() { return LENGTH; } 79 80 // Unary operator 81 82 @Override 83 $vectortype$ uOp(FUnOp f) { 84 $type$[] vec = getElements(); 85 $type$[] res = new $type$[length()]; 86 for (int i = 0; i < length(); i++) { 87 res[i] = f.apply(i, vec[i]); 88 } 89 return new $vectortype$(res); 90 } 91 92 @Override 93 $vectortype$ uOp(VectorMask<$Boxtype$> o, FUnOp f) { 94 $type$[] vec = getElements(); 95 $type$[] res = new $type$[length()]; 96 boolean[] mbits = (($masktype$)o).getBits(); 97 for (int i = 0; i < length(); i++) { 98 res[i] = mbits[i] ? f.apply(i, vec[i]) : vec[i]; 99 } 100 return new $vectortype$(res); 101 } 102 103 // Binary operator 104 105 @Override 106 $vectortype$ bOp(Vector<$Boxtype$> o, FBinOp f) { 107 $type$[] res = new $type$[length()]; 108 $type$[] vec1 = this.getElements(); 109 $type$[] vec2 = (($vectortype$)o).getElements(); 110 for (int i = 0; i < length(); i++) { 111 res[i] = f.apply(i, vec1[i], vec2[i]); 112 } 113 return new $vectortype$(res); 114 } 115 116 @Override 117 $vectortype$ bOp(Vector<$Boxtype$> o1, VectorMask<$Boxtype$> o2, FBinOp f) { 118 $type$[] res = new $type$[length()]; 119 $type$[] vec1 = this.getElements(); 120 $type$[] vec2 = (($vectortype$)o1).getElements(); 121 boolean[] mbits = (($masktype$)o2).getBits(); 122 for (int i = 0; i < length(); i++) { 123 res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i]) : vec1[i]; 124 } 125 return new $vectortype$(res); 126 } 127 128 // Trinary operator 129 130 @Override 131 $vectortype$ tOp(Vector<$Boxtype$> o1, Vector<$Boxtype$> o2, FTriOp f) { 132 $type$[] res = new $type$[length()]; 133 $type$[] vec1 = this.getElements(); 134 $type$[] vec2 = (($vectortype$)o1).getElements(); 135 $type$[] vec3 = (($vectortype$)o2).getElements(); 136 for (int i = 0; i < length(); i++) { 137 res[i] = f.apply(i, vec1[i], vec2[i], vec3[i]); 138 } 139 return new $vectortype$(res); 140 } 141 142 @Override 143 $vectortype$ tOp(Vector<$Boxtype$> o1, Vector<$Boxtype$> o2, VectorMask<$Boxtype$> o3, FTriOp f) { 144 $type$[] res = new $type$[length()]; 145 $type$[] vec1 = getElements(); 146 $type$[] vec2 = (($vectortype$)o1).getElements(); 147 $type$[] vec3 = (($vectortype$)o2).getElements(); 148 boolean[] mbits = (($masktype$)o3).getBits(); 149 for (int i = 0; i < length(); i++) { 150 res[i] = mbits[i] ? f.apply(i, vec1[i], vec2[i], vec3[i]) : vec1[i]; 151 } 152 return new $vectortype$(res); 153 } 154 155 @Override 156 $type$ rOp($type$ v, FBinOp f) { 157 $type$[] vec = getElements(); 158 for (int i = 0; i < length(); i++) { 159 v = f.apply(i, v, vec[i]); 160 } 161 return v; 162 } 163 164 @Override 165 @ForceInline 166 public <F> Vector<F> cast(VectorSpecies<F> s) { 167 Objects.requireNonNull(s); 168 if (s.length() != LENGTH) 169 throw new IllegalArgumentException("Vector length this species length differ"); 170 171 return VectorIntrinsics.cast( 172 $vectortype$.class, 173 $type$.class, LENGTH, 174 s.boxType(), 175 s.elementType(), LENGTH, 176 this, s, 177 (species, vector) -> vector.castDefault(species) 178 ); 179 } 180 181 @SuppressWarnings("unchecked") 182 @ForceInline 183 private <F> Vector<F> castDefault(VectorSpecies<F> s) { 184 int limit = s.length(); 185 186 Class<?> stype = s.elementType(); 187 if (stype == byte.class) { 188 byte[] a = new byte[limit]; 189 for (int i = 0; i < limit; i++) { 190 a[i] = (byte) this.lane(i); 191 } 192 return (Vector) ByteVector.fromArray((VectorSpecies<Byte>) s, a, 0); 193 } else if (stype == short.class) { 194 short[] a = new short[limit]; 195 for (int i = 0; i < limit; i++) { 196 a[i] = (short) this.lane(i); 197 } 198 return (Vector) ShortVector.fromArray((VectorSpecies<Short>) s, a, 0); 199 } else if (stype == int.class) { 200 int[] a = new int[limit]; 201 for (int i = 0; i < limit; i++) { 202 a[i] = (int) this.lane(i); 203 } 204 return (Vector) IntVector.fromArray((VectorSpecies<Integer>) s, a, 0); 205 } else if (stype == long.class) { 206 long[] a = new long[limit]; 207 for (int i = 0; i < limit; i++) { 208 a[i] = (long) this.lane(i); 209 } 210 return (Vector) LongVector.fromArray((VectorSpecies<Long>) s, a, 0); 211 } else if (stype == float.class) { 212 float[] a = new float[limit]; 213 for (int i = 0; i < limit; i++) { 214 a[i] = (float) this.lane(i); 215 } 216 return (Vector) FloatVector.fromArray((VectorSpecies<Float>) s, a, 0); 217 } else if (stype == double.class) { 218 double[] a = new double[limit]; 219 for (int i = 0; i < limit; i++) { 220 a[i] = (double) this.lane(i); 221 } 222 return (Vector) DoubleVector.fromArray((VectorSpecies<Double>) s, a, 0); 223 } else { 224 throw new UnsupportedOperationException("Bad lane type for casting."); 225 } 226 } 227 228 @Override 229 @ForceInline 230 @SuppressWarnings("unchecked") 231 public <F> Vector<F> reinterpret(VectorSpecies<F> s) { 232 Objects.requireNonNull(s); 233 234 if(s.elementType().equals($type$.class)) { 235 return (Vector<F>) reshape((VectorSpecies<$Boxtype$>)s); 236 } 237 if(s.bitSize() == bitSize()) { 238 return reinterpretType(s); 239 } 240 241 return defaultReinterpret(s); 242 } 243 244 @ForceInline 245 private <F> Vector<F> reinterpretType(VectorSpecies<F> s) { 246 Objects.requireNonNull(s); 247 248 Class<?> stype = s.elementType(); 249 if (stype == byte.class) { 250 return VectorIntrinsics.reinterpret( 251 $vectortype$.class, 252 $type$.class, LENGTH, 253 Byte$bits$Vector.class, 254 byte.class, Byte$bits$Vector.LENGTH, 255 this, s, 256 (species, vector) -> vector.defaultReinterpret(species) 257 ); 258 } else if (stype == short.class) { 259 return VectorIntrinsics.reinterpret( 260 $vectortype$.class, 261 $type$.class, LENGTH, 262 Short$bits$Vector.class, 263 short.class, Short$bits$Vector.LENGTH, 264 this, s, 265 (species, vector) -> vector.defaultReinterpret(species) 266 ); 267 } else if (stype == int.class) { 268 return VectorIntrinsics.reinterpret( 269 $vectortype$.class, 270 $type$.class, LENGTH, 271 Int$bits$Vector.class, 272 int.class, Int$bits$Vector.LENGTH, 273 this, s, 274 (species, vector) -> vector.defaultReinterpret(species) 275 ); 276 } else if (stype == long.class) { 277 return VectorIntrinsics.reinterpret( 278 $vectortype$.class, 279 $type$.class, LENGTH, 280 Long$bits$Vector.class, 281 long.class, Long$bits$Vector.LENGTH, 282 this, s, 283 (species, vector) -> vector.defaultReinterpret(species) 284 ); 285 } else if (stype == float.class) { 286 return VectorIntrinsics.reinterpret( 287 $vectortype$.class, 288 $type$.class, LENGTH, 289 Float$bits$Vector.class, 290 float.class, Float$bits$Vector.LENGTH, 291 this, s, 292 (species, vector) -> vector.defaultReinterpret(species) 293 ); 294 } else if (stype == double.class) { 295 return VectorIntrinsics.reinterpret( 296 $vectortype$.class, 297 $type$.class, LENGTH, 298 Double$bits$Vector.class, 299 double.class, Double$bits$Vector.LENGTH, 300 this, s, 301 (species, vector) -> vector.defaultReinterpret(species) 302 ); 303 } else { 304 throw new UnsupportedOperationException("Bad lane type for casting."); 305 } 306 } 307 308 @Override 309 @ForceInline 310 public $abstractvectortype$ reshape(VectorSpecies<$Boxtype$> s) { 311 Objects.requireNonNull(s); 312 if (s.bitSize() == 64 && (s.boxType() == $Type$64Vector.class)) { 313 return VectorIntrinsics.reinterpret( 314 $vectortype$.class, 315 $type$.class, LENGTH, 316 $Type$64Vector.class, 317 $type$.class, $Type$64Vector.LENGTH, 318 this, s, 319 (species, vector) -> ($abstractvectortype$) vector.defaultReinterpret(species) 320 ); 321 } else if (s.bitSize() == 128 && (s.boxType() == $Type$128Vector.class)) { 322 return VectorIntrinsics.reinterpret( 323 $vectortype$.class, 324 $type$.class, LENGTH, 325 $Type$128Vector.class, 326 $type$.class, $Type$128Vector.LENGTH, 327 this, s, 328 (species, vector) -> ($abstractvectortype$) vector.defaultReinterpret(species) 329 ); 330 } else if (s.bitSize() == 256 && (s.boxType() == $Type$256Vector.class)) { 331 return VectorIntrinsics.reinterpret( 332 $vectortype$.class, 333 $type$.class, LENGTH, 334 $Type$256Vector.class, 335 $type$.class, $Type$256Vector.LENGTH, 336 this, s, 337 (species, vector) -> ($abstractvectortype$) vector.defaultReinterpret(species) 338 ); 339 } else if (s.bitSize() == 512 && (s.boxType() == $Type$512Vector.class)) { 340 return VectorIntrinsics.reinterpret( 341 $vectortype$.class, 342 $type$.class, LENGTH, 343 $Type$512Vector.class, 344 $type$.class, $Type$512Vector.LENGTH, 345 this, s, 346 (species, vector) -> ($abstractvectortype$) vector.defaultReinterpret(species) 347 ); 348 } else if ((s.bitSize() > 0) && (s.bitSize() <= 2048) 349 && (s.bitSize() % 128 == 0) && (s.boxType() == $Type$MaxVector.class)) { 350 return VectorIntrinsics.reinterpret( 351 $vectortype$.class, 352 $type$.class, LENGTH, 353 $Type$MaxVector.class, 354 $type$.class, $Type$MaxVector.LENGTH, 355 this, s, 356 (species, vector) -> ($abstractvectortype$) vector.defaultReinterpret(species) 357 ); 358 } else { 359 throw new InternalError("Unimplemented size"); 360 } 361 } 362 363 // Binary operations with scalars 364 365 @Override 366 @ForceInline 367 public $abstractvectortype$ add($type$ o) { 368 return add(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 369 } 370 371 @Override 372 @ForceInline 373 public $abstractvectortype$ add($type$ o, VectorMask<$Boxtype$> m) { 374 return add(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o), m); 375 } 376 377 @Override 378 @ForceInline 379 public $abstractvectortype$ sub($type$ o) { 380 return sub(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 381 } 382 383 @Override 384 @ForceInline 385 public $abstractvectortype$ sub($type$ o, VectorMask<$Boxtype$> m) { 386 return sub(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o), m); 387 } 388 389 @Override 390 @ForceInline 391 public $abstractvectortype$ mul($type$ o) { 392 return mul(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 393 } 394 395 @Override 396 @ForceInline 397 public $abstractvectortype$ mul($type$ o, VectorMask<$Boxtype$> m) { 398 return mul(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o), m); 399 } 400 401 @Override 402 @ForceInline 403 public $abstractvectortype$ min($type$ o) { 404 return min(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 405 } 406 407 @Override 408 @ForceInline 409 public $abstractvectortype$ max($type$ o) { 410 return max(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 411 } 412 413 @Override 414 @ForceInline 415 public VectorMask<$Boxtype$> equal($type$ o) { 416 return equal(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 417 } 418 419 @Override 420 @ForceInline 421 public VectorMask<$Boxtype$> notEqual($type$ o) { 422 return notEqual(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 423 } 424 425 @Override 426 @ForceInline 427 public VectorMask<$Boxtype$> lessThan($type$ o) { 428 return lessThan(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 429 } 430 431 @Override 432 @ForceInline 433 public VectorMask<$Boxtype$> lessThanEq($type$ o) { 434 return lessThanEq(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 435 } 436 437 @Override 438 @ForceInline 439 public VectorMask<$Boxtype$> greaterThan($type$ o) { 440 return greaterThan(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 441 } 442 443 @Override 444 @ForceInline 445 public VectorMask<$Boxtype$> greaterThanEq($type$ o) { 446 return greaterThanEq(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 447 } 448 449 @Override 450 @ForceInline 451 public $abstractvectortype$ blend($type$ o, VectorMask<$Boxtype$> m) { 452 return blend(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o), m); 453 } 454 455 #if[FP] 456 @Override 457 @ForceInline 458 public $abstractvectortype$ div($type$ o) { 459 return div(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 460 } 461 462 @Override 463 @ForceInline 464 public $abstractvectortype$ div($type$ o, VectorMask<$Boxtype$> m) { 465 return div(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o), m); 466 } 467 468 @Override 469 @ForceInline 470 public $vectortype$ div(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 471 return blend(div(v), m); 472 } 473 474 @Override 475 @ForceInline 476 public $abstractvectortype$ atan2($type$ o) { 477 return atan2(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 478 } 479 480 @Override 481 @ForceInline 482 public $abstractvectortype$ atan2($type$ o, VectorMask<$Boxtype$> m) { 483 return atan2(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o), m); 484 } 485 486 @Override 487 @ForceInline 488 public $abstractvectortype$ pow($type$ o) { 489 return pow(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 490 } 491 492 @Override 493 @ForceInline 494 public $abstractvectortype$ pow($type$ o, VectorMask<$Boxtype$> m) { 495 return pow(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o), m); 496 } 497 498 @Override 499 @ForceInline 500 public $abstractvectortype$ fma($type$ o1, $type$ o2) { 501 return fma(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o1), ($vectortype$)$abstractvectortype$.broadcast(SPECIES, o2)); 502 } 503 504 @Override 505 @ForceInline 506 public $abstractvectortype$ fma($type$ o1, $type$ o2, VectorMask<$Boxtype$> m) { 507 return fma(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o1), ($vectortype$)$abstractvectortype$.broadcast(SPECIES, o2), m); 508 } 509 510 @Override 511 @ForceInline 512 public $abstractvectortype$ hypot($type$ o) { 513 return hypot(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 514 } 515 516 @Override 517 @ForceInline 518 public $abstractvectortype$ hypot($type$ o, VectorMask<$Boxtype$> m) { 519 return hypot(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o), m); 520 } 521 #end[FP] 522 523 #if[BITWISE] 524 @Override 525 @ForceInline 526 public $abstractvectortype$ and($type$ o) { 527 return and(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 528 } 529 530 @Override 531 @ForceInline 532 public $abstractvectortype$ and($type$ o, VectorMask<$Boxtype$> m) { 533 return and(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o), m); 534 } 535 536 @Override 537 @ForceInline 538 public $abstractvectortype$ or($type$ o) { 539 return or(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 540 } 541 542 @Override 543 @ForceInline 544 public $abstractvectortype$ or($type$ o, VectorMask<$Boxtype$> m) { 545 return or(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o), m); 546 } 547 548 @Override 549 @ForceInline 550 public $abstractvectortype$ xor($type$ o) { 551 return xor(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o)); 552 } 553 554 @Override 555 @ForceInline 556 public $abstractvectortype$ xor($type$ o, VectorMask<$Boxtype$> m) { 557 return xor(($vectortype$)$abstractvectortype$.broadcast(SPECIES, o), m); 558 } 559 560 @Override 561 @ForceInline 562 public $vectortype$ neg() { 563 return ($vectortype$)zero(SPECIES).sub(this); 564 } 565 #end[BITWISE] 566 567 // Unary operations 568 569 @ForceInline 570 @Override 571 public $vectortype$ neg(VectorMask<$Boxtype$> m) { 572 return blend(neg(), m); 573 } 574 575 @Override 576 @ForceInline 577 public $vectortype$ abs() { 578 return VectorIntrinsics.unaryOp( 579 VECTOR_OP_ABS, $vectortype$.class, $type$.class, LENGTH, 580 this, 581 v1 -> v1.uOp((i, a) -> ($type$) Math.abs(a))); 582 } 583 584 @ForceInline 585 @Override 586 public $vectortype$ abs(VectorMask<$Boxtype$> m) { 587 return blend(abs(), m); 588 } 589 590 #if[FP] 591 @Override 592 @ForceInline 593 public $vectortype$ neg() { 594 return VectorIntrinsics.unaryOp( 595 VECTOR_OP_NEG, $vectortype$.class, $type$.class, LENGTH, 596 this, 597 v1 -> v1.uOp((i, a) -> ($type$) -a)); 598 } 599 600 @Override 601 @ForceInline 602 public $vectortype$ div(Vector<$Boxtype$> o) { 603 Objects.requireNonNull(o); 604 $vectortype$ v = ($vectortype$)o; 605 return VectorIntrinsics.binaryOp( 606 VECTOR_OP_DIV, $vectortype$.class, $type$.class, LENGTH, 607 this, v, 608 (v1, v2) -> v1.bOp(v2, (i, a, b) -> ($type$)(a / b))); 609 } 610 611 @Override 612 @ForceInline 613 public $vectortype$ sqrt() { 614 return VectorIntrinsics.unaryOp( 615 VECTOR_OP_SQRT, $vectortype$.class, $type$.class, LENGTH, 616 this, 617 v1 -> v1.uOp((i, a) -> ($type$) Math.sqrt((double) a))); 618 } 619 620 @Override 621 @ForceInline 622 public $vectortype$ exp() { 623 return ($vectortype$) VectorIntrinsics.unaryOp( 624 VECTOR_OP_EXP, $vectortype$.class, $type$.class, LENGTH, 625 this, 626 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.exp((double) a))); 627 } 628 629 @Override 630 @ForceInline 631 public $vectortype$ log1p() { 632 return ($vectortype$) VectorIntrinsics.unaryOp( 633 VECTOR_OP_LOG1P, $vectortype$.class, $type$.class, LENGTH, 634 this, 635 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.log1p((double) a))); 636 } 637 638 @Override 639 @ForceInline 640 public $vectortype$ log() { 641 return ($vectortype$) VectorIntrinsics.unaryOp( 642 VECTOR_OP_LOG, $vectortype$.class, $type$.class, LENGTH, 643 this, 644 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.log((double) a))); 645 } 646 647 @Override 648 @ForceInline 649 public $vectortype$ log10() { 650 return ($vectortype$) VectorIntrinsics.unaryOp( 651 VECTOR_OP_LOG10, $vectortype$.class, $type$.class, LENGTH, 652 this, 653 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.log10((double) a))); 654 } 655 656 @Override 657 @ForceInline 658 public $vectortype$ expm1() { 659 return ($vectortype$) VectorIntrinsics.unaryOp( 660 VECTOR_OP_EXPM1, $vectortype$.class, $type$.class, LENGTH, 661 this, 662 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.expm1((double) a))); 663 } 664 665 @Override 666 @ForceInline 667 public $vectortype$ cbrt() { 668 return ($vectortype$) VectorIntrinsics.unaryOp( 669 VECTOR_OP_CBRT, $vectortype$.class, $type$.class, LENGTH, 670 this, 671 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.cbrt((double) a))); 672 } 673 674 @Override 675 @ForceInline 676 public $vectortype$ sin() { 677 return ($vectortype$) VectorIntrinsics.unaryOp( 678 VECTOR_OP_SIN, $vectortype$.class, $type$.class, LENGTH, 679 this, 680 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.sin((double) a))); 681 } 682 683 @Override 684 @ForceInline 685 public $vectortype$ cos() { 686 return ($vectortype$) VectorIntrinsics.unaryOp( 687 VECTOR_OP_COS, $vectortype$.class, $type$.class, LENGTH, 688 this, 689 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.cos((double) a))); 690 } 691 692 @Override 693 @ForceInline 694 public $vectortype$ tan() { 695 return ($vectortype$) VectorIntrinsics.unaryOp( 696 VECTOR_OP_TAN, $vectortype$.class, $type$.class, LENGTH, 697 this, 698 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.tan((double) a))); 699 } 700 701 @Override 702 @ForceInline 703 public $vectortype$ asin() { 704 return ($vectortype$) VectorIntrinsics.unaryOp( 705 VECTOR_OP_ASIN, $vectortype$.class, $type$.class, LENGTH, 706 this, 707 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.asin((double) a))); 708 } 709 710 @Override 711 @ForceInline 712 public $vectortype$ acos() { 713 return ($vectortype$) VectorIntrinsics.unaryOp( 714 VECTOR_OP_ACOS, $vectortype$.class, $type$.class, LENGTH, 715 this, 716 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.acos((double) a))); 717 } 718 719 @Override 720 @ForceInline 721 public $vectortype$ atan() { 722 return ($vectortype$) VectorIntrinsics.unaryOp( 723 VECTOR_OP_ATAN, $vectortype$.class, $type$.class, LENGTH, 724 this, 725 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.atan((double) a))); 726 } 727 728 @Override 729 @ForceInline 730 public $vectortype$ sinh() { 731 return ($vectortype$) VectorIntrinsics.unaryOp( 732 VECTOR_OP_SINH, $vectortype$.class, $type$.class, LENGTH, 733 this, 734 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.sinh((double) a))); 735 } 736 737 @Override 738 @ForceInline 739 public $vectortype$ cosh() { 740 return ($vectortype$) VectorIntrinsics.unaryOp( 741 VECTOR_OP_COSH, $vectortype$.class, $type$.class, LENGTH, 742 this, 743 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.cosh((double) a))); 744 } 745 746 @Override 747 @ForceInline 748 public $vectortype$ tanh() { 749 return ($vectortype$) VectorIntrinsics.unaryOp( 750 VECTOR_OP_TANH, $vectortype$.class, $type$.class, LENGTH, 751 this, 752 v1 -> (($vectortype$)v1).uOp((i, a) -> ($type$) Math.tanh((double) a))); 753 } 754 755 @Override 756 @ForceInline 757 public $vectortype$ pow(Vector<$Boxtype$> o) { 758 Objects.requireNonNull(o); 759 $vectortype$ v = ($vectortype$)o; 760 return ($vectortype$) VectorIntrinsics.binaryOp( 761 VECTOR_OP_POW, $vectortype$.class, $type$.class, LENGTH, 762 this, v, 763 (v1, v2) -> (($vectortype$)v1).bOp(v2, (i, a, b) -> ($type$)(Math.pow(a,b)))); 764 } 765 766 @Override 767 @ForceInline 768 public $vectortype$ hypot(Vector<$Boxtype$> o) { 769 Objects.requireNonNull(o); 770 $vectortype$ v = ($vectortype$)o; 771 return ($vectortype$) VectorIntrinsics.binaryOp( 772 VECTOR_OP_HYPOT, $vectortype$.class, $type$.class, LENGTH, 773 this, v, 774 (v1, v2) -> (($vectortype$)v1).bOp(v2, (i, a, b) -> ($type$)(Math.hypot(a,b)))); 775 } 776 777 @Override 778 @ForceInline 779 public $vectortype$ atan2(Vector<$Boxtype$> o) { 780 Objects.requireNonNull(o); 781 $vectortype$ v = ($vectortype$)o; 782 return ($vectortype$) VectorIntrinsics.binaryOp( 783 VECTOR_OP_ATAN2, $vectortype$.class, $type$.class, LENGTH, 784 this, v, 785 (v1, v2) -> (($vectortype$)v1).bOp(v2, (i, a, b) -> ($type$)(Math.atan2(a,b)))); 786 } 787 788 #end[FP] 789 790 #if[BITWISE] 791 @Override 792 @ForceInline 793 public $vectortype$ not() { 794 return VectorIntrinsics.unaryOp( 795 VECTOR_OP_NOT, $vectortype$.class, $type$.class, LENGTH, 796 this, 797 v1 -> v1.uOp((i, a) -> ($type$) ~a)); 798 } 799 800 @ForceInline 801 @Override 802 public $vectortype$ not(VectorMask<$Boxtype$> m) { 803 return blend(not(), m); 804 } 805 #end[BITWISE] 806 // Binary operations 807 808 @Override 809 @ForceInline 810 public $vectortype$ add(Vector<$Boxtype$> o) { 811 Objects.requireNonNull(o); 812 $vectortype$ v = ($vectortype$)o; 813 return VectorIntrinsics.binaryOp( 814 VECTOR_OP_ADD, $vectortype$.class, $type$.class, LENGTH, 815 this, v, 816 (v1, v2) -> v1.bOp(v2, (i, a, b) -> ($type$)(a + b))); 817 } 818 819 @Override 820 @ForceInline 821 public $vectortype$ add(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 822 return blend(add(v), m); 823 } 824 825 @Override 826 @ForceInline 827 public $vectortype$ sub(Vector<$Boxtype$> o) { 828 Objects.requireNonNull(o); 829 $vectortype$ v = ($vectortype$)o; 830 return VectorIntrinsics.binaryOp( 831 VECTOR_OP_SUB, $vectortype$.class, $type$.class, LENGTH, 832 this, v, 833 (v1, v2) -> v1.bOp(v2, (i, a, b) -> ($type$)(a - b))); 834 } 835 836 @Override 837 @ForceInline 838 public $vectortype$ sub(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 839 return blend(sub(v), m); 840 } 841 842 @Override 843 @ForceInline 844 public $vectortype$ mul(Vector<$Boxtype$> o) { 845 Objects.requireNonNull(o); 846 $vectortype$ v = ($vectortype$)o; 847 return VectorIntrinsics.binaryOp( 848 VECTOR_OP_MUL, $vectortype$.class, $type$.class, LENGTH, 849 this, v, 850 (v1, v2) -> v1.bOp(v2, (i, a, b) -> ($type$)(a * b))); 851 } 852 853 @Override 854 @ForceInline 855 public $vectortype$ mul(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 856 return blend(mul(v), m); 857 } 858 859 @Override 860 @ForceInline 861 public $vectortype$ min(Vector<$Boxtype$> o) { 862 Objects.requireNonNull(o); 863 $vectortype$ v = ($vectortype$)o; 864 return ($vectortype$) VectorIntrinsics.binaryOp( 865 VECTOR_OP_MIN, $vectortype$.class, $type$.class, LENGTH, 866 this, v, 867 (v1, v2) -> v1.bOp(v2, (i, a, b) -> ($type$) Math.min(a, b))); 868 } 869 870 @Override 871 @ForceInline 872 public $vectortype$ min(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 873 return blend(min(v), m); 874 } 875 876 @Override 877 @ForceInline 878 public $vectortype$ max(Vector<$Boxtype$> o) { 879 Objects.requireNonNull(o); 880 $vectortype$ v = ($vectortype$)o; 881 return VectorIntrinsics.binaryOp( 882 VECTOR_OP_MAX, $vectortype$.class, $type$.class, LENGTH, 883 this, v, 884 (v1, v2) -> v1.bOp(v2, (i, a, b) -> ($type$) Math.max(a, b))); 885 } 886 887 @Override 888 @ForceInline 889 public $vectortype$ max(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 890 return blend(max(v), m); 891 } 892 893 #if[BITWISE] 894 @Override 895 @ForceInline 896 public $vectortype$ and(Vector<$Boxtype$> o) { 897 Objects.requireNonNull(o); 898 $vectortype$ v = ($vectortype$)o; 899 return VectorIntrinsics.binaryOp( 900 VECTOR_OP_AND, $vectortype$.class, $type$.class, LENGTH, 901 this, v, 902 (v1, v2) -> v1.bOp(v2, (i, a, b) -> ($type$)(a & b))); 903 } 904 905 @Override 906 @ForceInline 907 public $vectortype$ or(Vector<$Boxtype$> o) { 908 Objects.requireNonNull(o); 909 $vectortype$ v = ($vectortype$)o; 910 return VectorIntrinsics.binaryOp( 911 VECTOR_OP_OR, $vectortype$.class, $type$.class, LENGTH, 912 this, v, 913 (v1, v2) -> v1.bOp(v2, (i, a, b) -> ($type$)(a | b))); 914 } 915 916 @Override 917 @ForceInline 918 public $vectortype$ xor(Vector<$Boxtype$> o) { 919 Objects.requireNonNull(o); 920 $vectortype$ v = ($vectortype$)o; 921 return VectorIntrinsics.binaryOp( 922 VECTOR_OP_XOR, $vectortype$.class, $type$.class, LENGTH, 923 this, v, 924 (v1, v2) -> v1.bOp(v2, (i, a, b) -> ($type$)(a ^ b))); 925 } 926 927 @Override 928 @ForceInline 929 public $vectortype$ and(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 930 return blend(and(v), m); 931 } 932 933 @Override 934 @ForceInline 935 public $vectortype$ or(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 936 return blend(or(v), m); 937 } 938 939 @Override 940 @ForceInline 941 public $vectortype$ xor(Vector<$Boxtype$> v, VectorMask<$Boxtype$> m) { 942 return blend(xor(v), m); 943 } 944 #end[BITWISE] 945 946 #if[byte] 947 @Override 948 @ForceInline 949 public $vectortype$ shiftL(int s) { 950 return VectorIntrinsics.broadcastInt( 951 VECTOR_OP_LSHIFT, $vectortype$.class, $type$.class, LENGTH, 952 this, s, 953 (v, i) -> v.uOp((__, a) -> ($type$) (a << (i & 7)))); 954 } 955 956 @Override 957 @ForceInline 958 public $vectortype$ shiftL(int s, VectorMask<$Boxtype$> m) { 959 return blend(shiftL(s), m); 960 } 961 962 @Override 963 @ForceInline 964 public $vectortype$ shiftR(int s) { 965 return VectorIntrinsics.broadcastInt( 966 VECTOR_OP_URSHIFT, $vectortype$.class, $type$.class, LENGTH, 967 this, s, 968 (v, i) -> v.uOp((__, a) -> ($type$) ((a & 0xFF) >>> (i & 7)))); 969 } 970 971 @Override 972 @ForceInline 973 public $vectortype$ shiftR(int s, VectorMask<$Boxtype$> m) { 974 return blend(shiftR(s), m); 975 } 976 977 @Override 978 @ForceInline 979 public $vectortype$ aShiftR(int s) { 980 return VectorIntrinsics.broadcastInt( 981 VECTOR_OP_RSHIFT, $vectortype$.class, $type$.class, LENGTH, 982 this, s, 983 (v, i) -> v.uOp((__, a) -> ($type$) (a >> (i & 7)))); 984 } 985 986 @Override 987 @ForceInline 988 public $vectortype$ aShiftR(int s, VectorMask<$Boxtype$> m) { 989 return blend(aShiftR(s), m); 990 } 991 #end[byte] 992 #if[short] 993 @Override 994 @ForceInline 995 public $vectortype$ shiftL(int s) { 996 return VectorIntrinsics.broadcastInt( 997 VECTOR_OP_LSHIFT, $vectortype$.class, $type$.class, LENGTH, 998 this, s, 999 (v, i) -> v.uOp((__, a) -> ($type$) (a << (i & 15)))); 1000 } 1001 1002 @Override 1003 @ForceInline 1004 public $vectortype$ shiftL(int s, VectorMask<$Boxtype$> m) { 1005 return blend(shiftL(s), m); 1006 } 1007 1008 @Override 1009 @ForceInline 1010 public $vectortype$ shiftR(int s) { 1011 return VectorIntrinsics.broadcastInt( 1012 VECTOR_OP_URSHIFT, $vectortype$.class, $type$.class, LENGTH, 1013 this, s, 1014 (v, i) -> v.uOp((__, a) -> ($type$) ((a & 0xFFFF) >>> (i & 15)))); 1015 } 1016 1017 @Override 1018 @ForceInline 1019 public $vectortype$ shiftR(int s, VectorMask<$Boxtype$> m) { 1020 return blend(shiftR(s), m); 1021 } 1022 1023 @Override 1024 @ForceInline 1025 public $vectortype$ aShiftR(int s) { 1026 return VectorIntrinsics.broadcastInt( 1027 VECTOR_OP_RSHIFT, $vectortype$.class, $type$.class, LENGTH, 1028 this, s, 1029 (v, i) -> v.uOp((__, a) -> ($type$) (a >> (i & 15)))); 1030 } 1031 1032 @Override 1033 @ForceInline 1034 public $vectortype$ aShiftR(int s, VectorMask<$Boxtype$> m) { 1035 return blend(aShiftR(s), m); 1036 } 1037 #end[short] 1038 #if[intOrLong] 1039 @Override 1040 @ForceInline 1041 public $vectortype$ shiftL(int s) { 1042 return VectorIntrinsics.broadcastInt( 1043 VECTOR_OP_LSHIFT, $vectortype$.class, $type$.class, LENGTH, 1044 this, s, 1045 (v, i) -> v.uOp((__, a) -> ($type$) (a << i))); 1046 } 1047 1048 @Override 1049 @ForceInline 1050 public $vectortype$ shiftL(int s, VectorMask<$Boxtype$> m) { 1051 return blend(shiftL(s), m); 1052 } 1053 1054 @Override 1055 @ForceInline 1056 public $vectortype$ shiftR(int s) { 1057 return VectorIntrinsics.broadcastInt( 1058 VECTOR_OP_URSHIFT, $vectortype$.class, $type$.class, LENGTH, 1059 this, s, 1060 (v, i) -> v.uOp((__, a) -> ($type$) (a >>> i))); 1061 } 1062 1063 @Override 1064 @ForceInline 1065 public $vectortype$ shiftR(int s, VectorMask<$Boxtype$> m) { 1066 return blend(shiftR(s), m); 1067 } 1068 1069 @Override 1070 @ForceInline 1071 public $vectortype$ aShiftR(int s) { 1072 return VectorIntrinsics.broadcastInt( 1073 VECTOR_OP_RSHIFT, $vectortype$.class, $type$.class, LENGTH, 1074 this, s, 1075 (v, i) -> v.uOp((__, a) -> ($type$) (a >> i))); 1076 } 1077 1078 @Override 1079 @ForceInline 1080 public $vectortype$ aShiftR(int s, VectorMask<$Boxtype$> m) { 1081 return blend(aShiftR(s), m); 1082 } 1083 1084 @Override 1085 @ForceInline 1086 public $vectortype$ shiftL(Vector<$Boxtype$> s) { 1087 $vectortype$ shiftv = ($vectortype$)s; 1088 // As per shift specification for Java, mask the shift count. 1089 shiftv = shiftv.and($abstractvectortype$.broadcast(SPECIES, {#if[int]?0x1f:0x3f})); 1090 return VectorIntrinsics.binaryOp( 1091 VECTOR_OP_LSHIFT, $vectortype$.class, $type$.class, LENGTH, 1092 this, shiftv, 1093 (v1, v2) -> v1.bOp(v2,(i,a, b) -> ($type$) (a << b))); 1094 } 1095 1096 @Override 1097 @ForceInline 1098 public $vectortype$ shiftR(Vector<$Boxtype$> s) { 1099 $vectortype$ shiftv = ($vectortype$)s; 1100 // As per shift specification for Java, mask the shift count. 1101 shiftv = shiftv.and($abstractvectortype$.broadcast(SPECIES, {#if[int]?0x1f:0x3f})); 1102 return VectorIntrinsics.binaryOp( 1103 VECTOR_OP_URSHIFT, $vectortype$.class, $type$.class, LENGTH, 1104 this, shiftv, 1105 (v1, v2) -> v1.bOp(v2,(i,a, b) -> ($type$) (a >>> b))); 1106 } 1107 1108 @Override 1109 @ForceInline 1110 public $vectortype$ aShiftR(Vector<$Boxtype$> s) { 1111 $vectortype$ shiftv = ($vectortype$)s; 1112 // As per shift specification for Java, mask the shift count. 1113 shiftv = shiftv.and($abstractvectortype$.broadcast(SPECIES, {#if[int]?0x1f:0x3f})); 1114 return VectorIntrinsics.binaryOp( 1115 VECTOR_OP_RSHIFT, $vectortype$.class, $type$.class, LENGTH, 1116 this, shiftv, 1117 (v1, v2) -> v1.bOp(v2,(i,a, b) -> ($type$) (a >> b))); 1118 } 1119 #end[intOrLong] 1120 // Ternary operations 1121 1122 #if[FP] 1123 @Override 1124 @ForceInline 1125 public $vectortype$ fma(Vector<$Boxtype$> o1, Vector<$Boxtype$> o2) { 1126 Objects.requireNonNull(o1); 1127 Objects.requireNonNull(o2); 1128 $vectortype$ v1 = ($vectortype$)o1; 1129 $vectortype$ v2 = ($vectortype$)o2; 1130 return VectorIntrinsics.ternaryOp( 1131 VECTOR_OP_FMA, $vectortype$.class, $type$.class, LENGTH, 1132 this, v1, v2, 1133 (w1, w2, w3) -> w1.tOp(w2, w3, (i, a, b, c) -> Math.fma(a, b, c))); 1134 } 1135 #end[FP] 1136 1137 // Type specific horizontal reductions 1138 #if[BITWISE] 1139 1140 @Override 1141 @ForceInline 1142 public $type$ addAll() { 1143 return ($type$) VectorIntrinsics.reductionCoerced( 1144 VECTOR_OP_ADD, $vectortype$.class, $type$.class, LENGTH, 1145 this, 1146 v -> (long) v.rOp(($type$) 0, (i, a, b) -> ($type$) (a + b))); 1147 } 1148 1149 @Override 1150 @ForceInline 1151 public $type$ andAll() { 1152 return ($type$) VectorIntrinsics.reductionCoerced( 1153 VECTOR_OP_AND, $vectortype$.class, $type$.class, LENGTH, 1154 this, 1155 v -> (long) v.rOp(($type$) -1, (i, a, b) -> ($type$) (a & b))); 1156 } 1157 1158 @Override 1159 @ForceInline 1160 public $type$ andAll(VectorMask<$Boxtype$> m) { 1161 return blend(($vectortype$)$abstractvectortype$.broadcast(SPECIES, ($type$) -1), m).andAll(); 1162 } 1163 1164 @Override 1165 @ForceInline 1166 public $type$ minAll() { 1167 return ($type$) VectorIntrinsics.reductionCoerced( 1168 VECTOR_OP_MIN, $vectortype$.class, $type$.class, LENGTH, 1169 this, 1170 v -> (long) v.rOp($Boxtype$.MAX_VALUE , (i, a, b) -> ($type$) Math.min(a, b))); 1171 } 1172 1173 @Override 1174 @ForceInline 1175 public $type$ maxAll() { 1176 return ($type$) VectorIntrinsics.reductionCoerced( 1177 VECTOR_OP_MAX, $vectortype$.class, $type$.class, LENGTH, 1178 this, 1179 v -> (long) v.rOp($Boxtype$.MIN_VALUE , (i, a, b) -> ($type$) Math.max(a, b))); 1180 } 1181 1182 @Override 1183 @ForceInline 1184 public $type$ mulAll() { 1185 return ($type$) VectorIntrinsics.reductionCoerced( 1186 VECTOR_OP_MUL, $vectortype$.class, $type$.class, LENGTH, 1187 this, 1188 v -> (long) v.rOp(($type$) 1, (i, a, b) -> ($type$) (a * b))); 1189 } 1190 1191 @Override 1192 @ForceInline 1193 public $type$ orAll() { 1194 return ($type$) VectorIntrinsics.reductionCoerced( 1195 VECTOR_OP_OR, $vectortype$.class, $type$.class, LENGTH, 1196 this, 1197 v -> (long) v.rOp(($type$) 0, (i, a, b) -> ($type$) (a | b))); 1198 } 1199 1200 @Override 1201 @ForceInline 1202 public $type$ orAll(VectorMask<$Boxtype$> m) { 1203 return blend(($vectortype$)$abstractvectortype$.broadcast(SPECIES, ($type$) 0), m).orAll(); 1204 } 1205 1206 @Override 1207 @ForceInline 1208 public $type$ xorAll() { 1209 return ($type$) VectorIntrinsics.reductionCoerced( 1210 VECTOR_OP_XOR, $vectortype$.class, $type$.class, LENGTH, 1211 this, 1212 v -> (long) v.rOp(($type$) 0, (i, a, b) -> ($type$) (a ^ b))); 1213 } 1214 1215 @Override 1216 @ForceInline 1217 public $type$ xorAll(VectorMask<$Boxtype$> m) { 1218 return blend(($vectortype$)$abstractvectortype$.broadcast(SPECIES, ($type$) 0), m).xorAll(); 1219 } 1220 #end[BITWISE] 1221 1222 #if[FP] 1223 @Override 1224 @ForceInline 1225 public $type$ addAll() { 1226 $bitstype$ bits = ($bitstype$) VectorIntrinsics.reductionCoerced( 1227 VECTOR_OP_ADD, $vectortype$.class, $type$.class, LENGTH, 1228 this, 1229 v -> { 1230 $type$ r = v.rOp(($type$) 0, (i, a, b) -> ($type$) (a + b)); 1231 return (long)$Type$.$type$To$Bitstype$Bits(r); 1232 }); 1233 return $Type$.$bitstype$BitsTo$Fptype$(bits); 1234 } 1235 1236 @Override 1237 @ForceInline 1238 public $type$ mulAll() { 1239 $bitstype$ bits = ($bitstype$) VectorIntrinsics.reductionCoerced( 1240 VECTOR_OP_MUL, $vectortype$.class, $type$.class, LENGTH, 1241 this, 1242 v -> { 1243 $type$ r = v.rOp(($type$) 1, (i, a, b) -> ($type$) (a * b)); 1244 return (long)$Type$.$type$To$Bitstype$Bits(r); 1245 }); 1246 return $Type$.$bitstype$BitsTo$Fptype$(bits); 1247 } 1248 1249 @Override 1250 @ForceInline 1251 public $type$ minAll() { 1252 $bitstype$ bits = ($bitstype$) VectorIntrinsics.reductionCoerced( 1253 VECTOR_OP_MIN, $vectortype$.class, $type$.class, LENGTH, 1254 this, 1255 v -> { 1256 $type$ r = v.rOp($Boxtype$.POSITIVE_INFINITY , (i, a, b) -> ($type$) Math.min(a, b)); 1257 return (long)$Type$.$type$To$Bitstype$Bits(r); 1258 }); 1259 return $Type$.$bitstype$BitsTo$Fptype$(bits); 1260 } 1261 1262 @Override 1263 @ForceInline 1264 public $type$ maxAll() { 1265 $bitstype$ bits = ($bitstype$) VectorIntrinsics.reductionCoerced( 1266 VECTOR_OP_MAX, $vectortype$.class, $type$.class, LENGTH, 1267 this, 1268 v -> { 1269 $type$ r = v.rOp($Boxtype$.NEGATIVE_INFINITY, (i, a, b) -> ($type$) Math.max(a, b)); 1270 return (long)$Type$.$type$To$Bitstype$Bits(r); 1271 }); 1272 return $Type$.$bitstype$BitsTo$Fptype$(bits); 1273 } 1274 1275 #end[FP] 1276 1277 @Override 1278 @ForceInline 1279 public $type$ addAll(VectorMask<$Boxtype$> m) { 1280 return blend(($vectortype$)$abstractvectortype$.broadcast(SPECIES, ($type$) 0), m).addAll(); 1281 } 1282 1283 1284 @Override 1285 @ForceInline 1286 public $type$ mulAll(VectorMask<$Boxtype$> m) { 1287 return blend(($vectortype$)$abstractvectortype$.broadcast(SPECIES, ($type$) 1), m).mulAll(); 1288 } 1289 1290 @Override 1291 @ForceInline 1292 public $type$ minAll(VectorMask<$Boxtype$> m) { 1293 return blend(($vectortype$)$abstractvectortype$.broadcast(SPECIES, $Boxtype$.MAX_VALUE), m).minAll(); 1294 } 1295 1296 @Override 1297 @ForceInline 1298 public $type$ maxAll(VectorMask<$Boxtype$> m) { 1299 return blend(($vectortype$)$abstractvectortype$.broadcast(SPECIES, $Boxtype$.MIN_VALUE), m).maxAll(); 1300 } 1301 1302 @Override 1303 @ForceInline 1304 public VectorShuffle<$Boxtype$> toShuffle() { 1305 $type$[] a = toArray(); 1306 int[] sa = new int[a.length]; 1307 for (int i = 0; i < a.length; i++) { 1308 sa[i] = (int) a[i]; 1309 } 1310 return VectorShuffle.fromArray(SPECIES, sa, 0); 1311 } 1312 1313 // Memory operations 1314 1315 private static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_$TYPE$_INDEX_SCALE); 1316 private static final int BOOLEAN_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BOOLEAN_INDEX_SCALE); 1317 1318 @Override 1319 @ForceInline 1320 public void intoArray($type$[] a, int ix) { 1321 Objects.requireNonNull(a); 1322 ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH); 1323 VectorIntrinsics.store($vectortype$.class, $type$.class, LENGTH, 1324 a, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_$TYPE$_BASE_OFFSET, 1325 this, 1326 a, ix, 1327 (arr, idx, v) -> v.forEach((i, e) -> arr[idx + i] = e)); 1328 } 1329 1330 @Override 1331 @ForceInline 1332 public final void intoArray($type$[] a, int ax, VectorMask<$Boxtype$> m) { 1333 $abstractvectortype$ oldVal = $abstractvectortype$.fromArray(SPECIES, a, ax); 1334 $abstractvectortype$ newVal = oldVal.blend(this, m); 1335 newVal.intoArray(a, ax); 1336 } 1337 #if[!byteOrShort] 1338 @Override 1339 @ForceInline 1340 public void intoArray($type$[] a, int ix, int[] b, int iy) { 1341 #if[longOrDouble64] 1342 this.intoArray(a, ix + b[iy]); 1343 #else[longOrDouble64] 1344 Objects.requireNonNull(a); 1345 Objects.requireNonNull(b); 1346 1347 // Index vector: vix[0:n] = i -> ix + indexMap[iy + i] 1348 IntVector vix = IntVector.fromArray(INDEX_SPECIES, b, iy).add(ix); 1349 1350 vix = VectorIntrinsics.checkIndex(vix, a.length); 1351 1352 VectorIntrinsics.storeWithMap($vectortype$.class, $type$.class, LENGTH, $vectorindextype$, 1353 a, Unsafe.ARRAY_$TYPE$_BASE_OFFSET, vix, 1354 this, 1355 a, ix, b, iy, 1356 (arr, idx, v, indexMap, idy) -> v.forEach((i, e) -> arr[idx+indexMap[idy+i]] = e)); 1357 #end[longOrDouble64] 1358 } 1359 1360 @Override 1361 @ForceInline 1362 public final void intoArray($type$[] a, int ax, VectorMask<$Boxtype$> m, int[] b, int iy) { 1363 // @@@ This can result in out of bounds errors for unset mask lanes 1364 $abstractvectortype$ oldVal = $abstractvectortype$.fromArray(SPECIES, a, ax, b, iy); 1365 $abstractvectortype$ newVal = oldVal.blend(this, m); 1366 newVal.intoArray(a, ax, b, iy); 1367 } 1368 #end[!byteOrShort] 1369 1370 @Override 1371 @ForceInline 1372 public void intoByteArray(byte[] a, int ix) { 1373 Objects.requireNonNull(a); 1374 ix = VectorIntrinsics.checkIndex(ix, a.length, bitSize() / Byte.SIZE); 1375 VectorIntrinsics.store($vectortype$.class, $type$.class, LENGTH, 1376 a, ((long) ix) + Unsafe.ARRAY_BYTE_BASE_OFFSET, 1377 this, 1378 a, ix, 1379 (c, idx, v) -> { 1380 ByteBuffer bbc = ByteBuffer.wrap(c, idx, c.length - idx).order(ByteOrder.nativeOrder()); 1381 $Type$Buffer tb = bbc{#if[byte]?;:.as$Type$Buffer();} 1382 v.forEach((i, e) -> tb.put(e)); 1383 }); 1384 } 1385 1386 @Override 1387 @ForceInline 1388 public final void intoByteArray(byte[] a, int ix, VectorMask<$Boxtype$> m) { 1389 $vectortype$ oldVal = ($vectortype$) $abstractvectortype$.fromByteArray(SPECIES, a, ix); 1390 $vectortype$ newVal = oldVal.blend(this, m); 1391 newVal.intoByteArray(a, ix); 1392 } 1393 1394 @Override 1395 @ForceInline 1396 public void intoByteBuffer(ByteBuffer bb, int ix) { 1397 if (bb.order() != ByteOrder.nativeOrder()) { 1398 throw new IllegalArgumentException(); 1399 } 1400 if (bb.isReadOnly()) { 1401 throw new ReadOnlyBufferException(); 1402 } 1403 ix = VectorIntrinsics.checkIndex(ix, bb.limit(), bitSize() / Byte.SIZE); 1404 VectorIntrinsics.store($vectortype$.class, $type$.class, LENGTH, 1405 U.getReference(bb, BYTE_BUFFER_HB), ix + U.getLong(bb, BUFFER_ADDRESS), 1406 this, 1407 bb, ix, 1408 (c, idx, v) -> { 1409 ByteBuffer bbc = c.duplicate().position(idx).order(ByteOrder.nativeOrder()); 1410 $Type$Buffer tb = bbc{#if[byte]?;:.as$Type$Buffer();} 1411 v.forEach((i, e) -> tb.put(e)); 1412 }); 1413 } 1414 1415 @Override 1416 @ForceInline 1417 public void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<$Boxtype$> m) { 1418 $vectortype$ oldVal = ($vectortype$) $abstractvectortype$.fromByteBuffer(SPECIES, bb, ix); 1419 $vectortype$ newVal = oldVal.blend(this, m); 1420 newVal.intoByteBuffer(bb, ix); 1421 } 1422 1423 // 1424 1425 @Override 1426 public String toString() { 1427 return Arrays.toString(getElements()); 1428 } 1429 1430 @Override 1431 public boolean equals(Object o) { 1432 if (this == o) return true; 1433 if (o == null || this.getClass() != o.getClass()) return false; 1434 1435 $vectortype$ that = ($vectortype$) o; 1436 return this.equal(that).allTrue(); 1437 } 1438 1439 @Override 1440 public int hashCode() { 1441 return Arrays.hashCode(vec); 1442 } 1443 1444 // Binary test 1445 1446 @Override 1447 $masktype$ bTest(Vector<$Boxtype$> o, FBinTest f) { 1448 $type$[] vec1 = getElements(); 1449 $type$[] vec2 = (($vectortype$)o).getElements(); 1450 boolean[] bits = new boolean[length()]; 1451 for (int i = 0; i < length(); i++){ 1452 bits[i] = f.apply(i, vec1[i], vec2[i]); 1453 } 1454 return new $masktype$(bits); 1455 } 1456 1457 // Comparisons 1458 1459 @Override 1460 @ForceInline 1461 public $masktype$ equal(Vector<$Boxtype$> o) { 1462 Objects.requireNonNull(o); 1463 $vectortype$ v = ($vectortype$)o; 1464 1465 return VectorIntrinsics.compare( 1466 BT_eq, $vectortype$.class, $masktype$.class, $type$.class, LENGTH, 1467 this, v, 1468 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a == b)); 1469 } 1470 1471 @Override 1472 @ForceInline 1473 public $masktype$ notEqual(Vector<$Boxtype$> o) { 1474 Objects.requireNonNull(o); 1475 $vectortype$ v = ($vectortype$)o; 1476 1477 return VectorIntrinsics.compare( 1478 BT_ne, $vectortype$.class, $masktype$.class, $type$.class, LENGTH, 1479 this, v, 1480 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a != b)); 1481 } 1482 1483 @Override 1484 @ForceInline 1485 public $masktype$ lessThan(Vector<$Boxtype$> o) { 1486 Objects.requireNonNull(o); 1487 $vectortype$ v = ($vectortype$)o; 1488 1489 return VectorIntrinsics.compare( 1490 BT_lt, $vectortype$.class, $masktype$.class, $type$.class, LENGTH, 1491 this, v, 1492 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a < b)); 1493 } 1494 1495 @Override 1496 @ForceInline 1497 public $masktype$ lessThanEq(Vector<$Boxtype$> o) { 1498 Objects.requireNonNull(o); 1499 $vectortype$ v = ($vectortype$)o; 1500 1501 return VectorIntrinsics.compare( 1502 BT_le, $vectortype$.class, $masktype$.class, $type$.class, LENGTH, 1503 this, v, 1504 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a <= b)); 1505 } 1506 1507 @Override 1508 @ForceInline 1509 public $masktype$ greaterThan(Vector<$Boxtype$> o) { 1510 Objects.requireNonNull(o); 1511 $vectortype$ v = ($vectortype$)o; 1512 1513 return ($masktype$) VectorIntrinsics.compare( 1514 BT_gt, $vectortype$.class, $masktype$.class, $type$.class, LENGTH, 1515 this, v, 1516 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a > b)); 1517 } 1518 1519 @Override 1520 @ForceInline 1521 public $masktype$ greaterThanEq(Vector<$Boxtype$> o) { 1522 Objects.requireNonNull(o); 1523 $vectortype$ v = ($vectortype$)o; 1524 1525 return VectorIntrinsics.compare( 1526 BT_ge, $vectortype$.class, $masktype$.class, $type$.class, LENGTH, 1527 this, v, 1528 (v1, v2) -> v1.bTest(v2, (i, a, b) -> a >= b)); 1529 } 1530 1531 // Foreach 1532 1533 @Override 1534 void forEach(FUnCon f) { 1535 $type$[] vec = getElements(); 1536 for (int i = 0; i < length(); i++) { 1537 f.apply(i, vec[i]); 1538 } 1539 } 1540 1541 @Override 1542 void forEach(VectorMask<$Boxtype$> o, FUnCon f) { 1543 boolean[] mbits = (($masktype$)o).getBits(); 1544 forEach((i, a) -> { 1545 if (mbits[i]) { f.apply(i, a); } 1546 }); 1547 } 1548 1549 #if[FP] 1550 $bitsvectortype$ toBits() { 1551 $type$[] vec = getElements(); 1552 $bitstype$[] res = new $bitstype$[this.species().length()]; 1553 for(int i = 0; i < this.species().length(); i++){ 1554 res[i] = $Type$.$type$To$Bitstype$Bits(vec[i]); 1555 } 1556 return new $bitsvectortype$(res); 1557 } 1558 #end[FP] 1559 1560 #if[intOrLong] 1561 $fpvectortype$ toFP() { 1562 $type$[] vec = getElements(); 1563 $fptype$[] res = new $fptype$[this.species().length()]; 1564 for(int i = 0; i < this.species().length(); i++){ 1565 res[i] = $Boxfptype$.$bitstype$BitsTo$Fptype$(vec[i]); 1566 } 1567 return new $fpvectortype$(res); 1568 } 1569 #end[intOrLong] 1570 1571 @Override 1572 public $vectortype$ rotateEL(int j) { 1573 $type$[] vec = getElements(); 1574 $type$[] res = new $type$[length()]; 1575 for (int i = 0; i < length(); i++){ 1576 res[(j + i) % length()] = vec[i]; 1577 } 1578 return new $vectortype$(res); 1579 } 1580 1581 @Override 1582 public $vectortype$ rotateER(int j) { 1583 $type$[] vec = getElements(); 1584 $type$[] res = new $type$[length()]; 1585 for (int i = 0; i < length(); i++){ 1586 int z = i - j; 1587 if(j < 0) { 1588 res[length() + z] = vec[i]; 1589 } else { 1590 res[z] = vec[i]; 1591 } 1592 } 1593 return new $vectortype$(res); 1594 } 1595 1596 @Override 1597 public $vectortype$ shiftEL(int j) { 1598 $type$[] vec = getElements(); 1599 $type$[] res = new $type$[length()]; 1600 for (int i = 0; i < length() - j; i++) { 1601 res[i] = vec[i + j]; 1602 } 1603 return new $vectortype$(res); 1604 } 1605 1606 @Override 1607 public $vectortype$ shiftER(int j) { 1608 $type$[] vec = getElements(); 1609 $type$[] res = new $type$[length()]; 1610 for (int i = 0; i < length() - j; i++){ 1611 res[i + j] = vec[i]; 1612 } 1613 return new $vectortype$(res); 1614 } 1615 1616 @Override 1617 @ForceInline 1618 public $vectortype$ rearrange(Vector<$Boxtype$> v, 1619 VectorShuffle<$Boxtype$> s, VectorMask<$Boxtype$> m) { 1620 return this.rearrange(s).blend(v.rearrange(s), m); 1621 } 1622 1623 @Override 1624 @ForceInline 1625 public $vectortype$ rearrange(VectorShuffle<$Boxtype$> o1) { 1626 Objects.requireNonNull(o1); 1627 $shuffletype$ s = ($shuffletype$)o1; 1628 1629 return VectorIntrinsics.rearrangeOp( 1630 $vectortype$.class, $shuffletype$.class, $type$.class, LENGTH, 1631 this, s, 1632 (v1, s_) -> v1.uOp((i, a) -> { 1633 int ei = s_.lane(i); 1634 return v1.lane(ei); 1635 })); 1636 } 1637 1638 @Override 1639 @ForceInline 1640 public $vectortype$ blend(Vector<$Boxtype$> o1, VectorMask<$Boxtype$> o2) { 1641 Objects.requireNonNull(o1); 1642 Objects.requireNonNull(o2); 1643 $vectortype$ v = ($vectortype$)o1; 1644 $masktype$ m = ($masktype$)o2; 1645 1646 return VectorIntrinsics.blend( 1647 $vectortype$.class, $masktype$.class, $type$.class, LENGTH, 1648 this, v, m, 1649 (v1, v2, m_) -> v1.bOp(v2, (i, a, b) -> m_.lane(i) ? b : a)); 1650 } 1651 1652 // Accessors 1653 1654 #if[FP] 1655 @Override 1656 public $type$ lane(int i) { 1657 if (i < 0 || i >= LENGTH) { 1658 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH); 1659 } 1660 $bitstype$ bits = ($bitstype$) VectorIntrinsics.extract( 1661 $vectortype$.class, $type$.class, LENGTH, 1662 this, i, 1663 (vec, ix) -> { 1664 $type$[] vecarr = vec.getElements(); 1665 return (long)$Type$.$type$To$Bitstype$Bits(vecarr[ix]); 1666 }); 1667 return $Type$.$bitstype$BitsTo$Fptype$(bits); 1668 } 1669 1670 @Override 1671 public $vectortype$ with(int i, $type$ e) { 1672 if (i < 0 || i >= LENGTH) { 1673 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH); 1674 } 1675 return VectorIntrinsics.insert( 1676 $vectortype$.class, $type$.class, LENGTH, 1677 this, i, (long)$Type$.$type$To$Bitstype$Bits(e), 1678 (v, ix, bits) -> { 1679 $type$[] res = v.getElements().clone(); 1680 res[ix] = $Type$.$bitstype$BitsTo$Type$(($bitstype$)bits); 1681 return new $vectortype$(res); 1682 }); 1683 } 1684 #else[FP] 1685 @Override 1686 public $type$ lane(int i) { 1687 if (i < 0 || i >= LENGTH) { 1688 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH); 1689 } 1690 return ($type$) VectorIntrinsics.extract( 1691 $vectortype$.class, $type$.class, LENGTH, 1692 this, i, 1693 (vec, ix) -> { 1694 $type$[] vecarr = vec.getElements(); 1695 return (long)vecarr[ix]; 1696 }); 1697 } 1698 1699 @Override 1700 public $vectortype$ with(int i, $type$ e) { 1701 if (i < 0 || i >= LENGTH) { 1702 throw new IllegalArgumentException("Index " + i + " must be zero or positive, and less than " + LENGTH); 1703 } 1704 return VectorIntrinsics.insert( 1705 $vectortype$.class, $type$.class, LENGTH, 1706 this, i, (long)e, 1707 (v, ix, bits) -> { 1708 $type$[] res = v.getElements().clone(); 1709 res[ix] = ($type$)bits; 1710 return new $vectortype$(res); 1711 }); 1712 } 1713 #end[FP] 1714 1715 // Mask 1716 1717 static final class $masktype$ extends AbstractMask<$Boxtype$> { 1718 static final $masktype$ TRUE_MASK = new $masktype$(true); 1719 static final $masktype$ FALSE_MASK = new $masktype$(false); 1720 1721 private final boolean[] bits; // Don't access directly, use getBits() instead. 1722 1723 public $masktype$(boolean[] bits) { 1724 this(bits, 0); 1725 } 1726 1727 public $masktype$(boolean[] bits, int offset) { 1728 boolean[] a = new boolean[species().length()]; 1729 for (int i = 0; i < a.length; i++) { 1730 a[i] = bits[offset + i]; 1731 } 1732 this.bits = a; 1733 } 1734 1735 public $masktype$(boolean val) { 1736 boolean[] bits = new boolean[species().length()]; 1737 Arrays.fill(bits, val); 1738 this.bits = bits; 1739 } 1740 1741 boolean[] getBits() { 1742 return VectorIntrinsics.maybeRebox(this).bits; 1743 } 1744 1745 @Override 1746 $masktype$ uOp(MUnOp f) { 1747 boolean[] res = new boolean[species().length()]; 1748 boolean[] bits = getBits(); 1749 for (int i = 0; i < species().length(); i++) { 1750 res[i] = f.apply(i, bits[i]); 1751 } 1752 return new $masktype$(res); 1753 } 1754 1755 @Override 1756 $masktype$ bOp(VectorMask<$Boxtype$> o, MBinOp f) { 1757 boolean[] res = new boolean[species().length()]; 1758 boolean[] bits = getBits(); 1759 boolean[] mbits = (($masktype$)o).getBits(); 1760 for (int i = 0; i < species().length(); i++) { 1761 res[i] = f.apply(i, bits[i], mbits[i]); 1762 } 1763 return new $masktype$(res); 1764 } 1765 1766 @Override 1767 public VectorSpecies<$Boxtype$> species() { 1768 return SPECIES; 1769 } 1770 1771 @Override 1772 public $vectortype$ toVector() { 1773 $type$[] res = new $type$[species().length()]; 1774 boolean[] bits = getBits(); 1775 for (int i = 0; i < species().length(); i++) { 1776 // -1 will result in the most significant bit being set in 1777 // addition to some or all other bits 1778 res[i] = ($type$) (bits[i] ? -1 : 0); 1779 } 1780 return new $vectortype$(res); 1781 } 1782 1783 @Override 1784 @ForceInline 1785 @SuppressWarnings("unchecked") 1786 public <E> VectorMask<E> cast(VectorSpecies<E> species) { 1787 if (length() != species.length()) 1788 throw new IllegalArgumentException("VectorMask length and species length differ"); 1789 Class<?> stype = species.elementType(); 1790 boolean [] maskArray = toArray(); 1791 if (stype == byte.class) { 1792 return (VectorMask <E>) new Byte$bits$Vector.Byte$bits$Mask(maskArray); 1793 } else if (stype == short.class) { 1794 return (VectorMask <E>) new Short$bits$Vector.Short$bits$Mask(maskArray); 1795 } else if (stype == int.class) { 1796 return (VectorMask <E>) new Int$bits$Vector.Int$bits$Mask(maskArray); 1797 } else if (stype == long.class) { 1798 return (VectorMask <E>) new Long$bits$Vector.Long$bits$Mask(maskArray); 1799 } else if (stype == float.class) { 1800 return (VectorMask <E>) new Float$bits$Vector.Float$bits$Mask(maskArray); 1801 } else if (stype == double.class) { 1802 return (VectorMask <E>) new Double$bits$Vector.Double$bits$Mask(maskArray); 1803 } else { 1804 throw new UnsupportedOperationException("Bad lane type for casting."); 1805 } 1806 } 1807 1808 // Unary operations 1809 1810 @Override 1811 @ForceInline 1812 public $masktype$ not() { 1813 return ($masktype$) VectorIntrinsics.unaryOp( 1814 VECTOR_OP_NOT, $masktype$.class, $bitstype$.class, LENGTH, 1815 this, 1816 (m1) -> m1.uOp((i, a) -> !a)); 1817 } 1818 1819 // Binary operations 1820 1821 @Override 1822 @ForceInline 1823 public $masktype$ and(VectorMask<$Boxtype$> o) { 1824 Objects.requireNonNull(o); 1825 $masktype$ m = ($masktype$)o; 1826 return VectorIntrinsics.binaryOp(VECTOR_OP_AND, $masktype$.class, $bitstype$.class, LENGTH, 1827 this, m, 1828 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a & b)); 1829 } 1830 1831 @Override 1832 @ForceInline 1833 public $masktype$ or(VectorMask<$Boxtype$> o) { 1834 Objects.requireNonNull(o); 1835 $masktype$ m = ($masktype$)o; 1836 return VectorIntrinsics.binaryOp(VECTOR_OP_OR, $masktype$.class, $bitstype$.class, LENGTH, 1837 this, m, 1838 (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b)); 1839 } 1840 1841 // Reductions 1842 1843 @Override 1844 @ForceInline 1845 public boolean anyTrue() { 1846 return VectorIntrinsics.test(BT_ne, $masktype$.class, $bitstype$.class, LENGTH, 1847 this, this, 1848 (m, __) -> anyTrueHelper((($masktype$)m).getBits())); 1849 } 1850 1851 @Override 1852 @ForceInline 1853 public boolean allTrue() { 1854 return VectorIntrinsics.test(BT_overflow, $masktype$.class, $bitstype$.class, LENGTH, 1855 this, VectorMask.maskAllTrue(species()), 1856 (m, __) -> allTrueHelper((($masktype$)m).getBits())); 1857 } 1858 } 1859 1860 // Shuffle 1861 1862 static final class $shuffletype$ extends AbstractShuffle<$Boxtype$> { 1863 $shuffletype$(byte[] reorder) { 1864 super(reorder); 1865 } 1866 1867 public $shuffletype$(int[] reorder) { 1868 super(reorder); 1869 } 1870 1871 public $shuffletype$(int[] reorder, int i) { 1872 super(reorder, i); 1873 } 1874 1875 public $shuffletype$(IntUnaryOperator f) { 1876 super(f); 1877 } 1878 1879 @Override 1880 public VectorSpecies<$Boxtype$> species() { 1881 return SPECIES; 1882 } 1883 1884 @Override 1885 public $abstractvectortype$ toVector() { 1886 $type$[] va = new $type$[SPECIES.length()]; 1887 for (int i = 0; i < va.length; i++) { 1888 va[i] = ($type$) lane(i); 1889 } 1890 return $abstractvectortype$.fromArray(SPECIES, va, 0); 1891 } 1892 1893 @Override 1894 @ForceInline 1895 @SuppressWarnings("unchecked") 1896 public <F> VectorShuffle<F> cast(VectorSpecies<F> species) { 1897 if (length() != species.length()) 1898 throw new IllegalArgumentException("Shuffle length and species length differ"); 1899 Class<?> stype = species.elementType(); 1900 int [] shuffleArray = toArray(); 1901 if (stype == byte.class) { 1902 return (VectorShuffle<F>) new Byte$bits$Vector.Byte$bits$Shuffle(shuffleArray); 1903 } else if (stype == short.class) { 1904 return (VectorShuffle<F>) new Short$bits$Vector.Short$bits$Shuffle(shuffleArray); 1905 } else if (stype == int.class) { 1906 return (VectorShuffle<F>) new Int$bits$Vector.Int$bits$Shuffle(shuffleArray); 1907 } else if (stype == long.class) { 1908 return (VectorShuffle<F>) new Long$bits$Vector.Long$bits$Shuffle(shuffleArray); 1909 } else if (stype == float.class) { 1910 return (VectorShuffle<F>) new Float$bits$Vector.Float$bits$Shuffle(shuffleArray); 1911 } else if (stype == double.class) { 1912 return (VectorShuffle<F>) new Double$bits$Vector.Double$bits$Shuffle(shuffleArray); 1913 } else { 1914 throw new UnsupportedOperationException("Bad lane type for casting."); 1915 } 1916 } 1917 1918 @Override 1919 public $shuffletype$ rearrange(VectorShuffle<$Boxtype$> o) { 1920 $shuffletype$ s = ($shuffletype$) o; 1921 byte[] r = new byte[reorder.length]; 1922 for (int i = 0; i < reorder.length; i++) { 1923 r[i] = reorder[s.reorder[i]]; 1924 } 1925 return new $shuffletype$(r); 1926 } 1927 } 1928 1929 // VectorSpecies 1930 1931 @Override 1932 public VectorSpecies<$Boxtype$> species() { 1933 return SPECIES; 1934 } 1935 }