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.ShortBuffer;
  29 import java.nio.ByteOrder;
  30 import java.util.Objects;
  31 import java.util.function.IntUnaryOperator;
  32 import java.util.function.Function;
  33 import java.util.concurrent.ThreadLocalRandom;
  34 
  35 import jdk.internal.misc.Unsafe;
  36 import jdk.internal.vm.annotation.ForceInline;
  37 import static jdk.incubator.vector.VectorIntrinsics.*;
  38 
  39 
  40 /**
  41  * A specialized {@link Vector} representing an ordered immutable sequence of
  42  * {@code short} values.
  43  */
  44 @SuppressWarnings("cast")
  45 public abstract class ShortVector extends Vector<Short> {
  46 
  47     ShortVector() {}
  48 
  49     private static final int ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_SHORT_INDEX_SCALE);
  50 
  51     // Unary operator
  52 
  53     interface FUnOp {
  54         short apply(int i, short a);
  55     }
  56 
  57     abstract ShortVector uOp(FUnOp f);
  58 
  59     abstract ShortVector uOp(VectorMask<Short> m, FUnOp f);
  60 
  61     // Binary operator
  62 
  63     interface FBinOp {
  64         short apply(int i, short a, short b);
  65     }
  66 
  67     abstract ShortVector bOp(Vector<Short> v, FBinOp f);
  68 
  69     abstract ShortVector bOp(Vector<Short> v, VectorMask<Short> m, FBinOp f);
  70 
  71     // Trinary operator
  72 
  73     interface FTriOp {
  74         short apply(int i, short a, short b, short c);
  75     }
  76 
  77     abstract ShortVector tOp(Vector<Short> v1, Vector<Short> v2, FTriOp f);
  78 
  79     abstract ShortVector tOp(Vector<Short> v1, Vector<Short> v2, VectorMask<Short> m, FTriOp f);
  80 
  81     // Reduction operator
  82 
  83     abstract short rOp(short v, FBinOp f);
  84 
  85     // Binary test
  86 
  87     interface FBinTest {
  88         boolean apply(int i, short a, short b);
  89     }
  90 
  91     abstract VectorMask<Short> bTest(Vector<Short> v, FBinTest f);
  92 
  93     // Foreach
  94 
  95     interface FUnCon {
  96         void apply(int i, short a);
  97     }
  98 
  99     abstract void forEach(FUnCon f);
 100 
 101     abstract void forEach(VectorMask<Short> m, FUnCon f);
 102 
 103     // Static factories
 104 
 105     /**
 106      * Returns a vector where all lane elements are set to the default
 107      * primitive value.
 108      *
 109      * @param species species of desired vector
 110      * @return a zero vector of given species
 111      */
 112     @ForceInline
 113     @SuppressWarnings("unchecked")
 114     public static ShortVector zero(VectorSpecies<Short> species) {
 115         return VectorIntrinsics.broadcastCoerced((Class<ShortVector>) species.vectorType(), short.class, species.length(),
 116                                                  0, species,
 117                                                  ((bits, s) -> ((ShortSpecies)s).op(i -> (short)bits)));
 118     }
 119 
 120     /**
 121      * Loads a vector from a byte array starting at an offset.
 122      * <p>
 123      * Bytes are composed into primitive lane elements according to the
 124      * native byte order of the underlying platform
 125      * <p>
 126      * This method behaves as if it returns the result of calling the
 127      * byte buffer, offset, and mask accepting
 128      * {@link #fromByteBuffer(VectorSpecies, ByteBuffer, int, VectorMask) method} as follows:
 129      * <pre>{@code
 130      * return fromByteBuffer(species, ByteBuffer.wrap(a), offset, VectorMask.allTrue());
 131      * }</pre>
 132      *
 133      * @param species species of desired vector
 134      * @param a the byte array
 135      * @param offset the offset into the array
 136      * @return a vector loaded from a byte array
 137      * @throws IndexOutOfBoundsException if {@code i < 0} or
 138      * {@code offset > a.length - (species.length() * species.elementSize() / Byte.SIZE)}
 139      */
 140     @ForceInline
 141     @SuppressWarnings("unchecked")
 142     public static ShortVector fromByteArray(VectorSpecies<Short> species, byte[] a, int offset) {
 143         Objects.requireNonNull(a);
 144         offset = VectorIntrinsics.checkIndex(offset, a.length, species.bitSize() / Byte.SIZE);
 145         return VectorIntrinsics.load((Class<ShortVector>) species.vectorType(), short.class, species.length(),
 146                                      a, ((long) offset) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
 147                                      a, offset, species,
 148                                      (c, idx, s) -> {
 149                                          ByteBuffer bbc = ByteBuffer.wrap(c, idx, c.length - idx).order(ByteOrder.nativeOrder());
 150                                          ShortBuffer tb = bbc.asShortBuffer();
 151                                          return ((ShortSpecies)s).op(i -> tb.get());
 152                                      });
 153     }
 154 
 155     /**
 156      * Loads a vector from a byte array starting at an offset and using a
 157      * mask.
 158      * <p>
 159      * Bytes are composed into primitive lane elements according to the
 160      * native byte order of the underlying platform.
 161      * <p>
 162      * This method behaves as if it returns the result of calling the
 163      * byte buffer, offset, and mask accepting
 164      * {@link #fromByteBuffer(VectorSpecies, ByteBuffer, int, VectorMask) method} as follows:
 165      * <pre>{@code
 166      * return fromByteBuffer(species, ByteBuffer.wrap(a), offset, m);
 167      * }</pre>
 168      *
 169      * @param species species of desired vector
 170      * @param a the byte array
 171      * @param offset the offset into the array
 172      * @param m the mask
 173      * @return a vector loaded from a byte array
 174      * @throws IndexOutOfBoundsException if {@code offset < 0} or
 175      * for any vector lane index {@code N} where the mask at lane {@code N}
 176      * is set
 177      * {@code offset >= a.length - (N * species.elementSize() / Byte.SIZE)}
 178      */
 179     @ForceInline
 180     public static ShortVector fromByteArray(VectorSpecies<Short> species, byte[] a, int offset, VectorMask<Short> m) {
 181         return zero(species).blend(fromByteArray(species, a, offset), m);
 182     }
 183 
 184     /**
 185      * Loads a vector from an array starting at offset.
 186      * <p>
 187      * For each vector lane, where {@code N} is the vector lane index, the
 188      * array element at index {@code offset + N} is placed into the
 189      * resulting vector at lane index {@code N}.
 190      *
 191      * @param species species of desired vector
 192      * @param a the array
 193      * @param offset the offset into the array
 194      * @return the vector loaded from an array
 195      * @throws IndexOutOfBoundsException if {@code offset < 0}, or
 196      * {@code offset > a.length - species.length()}
 197      */
 198     @ForceInline
 199     @SuppressWarnings("unchecked")
 200     public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset){
 201         Objects.requireNonNull(a);
 202         offset = VectorIntrinsics.checkIndex(offset, a.length, species.length());
 203         return VectorIntrinsics.load((Class<ShortVector>) species.vectorType(), short.class, species.length(),
 204                                      a, (((long) offset) << ARRAY_SHIFT) + Unsafe.ARRAY_SHORT_BASE_OFFSET,
 205                                      a, offset, species,
 206                                      (c, idx, s) -> ((ShortSpecies)s).op(n -> c[idx + n]));
 207     }
 208 
 209 
 210     /**
 211      * Loads a vector from an array starting at offset and using a mask.
 212      * <p>
 213      * For each vector lane, where {@code N} is the vector lane index,
 214      * if the mask lane at index {@code N} is set then the array element at
 215      * index {@code offset + N} is placed into the resulting vector at lane index
 216      * {@code N}, otherwise the default element value is placed into the
 217      * resulting vector at lane index {@code N}.
 218      *
 219      * @param species species of desired vector
 220      * @param a the array
 221      * @param offset the offset into the array
 222      * @param m the mask
 223      * @return the vector loaded from an array
 224      * @throws IndexOutOfBoundsException if {@code offset < 0}, or
 225      * for any vector lane index {@code N} where the mask at lane {@code N}
 226      * is set {@code offset > a.length - N}
 227      */
 228     @ForceInline
 229     public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset, VectorMask<Short> m) {
 230         return zero(species).blend(fromArray(species, a, offset), m);
 231     }
 232 
 233     /**
 234      * Loads a vector from an array using indexes obtained from an index
 235      * map.
 236      * <p>
 237      * For each vector lane, where {@code N} is the vector lane index, the
 238      * array element at index {@code a_offset + indexMap[i_offset + N]} is placed into the
 239      * resulting vector at lane index {@code N}.
 240      *
 241      * @param species species of desired vector
 242      * @param a the array
 243      * @param a_offset the offset into the array, may be negative if relative
 244      * indexes in the index map compensate to produce a value within the
 245      * array bounds
 246      * @param indexMap the index map
 247      * @param i_offset the offset into the index map
 248      * @return the vector loaded from an array
 249      * @throws IndexOutOfBoundsException if {@code i_offset < 0}, or
 250      * {@code i_offset > indexMap.length - species.length()},
 251      * or for any vector lane index {@code N} the result of
 252      * {@code a_offset + indexMap[i_offset + N]} is {@code < 0} or {@code >= a.length}
 253      */
 254     public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int a_offset, int[] indexMap, int i_offset) {
 255         return ((ShortSpecies)species).op(n -> a[a_offset + indexMap[i_offset + n]]);
 256     }
 257     /**
 258      * Loads a vector from an array using indexes obtained from an index
 259      * map and using a mask.
 260      * <p>
 261      * For each vector lane, where {@code N} is the vector lane index,
 262      * if the mask lane at index {@code N} is set then the array element at
 263      * index {@code a_offset + indexMap[i_offset + N]} is placed into the resulting vector
 264      * at lane index {@code N}.
 265      *
 266      * @param species species of desired vector
 267      * @param a the array
 268      * @param a_offset the offset into the array, may be negative if relative
 269      * indexes in the index map compensate to produce a value within the
 270      * array bounds
 271      * @param m the mask
 272      * @param indexMap the index map
 273      * @param i_offset the offset into the index map
 274      * @return the vector loaded from an array
 275      * @throws IndexOutOfBoundsException if {@code i_offset < 0}, or
 276      * {@code i_offset > indexMap.length - species.length()},
 277      * or for any vector lane index {@code N} where the mask at lane
 278      * {@code N} is set the result of {@code a_offset + indexMap[i_offset + N]} is
 279      * {@code < 0} or {@code >= a.length}
 280      */
 281     public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int a_offset, VectorMask<Short> m, int[] indexMap, int i_offset) {
 282         return ((ShortSpecies)species).op(m, n -> a[a_offset + indexMap[i_offset + n]]);
 283     }
 284 
 285     /**
 286      * Loads a vector from a {@link ByteBuffer byte buffer} starting at an
 287      * offset into the byte buffer.
 288      * <p>
 289      * Bytes are composed into primitive lane elements according to the
 290      * native byte order of the underlying platform.
 291      * <p>
 292      * This method behaves as if it returns the result of calling the
 293      * byte buffer, offset, and mask accepting
 294      * {@link #fromByteBuffer(VectorSpecies, ByteBuffer, int, VectorMask)} method} as follows:
 295      * <pre>{@code
 296      *   return fromByteBuffer(b, offset, VectorMask.allTrue())
 297      * }</pre>
 298      *
 299      * @param species species of desired vector
 300      * @param bb the byte buffer
 301      * @param offset the offset into the byte buffer
 302      * @return a vector loaded from a byte buffer
 303      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
 304      * or {@code > b.limit()},
 305      * or if there are fewer than
 306      * {@code species.length() * species.elementSize() / Byte.SIZE} bytes
 307      * remaining in the byte buffer from the given offset
 308      */
 309     @ForceInline
 310     @SuppressWarnings("unchecked")
 311     public static ShortVector fromByteBuffer(VectorSpecies<Short> species, ByteBuffer bb, int offset) {
 312         if (bb.order() != ByteOrder.nativeOrder()) {
 313             throw new IllegalArgumentException();
 314         }
 315         offset = VectorIntrinsics.checkIndex(offset, bb.limit(), species.bitSize() / Byte.SIZE);
 316         return VectorIntrinsics.load((Class<ShortVector>) species.vectorType(), short.class, species.length(),
 317                                      U.getReference(bb, BYTE_BUFFER_HB), U.getLong(bb, BUFFER_ADDRESS) + offset,
 318                                      bb, offset, species,
 319                                      (c, idx, s) -> {
 320                                          ByteBuffer bbc = c.duplicate().position(idx).order(ByteOrder.nativeOrder());
 321                                          ShortBuffer tb = bbc.asShortBuffer();
 322                                          return ((ShortSpecies)s).op(i -> tb.get());
 323                                      });
 324     }
 325 
 326     /**
 327      * Loads a vector from a {@link ByteBuffer byte buffer} starting at an
 328      * offset into the byte buffer and using a mask.
 329      * <p>
 330      * This method behaves as if the byte buffer is viewed as a primitive
 331      * {@link java.nio.Buffer buffer} for the primitive element type,
 332      * according to the native byte order of the underlying platform, and
 333      * the returned vector is loaded with a mask from a primitive array
 334      * obtained from the primitive buffer.
 335      * The following pseudocode expresses the behaviour, where
 336      * {@code EBuffer} is the primitive buffer type, {@code e} is the
 337      * primitive element type, and {@code ESpecies} is the primitive
 338      * species for {@code e}:
 339      * <pre>{@code
 340      * EBuffer eb = b.duplicate().
 341      *     order(ByteOrder.nativeOrder()).position(offset).
 342      *     asEBuffer();
 343      * e[] es = new e[species.length()];
 344      * for (int n = 0; n < t.length; n++) {
 345      *     if (m.isSet(n))
 346      *         es[n] = eb.get(n);
 347      * }
 348      * EVector r = EVector.fromArray(es, 0, m);
 349      * }</pre>
 350      *
 351      * @param species species of desired vector
 352      * @param bb the byte buffer
 353      * @param offset the offset into the byte buffer
 354      * @param m the mask
 355      * @return a vector loaded from a byte buffer
 356      * @throws IndexOutOfBoundsException if the offset is {@code < 0},
 357      * or {@code > b.limit()},
 358      * for any vector lane index {@code N} where the mask at lane {@code N}
 359      * is set
 360      * {@code offset >= b.limit() - (N * species.elementSize() / Byte.SIZE)}
 361      */
 362     @ForceInline
 363     public static ShortVector fromByteBuffer(VectorSpecies<Short> species, ByteBuffer bb, int offset, VectorMask<Short> m) {
 364         return zero(species).blend(fromByteBuffer(species, bb, offset), m);
 365     }
 366 
 367     /**
 368      * Returns a vector where all lane elements are set to the primitive
 369      * value {@code e}.
 370      *
 371      * @param species species of the desired vector
 372      * @param e the value to be broadcasted
 373      * @return a vector of vector where all lane elements are set to
 374      * the primitive value {@code e}
 375      */
 376     @ForceInline
 377     @SuppressWarnings("unchecked")
 378     public static ShortVector broadcast(VectorSpecies<Short> species, short e) {
 379         return VectorIntrinsics.broadcastCoerced(
 380             (Class<ShortVector>) species.vectorType(), short.class, species.length(),
 381             e, species,
 382             ((bits, sp) -> ((ShortSpecies)sp).op(i -> (short)bits)));
 383     }
 384 
 385     /**
 386      * Returns a vector where each lane element is set to given
 387      * primitive values.
 388      * <p>
 389      * For each vector lane, where {@code N} is the vector lane index, the
 390      * the primitive value at index {@code N} is placed into the resulting
 391      * vector at lane index {@code N}.
 392      *
 393      * @param species species of the desired vector
 394      * @param es the given primitive values
 395      * @return a vector where each lane element is set to given primitive
 396      * values
 397      * @throws IndexOutOfBoundsException if {@code es.length < species.length()}
 398      */
 399     @ForceInline
 400     @SuppressWarnings("unchecked")
 401     public static ShortVector scalars(VectorSpecies<Short> species, short... es) {
 402         Objects.requireNonNull(es);
 403         int ix = VectorIntrinsics.checkIndex(0, es.length, species.length());
 404         return VectorIntrinsics.load((Class<ShortVector>) species.vectorType(), short.class, species.length(),
 405                                      es, Unsafe.ARRAY_SHORT_BASE_OFFSET,
 406                                      es, ix, species,
 407                                      (c, idx, sp) -> ((ShortSpecies)sp).op(n -> c[idx + n]));
 408     }
 409 
 410     /**
 411      * Returns a vector where the first lane element is set to the primtive
 412      * value {@code e}, all other lane elements are set to the default
 413      * value.
 414      *
 415      * @param species species of the desired vector
 416      * @param e the value
 417      * @return a vector where the first lane element is set to the primitive
 418      * value {@code e}
 419      */
 420     @ForceInline
 421     public static final ShortVector single(VectorSpecies<Short> species, short e) {
 422         return zero(species).with(0, e);
 423     }
 424 
 425     /**
 426      * Returns a vector where each lane element is set to a randomly
 427      * generated primitive value.
 428      *
 429      * The semantics are equivalent to calling
 430      * (short){@link ThreadLocalRandom#nextInt()}
 431      *
 432      * @param species species of the desired vector
 433      * @return a vector where each lane elements is set to a randomly
 434      * generated primitive value
 435      */
 436     public static ShortVector random(VectorSpecies<Short> species) {
 437         ThreadLocalRandom r = ThreadLocalRandom.current();
 438         return ((ShortSpecies)species).op(i -> (short) r.nextInt());
 439     }
 440 
 441     // Ops
 442 
 443     /**
 444      * {@inheritDoc}
 445      */
 446     @Override
 447     public abstract ShortVector add(Vector<Short> v);
 448 
 449     /**
 450      * Adds this vector to the broadcast of an input scalar.
 451      * <p>
 452      * This is a lane-wise binary operation which applies the primitive addition operation
 453      * ({@code +}) to each lane.
 454      *
 455      * @param s the input scalar
 456      * @return the result of adding this vector to the broadcast of an input
 457      * scalar
 458      */
 459     public abstract ShortVector add(short s);
 460 
 461     /**
 462      * {@inheritDoc}
 463      */
 464     @Override
 465     public abstract ShortVector add(Vector<Short> v, VectorMask<Short> m);
 466 
 467     /**
 468      * Adds this vector to broadcast of an input scalar,
 469      * selecting lane elements controlled by a mask.
 470      * <p>
 471      * This is a lane-wise binary operation which applies the primitive addition operation
 472      * ({@code +}) to each lane.
 473      *
 474      * @param s the input scalar
 475      * @param m the mask controlling lane selection
 476      * @return the result of adding this vector to the broadcast of an input
 477      * scalar
 478      */
 479     public abstract ShortVector add(short s, VectorMask<Short> m);
 480 
 481     /**
 482      * {@inheritDoc}
 483      */
 484     @Override
 485     public abstract ShortVector sub(Vector<Short> v);
 486 
 487     /**
 488      * Subtracts the broadcast of an input scalar from this vector.
 489      * <p>
 490      * This is a lane-wise binary operation which applies the primitive subtraction
 491      * operation ({@code -}) to each lane.
 492      *
 493      * @param s the input scalar
 494      * @return the result of subtracting the broadcast of an input
 495      * scalar from this vector
 496      */
 497     public abstract ShortVector sub(short s);
 498 
 499     /**
 500      * {@inheritDoc}
 501      */
 502     @Override
 503     public abstract ShortVector sub(Vector<Short> v, VectorMask<Short> m);
 504 
 505     /**
 506      * Subtracts the broadcast of an input scalar from this vector, selecting
 507      * lane elements controlled by a mask.
 508      * <p>
 509      * This is a lane-wise binary operation which applies the primitive subtraction
 510      * operation ({@code -}) to each lane.
 511      *
 512      * @param s the input scalar
 513      * @param m the mask controlling lane selection
 514      * @return the result of subtracting the broadcast of an input
 515      * scalar from this vector
 516      */
 517     public abstract ShortVector sub(short s, VectorMask<Short> m);
 518 
 519     /**
 520      * {@inheritDoc}
 521      */
 522     @Override
 523     public abstract ShortVector mul(Vector<Short> v);
 524 
 525     /**
 526      * Multiplies this vector with the broadcast of an input scalar.
 527      * <p>
 528      * This is a lane-wise binary operation which applies the primitive multiplication
 529      * operation ({@code *}) to each lane.
 530      *
 531      * @param s the input scalar
 532      * @return the result of multiplying this vector with the broadcast of an
 533      * input scalar
 534      */
 535     public abstract ShortVector mul(short s);
 536 
 537     /**
 538      * {@inheritDoc}
 539      */
 540     @Override
 541     public abstract ShortVector mul(Vector<Short> v, VectorMask<Short> m);
 542 
 543     /**
 544      * Multiplies this vector with the broadcast of an input scalar, selecting
 545      * lane elements controlled by a mask.
 546      * <p>
 547      * This is a lane-wise binary operation which applies the primitive multiplication
 548      * operation ({@code *}) to each lane.
 549      *
 550      * @param s the input scalar
 551      * @param m the mask controlling lane selection
 552      * @return the result of multiplying this vector with the broadcast of an
 553      * input scalar
 554      */
 555     public abstract ShortVector mul(short s, VectorMask<Short> m);
 556 
 557     /**
 558      * {@inheritDoc}
 559      */
 560     @Override
 561     public abstract ShortVector neg();
 562 
 563     /**
 564      * {@inheritDoc}
 565      */
 566     @Override
 567     public abstract ShortVector neg(VectorMask<Short> m);
 568 
 569     /**
 570      * {@inheritDoc}
 571      */
 572     @Override
 573     public abstract ShortVector abs();
 574 
 575     /**
 576      * {@inheritDoc}
 577      */
 578     @Override
 579     public abstract ShortVector abs(VectorMask<Short> m);
 580 
 581     /**
 582      * {@inheritDoc}
 583      */
 584     @Override
 585     public abstract ShortVector min(Vector<Short> v);
 586 
 587     /**
 588      * {@inheritDoc}
 589      */
 590     @Override
 591     public abstract ShortVector min(Vector<Short> v, VectorMask<Short> m);
 592 
 593     /**
 594      * Returns the minimum of this vector and the broadcast of an input scalar.
 595      * <p>
 596      * This is a lane-wise binary operation which applies the operation
 597      * {@code (a, b) -> Math.min(a, b)} to each lane.
 598      *
 599      * @param s the input scalar
 600      * @return the minimum of this vector and the broadcast of an input scalar
 601      */
 602     public abstract ShortVector min(short s);
 603 
 604     /**
 605      * {@inheritDoc}
 606      */
 607     @Override
 608     public abstract ShortVector max(Vector<Short> v);
 609 
 610     /**
 611      * {@inheritDoc}
 612      */
 613     @Override
 614     public abstract ShortVector max(Vector<Short> v, VectorMask<Short> m);
 615 
 616     /**
 617      * Returns the maximum of this vector and the broadcast of an input scalar.
 618      * <p>
 619      * This is a lane-wise binary operation which applies the operation
 620      * {@code (a, b) -> Math.max(a, b)} to each lane.
 621      *
 622      * @param s the input scalar
 623      * @return the maximum of this vector and the broadcast of an input scalar
 624      */
 625     public abstract ShortVector max(short s);
 626 
 627     /**
 628      * {@inheritDoc}
 629      */
 630     @Override
 631     public abstract VectorMask<Short> equal(Vector<Short> v);
 632 
 633     /**
 634      * Tests if this vector is equal to the broadcast of an input scalar.
 635      * <p>
 636      * This is a lane-wise binary test operation which applies the primitive equals
 637      * operation ({@code ==}) each lane.
 638      *
 639      * @param s the input scalar
 640      * @return the result mask of testing if this vector is equal to the
 641      * broadcast of an input scalar
 642      */
 643     public abstract VectorMask<Short> equal(short s);
 644 
 645     /**
 646      * {@inheritDoc}
 647      */
 648     @Override
 649     public abstract VectorMask<Short> notEqual(Vector<Short> v);
 650 
 651     /**
 652      * Tests if this vector is not equal to the broadcast of an input scalar.
 653      * <p>
 654      * This is a lane-wise binary test operation which applies the primitive not equals
 655      * operation ({@code !=}) to each lane.
 656      *
 657      * @param s the input scalar
 658      * @return the result mask of testing if this vector is not equal to the
 659      * broadcast of an input scalar
 660      */
 661     public abstract VectorMask<Short> notEqual(short s);
 662 
 663     /**
 664      * {@inheritDoc}
 665      */
 666     @Override
 667     public abstract VectorMask<Short> lessThan(Vector<Short> v);
 668 
 669     /**
 670      * Tests if this vector is less than the broadcast of an input scalar.
 671      * <p>
 672      * This is a lane-wise binary test operation which applies the primitive less than
 673      * operation ({@code <}) to each lane.
 674      *
 675      * @param s the input scalar
 676      * @return the mask result of testing if this vector is less than the
 677      * broadcast of an input scalar
 678      */
 679     public abstract VectorMask<Short> lessThan(short s);
 680 
 681     /**
 682      * {@inheritDoc}
 683      */
 684     @Override
 685     public abstract VectorMask<Short> lessThanEq(Vector<Short> v);
 686 
 687     /**
 688      * Tests if this vector is less or equal to the broadcast of an input scalar.
 689      * <p>
 690      * This is a lane-wise binary test operation which applies the primitive less than
 691      * or equal to operation ({@code <=}) to each lane.
 692      *
 693      * @param s the input scalar
 694      * @return the mask result of testing if this vector is less than or equal
 695      * to the broadcast of an input scalar
 696      */
 697     public abstract VectorMask<Short> lessThanEq(short s);
 698 
 699     /**
 700      * {@inheritDoc}
 701      */
 702     @Override
 703     public abstract VectorMask<Short> greaterThan(Vector<Short> v);
 704 
 705     /**
 706      * Tests if this vector is greater than the broadcast of an input scalar.
 707      * <p>
 708      * This is a lane-wise binary test operation which applies the primitive greater than
 709      * operation ({@code >}) to each lane.
 710      *
 711      * @param s the input scalar
 712      * @return the mask result of testing if this vector is greater than the
 713      * broadcast of an input scalar
 714      */
 715     public abstract VectorMask<Short> greaterThan(short s);
 716 
 717     /**
 718      * {@inheritDoc}
 719      */
 720     @Override
 721     public abstract VectorMask<Short> greaterThanEq(Vector<Short> v);
 722 
 723     /**
 724      * Tests if this vector is greater than or equal to the broadcast of an
 725      * input scalar.
 726      * <p>
 727      * This is a lane-wise binary test operation which applies the primitive greater than
 728      * or equal to operation ({@code >=}) to each lane.
 729      *
 730      * @param s the input scalar
 731      * @return the mask result of testing if this vector is greater than or
 732      * equal to the broadcast of an input scalar
 733      */
 734     public abstract VectorMask<Short> greaterThanEq(short s);
 735 
 736     /**
 737      * {@inheritDoc}
 738      */
 739     @Override
 740     public abstract ShortVector blend(Vector<Short> v, VectorMask<Short> m);
 741 
 742     /**
 743      * Blends the lane elements of this vector with those of the broadcast of an
 744      * input scalar, selecting lanes controlled by a mask.
 745      * <p>
 746      * For each lane of the mask, at lane index {@code N}, if the mask lane
 747      * is set then the lane element at {@code N} from the input vector is
 748      * selected and placed into the resulting vector at {@code N},
 749      * otherwise the the lane element at {@code N} from this input vector is
 750      * selected and placed into the resulting vector at {@code N}.
 751      *
 752      * @param s the input scalar
 753      * @param m the mask controlling lane selection
 754      * @return the result of blending the lane elements of this vector with
 755      * those of the broadcast of an input scalar
 756      */
 757     public abstract ShortVector blend(short s, VectorMask<Short> m);
 758 
 759     /**
 760      * {@inheritDoc}
 761      */
 762     @Override
 763     public abstract ShortVector rearrange(Vector<Short> v,
 764                                                       VectorShuffle<Short> s, VectorMask<Short> m);
 765 
 766     /**
 767      * {@inheritDoc}
 768      */
 769     @Override
 770     public abstract ShortVector rearrange(VectorShuffle<Short> m);
 771 
 772     /**
 773      * {@inheritDoc}
 774      */
 775     @Override
 776     public abstract ShortVector reshape(VectorSpecies<Short> s);
 777 
 778     /**
 779      * {@inheritDoc}
 780      */
 781     @Override
 782     public abstract ShortVector rotateLanesLeft(int i);
 783 
 784     /**
 785      * {@inheritDoc}
 786      */
 787     @Override
 788     public abstract ShortVector rotateLanesRight(int i);
 789 
 790     /**
 791      * {@inheritDoc}
 792      */
 793     @Override
 794     public abstract ShortVector shiftLanesLeft(int i);
 795 
 796     /**
 797      * {@inheritDoc}
 798      */
 799     @Override
 800     public abstract ShortVector shiftLanesRight(int i);
 801 
 802 
 803 
 804     /**
 805      * Bitwise ANDs this vector with an input vector.
 806      * <p>
 807      * This is a lane-wise binary operation which applies the primitive bitwise AND
 808      * operation ({@code &}) to each lane.
 809      *
 810      * @param v the input vector
 811      * @return the bitwise AND of this vector with the input vector
 812      */
 813     public abstract ShortVector and(Vector<Short> v);
 814 
 815     /**
 816      * Bitwise ANDs this vector with the broadcast of an input scalar.
 817      * <p>
 818      * This is a lane-wise binary operation which applies the primitive bitwise AND
 819      * operation ({@code &}) to each lane.
 820      *
 821      * @param s the input scalar
 822      * @return the bitwise AND of this vector with the broadcast of an input
 823      * scalar
 824      */
 825     public abstract ShortVector and(short s);
 826 
 827     /**
 828      * Bitwise ANDs this vector with an input vector, selecting lane elements
 829      * controlled by a mask.
 830      * <p>
 831      * This is a lane-wise binary operation which applies the primitive bitwise AND
 832      * operation ({@code &}) to each lane.
 833      *
 834      * @param v the input vector
 835      * @param m the mask controlling lane selection
 836      * @return the bitwise AND of this vector with the input vector
 837      */
 838     public abstract ShortVector and(Vector<Short> v, VectorMask<Short> m);
 839 
 840     /**
 841      * Bitwise ANDs this vector with the broadcast of an input scalar, selecting
 842      * lane elements controlled by a mask.
 843      * <p>
 844      * This is a lane-wise binary operation which applies the primitive bitwise AND
 845      * operation ({@code &}) to each lane.
 846      *
 847      * @param s the input scalar
 848      * @param m the mask controlling lane selection
 849      * @return the bitwise AND of this vector with the broadcast of an input
 850      * scalar
 851      */
 852     public abstract ShortVector and(short s, VectorMask<Short> m);
 853 
 854     /**
 855      * Bitwise ORs this vector with an input vector.
 856      * <p>
 857      * This is a lane-wise binary operation which applies the primitive bitwise OR
 858      * operation ({@code |}) to each lane.
 859      *
 860      * @param v the input vector
 861      * @return the bitwise OR of this vector with the input vector
 862      */
 863     public abstract ShortVector or(Vector<Short> v);
 864 
 865     /**
 866      * Bitwise ORs this vector with the broadcast of an input scalar.
 867      * <p>
 868      * This is a lane-wise binary operation which applies the primitive bitwise OR
 869      * operation ({@code |}) to each lane.
 870      *
 871      * @param s the input scalar
 872      * @return the bitwise OR of this vector with the broadcast of an input
 873      * scalar
 874      */
 875     public abstract ShortVector or(short s);
 876 
 877     /**
 878      * Bitwise ORs this vector with an input vector, selecting lane elements
 879      * controlled by a mask.
 880      * <p>
 881      * This is a lane-wise binary operation which applies the primitive bitwise OR
 882      * operation ({@code |}) to each lane.
 883      *
 884      * @param v the input vector
 885      * @param m the mask controlling lane selection
 886      * @return the bitwise OR of this vector with the input vector
 887      */
 888     public abstract ShortVector or(Vector<Short> v, VectorMask<Short> m);
 889 
 890     /**
 891      * Bitwise ORs this vector with the broadcast of an input scalar, selecting
 892      * lane elements controlled by a mask.
 893      * <p>
 894      * This is a lane-wise binary operation which applies the primitive bitwise OR
 895      * operation ({@code |}) to each lane.
 896      *
 897      * @param s the input scalar
 898      * @param m the mask controlling lane selection
 899      * @return the bitwise OR of this vector with the broadcast of an input
 900      * scalar
 901      */
 902     public abstract ShortVector or(short s, VectorMask<Short> m);
 903 
 904     /**
 905      * Bitwise XORs this vector with an input vector.
 906      * <p>
 907      * This is a lane-wise binary operation which applies the primitive bitwise XOR
 908      * operation ({@code ^}) to each lane.
 909      *
 910      * @param v the input vector
 911      * @return the bitwise XOR of this vector with the input vector
 912      */
 913     public abstract ShortVector xor(Vector<Short> v);
 914 
 915     /**
 916      * Bitwise XORs this vector with the broadcast of an input scalar.
 917      * <p>
 918      * This is a lane-wise binary operation which applies the primitive bitwise XOR
 919      * operation ({@code ^}) to each lane.
 920      *
 921      * @param s the input scalar
 922      * @return the bitwise XOR of this vector with the broadcast of an input
 923      * scalar
 924      */
 925     public abstract ShortVector xor(short s);
 926 
 927     /**
 928      * Bitwise XORs this vector with an input vector, selecting lane elements
 929      * controlled by a mask.
 930      * <p>
 931      * This is a lane-wise binary operation which applies the primitive bitwise XOR
 932      * operation ({@code ^}) to each lane.
 933      *
 934      * @param v the input vector
 935      * @param m the mask controlling lane selection
 936      * @return the bitwise XOR of this vector with the input vector
 937      */
 938     public abstract ShortVector xor(Vector<Short> v, VectorMask<Short> m);
 939 
 940     /**
 941      * Bitwise XORs this vector with the broadcast of an input scalar, selecting
 942      * lane elements controlled by a mask.
 943      * <p>
 944      * This is a lane-wise binary operation which applies the primitive bitwise XOR
 945      * operation ({@code ^}) to each lane.
 946      *
 947      * @param s the input scalar
 948      * @param m the mask controlling lane selection
 949      * @return the bitwise XOR of this vector with the broadcast of an input
 950      * scalar
 951      */
 952     public abstract ShortVector xor(short s, VectorMask<Short> m);
 953 
 954     /**
 955      * Bitwise NOTs this vector.
 956      * <p>
 957      * This is a lane-wise unary operation which applies the primitive bitwise NOT
 958      * operation ({@code ~}) to each lane.
 959      *
 960      * @return the bitwise NOT of this vector
 961      */
 962     public abstract ShortVector not();
 963 
 964     /**
 965      * Bitwise NOTs this vector, selecting lane elements controlled by a mask.
 966      * <p>
 967      * This is a lane-wise unary operation which applies the primitive bitwise NOT
 968      * operation ({@code ~}) to each lane.
 969      *
 970      * @param m the mask controlling lane selection
 971      * @return the bitwise NOT of this vector
 972      */
 973     public abstract ShortVector not(VectorMask<Short> m);
 974 
 975     /**
 976      * Logically left shifts this vector by the broadcast of an input scalar.
 977      * <p>
 978      * This is a lane-wise binary operation which applies the primitive logical left shift
 979      * operation ({@code <<}) to each lane to left shift the
 980      * element by shift value as specified by the input scalar.
 981      * Only the 4 lowest-order bits of shift value are used. It is as if the shift value
 982      * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
 983      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
 984      *
 985      * @param s the input scalar; the number of the bits to left shift
 986      * @return the result of logically left shifting this vector by the
 987      * broadcast of an input scalar
 988      */
 989     public abstract ShortVector shiftLeft(int s);
 990 
 991     /**
 992      * Logically left shifts this vector by the broadcast of an input scalar,
 993      * selecting lane elements controlled by a mask.
 994      * <p>
 995      * This is a lane-wise binary operation which applies the primitive logical left shift
 996      * operation ({@code <<}) to each lane to left shift the
 997      * element by shift value as specified by the input scalar.
 998      * Only the 4 lowest-order bits of shift value are used. It is as if the shift value
 999      * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
1000      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
1001      *
1002      * @param s the input scalar; the number of the bits to left shift
1003      * @param m the mask controlling lane selection
1004      * @return the result of logically left shifting this vector by the
1005      * broadcast of an input scalar
1006      */
1007     public abstract ShortVector shiftLeft(int s, VectorMask<Short> m);
1008 
1009     /**
1010      * Logically left shifts this vector by an input vector.
1011      * <p>
1012      * This is a lane-wise binary operation which applies the primitive logical left shift
1013      * operation ({@code <<}) to each lane. For each lane of this vector, the
1014      * shift value is the corresponding lane of input vector.
1015      * Only the 4 lowest-order bits of shift value are used. It is as if the shift value
1016      * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
1017      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
1018      *
1019      * @param v the input vector
1020      * @return the result of logically left shifting this vector by the input
1021      * vector
1022      */
1023     public abstract ShortVector shiftLeft(Vector<Short> v);
1024 
1025     /**
1026      * Logically left shifts this vector by an input vector, selecting lane
1027      * elements controlled by a mask.
1028      * <p>
1029      * This is a lane-wise binary operation which applies the primitive logical left shift
1030      * operation ({@code <<}) to each lane. For each lane of this vector, the
1031      * shift value is the corresponding lane of input vector.
1032      * Only the 4 lowest-order bits of shift value are used. It is as if the shift value
1033      * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
1034      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
1035      *
1036      * @param v the input vector
1037      * @param m the mask controlling lane selection
1038      * @return the result of logically left shifting this vector by the input
1039      * vector
1040      */
1041     public ShortVector shiftLeft(Vector<Short> v, VectorMask<Short> m) {
1042         return blend(shiftLeft(v), m);
1043     }
1044 
1045     // logical, or unsigned, shift right
1046 
1047      /**
1048      * Logically right shifts (or unsigned right shifts) this vector by the
1049      * broadcast of an input scalar.
1050      * <p>
1051      * This is a lane-wise binary operation which applies the primitive logical right shift
1052      * operation ({@code >>>}) to each lane to logically right shift the
1053      * element by shift value as specified by the input scalar.
1054      * Only the 4 lowest-order bits of shift value are used. It is as if the shift value
1055      * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
1056      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
1057      *
1058      * @param s the input scalar; the number of the bits to right shift
1059      * @return the result of logically right shifting this vector by the
1060      * broadcast of an input scalar
1061      */
1062     public abstract ShortVector shiftRight(int s);
1063 
1064      /**
1065      * Logically right shifts (or unsigned right shifts) this vector by the
1066      * broadcast of an input scalar, selecting lane elements controlled by a
1067      * mask.
1068      * <p>
1069      * This is a lane-wise binary operation which applies the primitive logical right shift
1070      * operation ({@code >>}) to each lane to logically right shift the
1071      * element by shift value as specified by the input scalar.
1072      * Only the 4 lowest-order bits of shift value are used. It is as if the shift value
1073      * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
1074      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
1075      *
1076      * @param s the input scalar; the number of the bits to right shift
1077      * @param m the mask controlling lane selection
1078      * @return the result of logically right shifting this vector by the
1079      * broadcast of an input scalar
1080      */
1081     public abstract ShortVector shiftRight(int s, VectorMask<Short> m);
1082 
1083     /**
1084      * Logically right shifts (or unsigned right shifts) this vector by an
1085      * input vector.
1086      * <p>
1087      * This is a lane-wise binary operation which applies the primitive logical right shift
1088      * operation ({@code >>>}) to each lane. For each lane of this vector, the
1089      * shift value is the corresponding lane of input vector.
1090      * Only the 4 lowest-order bits of shift value are used. It is as if the shift value
1091      * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
1092      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
1093      *
1094      * @param v the input vector
1095      * @return the result of logically right shifting this vector by the
1096      * input vector
1097      */
1098     public abstract ShortVector shiftRight(Vector<Short> v);
1099 
1100     /**
1101      * Logically right shifts (or unsigned right shifts) this vector by an
1102      * input vector, selecting lane elements controlled by a mask.
1103      * <p>
1104      * This is a lane-wise binary operation which applies the primitive logical right shift
1105      * operation ({@code >>>}) to each lane. For each lane of this vector, the
1106      * shift value is the corresponding lane of input vector.
1107      * Only the 4 lowest-order bits of shift value are used. It is as if the shift value
1108      * were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
1109      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
1110      *
1111      * @param v the input vector
1112      * @param m the mask controlling lane selection
1113      * @return the result of logically right shifting this vector by the
1114      * input vector
1115      */
1116     public ShortVector shiftRight(Vector<Short> v, VectorMask<Short> m) {
1117         return blend(shiftRight(v), m);
1118     }
1119 
1120     /**
1121      * Arithmetically right shifts (or signed right shifts) this vector by the
1122      * broadcast of an input scalar.
1123      * <p>
1124      * This is a lane-wise binary operation which applies the primitive arithmetic right
1125      * shift operation ({@code >>}) to each lane to arithmetically
1126      * right shift the element by shift value as specified by the input scalar.
1127      * Only the 4 lowest-order bits of shift value are used. It is as if the shift
1128      * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
1129      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
1130      *
1131      * @param s the input scalar; the number of the bits to right shift
1132      * @return the result of arithmetically right shifting this vector by the
1133      * broadcast of an input scalar
1134      */
1135     public abstract ShortVector shiftArithmeticRight(int s);
1136 
1137     /**
1138      * Arithmetically right shifts (or signed right shifts) this vector by the
1139      * broadcast of an input scalar, selecting lane elements controlled by a
1140      * mask.
1141      * <p>
1142      * This is a lane-wise binary operation which applies the primitive arithmetic right
1143      * shift operation ({@code >>}) to each lane to arithmetically
1144      * right shift the element by shift value as specified by the input scalar.
1145      * Only the 4 lowest-order bits of shift value are used. It is as if the shift
1146      * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
1147      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
1148      *
1149      * @param s the input scalar; the number of the bits to right shift
1150      * @param m the mask controlling lane selection
1151      * @return the result of arithmetically right shifting this vector by the
1152      * broadcast of an input scalar
1153      */
1154     public abstract ShortVector shiftArithmeticRight(int s, VectorMask<Short> m);
1155 
1156     /**
1157      * Arithmetically right shifts (or signed right shifts) this vector by an
1158      * input vector.
1159      * <p>
1160      * This is a lane-wise binary operation which applies the primitive arithmetic right
1161      * shift operation ({@code >>}) to each lane. For each lane of this vector, the
1162      * shift value is the corresponding lane of input vector.
1163      * Only the 4 lowest-order bits of shift value are used. It is as if the shift
1164      * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
1165      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
1166      *
1167      * @param v the input vector
1168      * @return the result of arithmetically right shifting this vector by the
1169      * input vector
1170      */
1171     public abstract ShortVector shiftArithmeticRight(Vector<Short> v);
1172 
1173     /**
1174      * Arithmetically right shifts (or signed right shifts) this vector by an
1175      * input vector, selecting lane elements controlled by a mask.
1176      * <p>
1177      * This is a lane-wise binary operation which applies the primitive arithmetic right
1178      * shift operation ({@code >>}) to each lane. For each lane of this vector, the
1179      * shift value is the corresponding lane of input vector.
1180      * Only the 4 lowest-order bits of shift value are used. It is as if the shift
1181      * value were subjected to a bitwise logical AND operator ({@code &}) with the mask value 0xF.
1182      * The shift distance actually used is therefore always in the range 0 to 15, inclusive.
1183      *
1184      * @param v the input vector
1185      * @param m the mask controlling lane selection
1186      * @return the result of arithmetically right shifting this vector by the
1187      * input vector
1188      */
1189     public ShortVector shiftArithmeticRight(Vector<Short> v, VectorMask<Short> m) {
1190         return blend(shiftArithmeticRight(v), m);
1191     }
1192 
1193     /**
1194      * Rotates left this vector by the broadcast of an input scalar.
1195      * <p>
1196      * This is a lane-wise binary operation which produces the result of rotating left the two's
1197      * complement binary representation of each lane of first operand (this vector) by input scalar.
1198      * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used.
1199      * It is as if the input value were subjected to a bitwise logical
1200      * AND operator ({@code &}) with the mask value 0xF.
1201      *
1202      * @param s the input scalar; the number of the bits to rotate left
1203      * @return the result of rotating left this vector by the broadcast of an
1204      * input scalar
1205      */
1206     @ForceInline
1207     public final ShortVector rotateLeft(int s) {
1208         return shiftLeft(s).or(shiftRight(-s));
1209     }
1210 
1211     /**
1212      * Rotates left this vector by the broadcast of an input scalar, selecting
1213      * lane elements controlled by a mask.
1214      * <p>
1215      * This is a lane-wise binary operation which produces the result of rotating left the two's
1216      * complement binary representation of each lane of first operand (this vector) by input scalar.
1217      * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used.
1218      * It is as if the input value were subjected to a bitwise logical
1219      * AND operator ({@code &}) with the mask value 0xF.
1220      *
1221      * @param s the input scalar; the number of the bits to rotate left
1222      * @param m the mask controlling lane selection
1223      * @return the result of rotating left this vector by the broadcast of an
1224      * input scalar
1225      */
1226     @ForceInline
1227     public final ShortVector rotateLeft(int s, VectorMask<Short> m) {
1228         return shiftLeft(s, m).or(shiftRight(-s, m), m);
1229     }
1230 
1231     /**
1232      * Rotates right this vector by the broadcast of an input scalar.
1233      * <p>
1234      * This is a lane-wise binary operation which produces the result of rotating right the two's
1235      * complement binary representation of each lane of first operand (this vector) by input scalar.
1236      * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used.
1237      * It is as if the input value were subjected to a bitwise logical
1238      * AND operator ({@code &}) with the mask value 0xF.
1239      *
1240      * @param s the input scalar; the number of the bits to rotate right
1241      * @return the result of rotating right this vector by the broadcast of an
1242      * input scalar
1243      */
1244     @ForceInline
1245     public final ShortVector rotateRight(int s) {
1246         return shiftRight(s).or(shiftLeft(-s));
1247     }
1248 
1249     /**
1250      * Rotates right this vector by the broadcast of an input scalar, selecting
1251      * lane elements controlled by a mask.
1252      * <p>
1253      * This is a lane-wise binary operation which produces the result of rotating right the two's
1254      * complement binary representation of each lane of first operand (this vector) by input scalar.
1255      * Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used.
1256      * It is as if the input value were subjected to a bitwise logical
1257      * AND operator ({@code &}) with the mask value 0xF.
1258      *
1259      * @param s the input scalar; the number of the bits to rotate right
1260      * @param m the mask controlling lane selection
1261      * @return the result of rotating right this vector by the broadcast of an
1262      * input scalar
1263      */
1264     @ForceInline
1265     public final ShortVector rotateRight(int s, VectorMask<Short> m) {
1266         return shiftRight(s, m).or(shiftLeft(-s, m), m);
1267     }
1268 
1269     /**
1270      * {@inheritDoc}
1271      */
1272     @Override
1273     public abstract void intoByteArray(byte[] a, int ix);
1274 
1275     /**
1276      * {@inheritDoc}
1277      */
1278     @Override
1279     public abstract void intoByteArray(byte[] a, int ix, VectorMask<Short> m);
1280 
1281     /**
1282      * {@inheritDoc}
1283      */
1284     @Override
1285     public abstract void intoByteBuffer(ByteBuffer bb, int ix);
1286 
1287     /**
1288      * {@inheritDoc}
1289      */
1290     @Override
1291     public abstract void intoByteBuffer(ByteBuffer bb, int ix, VectorMask<Short> m);
1292 
1293 
1294     // Type specific horizontal reductions
1295     /**
1296      * Adds all lane elements of this vector.
1297      * <p>
1298      * This is an associative cross-lane reduction operation which applies the addition
1299      * operation ({@code +}) to lane elements,
1300      * and the identity value is {@code 0}.
1301      *
1302      * @return the addition of all the lane elements of this vector
1303      */
1304     public abstract short addLanes();
1305 
1306     /**
1307      * Adds all lane elements of this vector, selecting lane elements
1308      * controlled by a mask.
1309      * <p>
1310      * This is an associative cross-lane reduction operation which applies the addition
1311      * operation ({@code +}) to lane elements,
1312      * and the identity value is {@code 0}.
1313      *
1314      * @param m the mask controlling lane selection
1315      * @return the addition of the selected lane elements of this vector
1316      */
1317     public abstract short addLanes(VectorMask<Short> m);
1318 
1319     /**
1320      * Multiplies all lane elements of this vector.
1321      * <p>
1322      * This is an associative cross-lane reduction operation which applies the
1323      * multiplication operation ({@code *}) to lane elements,
1324      * and the identity value is {@code 1}.
1325      *
1326      * @return the multiplication of all the lane elements of this vector
1327      */
1328     public abstract short mulLanes();
1329 
1330     /**
1331      * Multiplies all lane elements of this vector, selecting lane elements
1332      * controlled by a mask.
1333      * <p>
1334      * This is an associative cross-lane reduction operation which applies the
1335      * multiplication operation ({@code *}) to lane elements,
1336      * and the identity value is {@code 1}.
1337      *
1338      * @param m the mask controlling lane selection
1339      * @return the multiplication of all the lane elements of this vector
1340      */
1341     public abstract short mulLanes(VectorMask<Short> m);
1342 
1343     /**
1344      * Returns the minimum lane element of this vector.
1345      * <p>
1346      * This is an associative cross-lane reduction operation which applies the operation
1347      * {@code (a, b) -> Math.min(a, b)} to lane elements,
1348      * and the identity value is
1349      * {@link Short#MAX_VALUE}.
1350      *
1351      * @return the minimum lane element of this vector
1352      */
1353     public abstract short minLanes();
1354 
1355     /**
1356      * Returns the minimum lane element of this vector, selecting lane elements
1357      * controlled by a mask.
1358      * <p>
1359      * This is an associative cross-lane reduction operation which applies the operation
1360      * {@code (a, b) -> Math.min(a, b)} to lane elements,
1361      * and the identity value is
1362      * {@link Short#MAX_VALUE}.
1363      *
1364      * @param m the mask controlling lane selection
1365      * @return the minimum lane element of this vector
1366      */
1367     public abstract short minLanes(VectorMask<Short> m);
1368 
1369     /**
1370      * Returns the maximum lane element of this vector.
1371      * <p>
1372      * This is an associative cross-lane reduction operation which applies the operation
1373      * {@code (a, b) -> Math.max(a, b)} to lane elements,
1374      * and the identity value is
1375      * {@link Short#MIN_VALUE}.
1376      *
1377      * @return the maximum lane element of this vector
1378      */
1379     public abstract short maxLanes();
1380 
1381     /**
1382      * Returns the maximum lane element of this vector, selecting lane elements
1383      * controlled by a mask.
1384      * <p>
1385      * This is an associative cross-lane reduction operation which applies the operation
1386      * {@code (a, b) -> Math.max(a, b)} to lane elements,
1387      * and the identity value is
1388      * {@link Short#MIN_VALUE}.
1389      *
1390      * @param m the mask controlling lane selection
1391      * @return the maximum lane element of this vector
1392      */
1393     public abstract short maxLanes(VectorMask<Short> m);
1394 
1395     /**
1396      * Logically ORs all lane elements of this vector.
1397      * <p>
1398      * This is an associative cross-lane reduction operation which applies the logical OR
1399      * operation ({@code |}) to lane elements,
1400      * and the identity value is {@code 0}.
1401      *
1402      * @return the logical OR all the lane elements of this vector
1403      */
1404     public abstract short orLanes();
1405 
1406     /**
1407      * Logically ORs all lane elements of this vector, selecting lane elements
1408      * controlled by a mask.
1409      * <p>
1410      * This is an associative cross-lane reduction operation which applies the logical OR
1411      * operation ({@code |}) to lane elements,
1412      * and the identity value is {@code 0}.
1413      *
1414      * @param m the mask controlling lane selection
1415      * @return the logical OR all the lane elements of this vector
1416      */
1417     public abstract short orLanes(VectorMask<Short> m);
1418 
1419     /**
1420      * Logically ANDs all lane elements of this vector.
1421      * <p>
1422      * This is an associative cross-lane reduction operation which applies the logical AND
1423      * operation ({@code |}) to lane elements,
1424      * and the identity value is {@code -1}.
1425      *
1426      * @return the logical AND all the lane elements of this vector
1427      */
1428     public abstract short andLanes();
1429 
1430     /**
1431      * Logically ANDs all lane elements of this vector, selecting lane elements
1432      * controlled by a mask.
1433      * <p>
1434      * This is an associative cross-lane reduction operation which applies the logical AND
1435      * operation ({@code |}) to lane elements,
1436      * and the identity value is {@code -1}.
1437      *
1438      * @param m the mask controlling lane selection
1439      * @return the logical AND all the lane elements of this vector
1440      */
1441     public abstract short andLanes(VectorMask<Short> m);
1442 
1443     /**
1444      * Logically XORs all lane elements of this vector.
1445      * <p>
1446      * This is an associative cross-lane reduction operation which applies the logical XOR
1447      * operation ({@code ^}) to lane elements,
1448      * and the identity value is {@code 0}.
1449      *
1450      * @return the logical XOR all the lane elements of this vector
1451      */
1452     public abstract short xorLanes();
1453 
1454     /**
1455      * Logically XORs all lane elements of this vector, selecting lane elements
1456      * controlled by a mask.
1457      * <p>
1458      * This is an associative cross-lane reduction operation which applies the logical XOR
1459      * operation ({@code ^}) to lane elements,
1460      * and the identity value is {@code 0}.
1461      *
1462      * @param m the mask controlling lane selection
1463      * @return the logical XOR all the lane elements of this vector
1464      */
1465     public abstract short xorLanes(VectorMask<Short> m);
1466 
1467     // Type specific accessors
1468 
1469     /**
1470      * Gets the lane element at lane index {@code i}
1471      *
1472      * @param i the lane index
1473      * @return the lane element at lane index {@code i}
1474      * @throws IllegalArgumentException if the index is is out of range
1475      * ({@code < 0 || >= length()})
1476      */
1477     public abstract short lane(int i);
1478 
1479     /**
1480      * Replaces the lane element of this vector at lane index {@code i} with
1481      * value {@code e}.
1482      * <p>
1483      * This is a cross-lane operation and behaves as if it returns the result
1484      * of blending this vector with an input vector that is the result of
1485      * broadcasting {@code e} and a mask that has only one lane set at lane
1486      * index {@code i}.
1487      *
1488      * @param i the lane index of the lane element to be replaced
1489      * @param e the value to be placed
1490      * @return the result of replacing the lane element of this vector at lane
1491      * index {@code i} with value {@code e}.
1492      * @throws IllegalArgumentException if the index is is out of range
1493      * ({@code < 0 || >= length()})
1494      */
1495     public abstract ShortVector with(int i, short e);
1496 
1497     // Type specific extractors
1498 
1499     /**
1500      * Returns an array containing the lane elements of this vector.
1501      * <p>
1502      * This method behaves as if it {@link #intoArray(short[], int)} stores}
1503      * this vector into an allocated array and returns the array as follows:
1504      * <pre>{@code
1505      *   short[] a = new short[this.length()];
1506      *   this.intoArray(a, 0);
1507      *   return a;
1508      * }</pre>
1509      *
1510      * @return an array containing the the lane elements of this vector
1511      */
1512     @ForceInline
1513     public final short[] toArray() {
1514         short[] a = new short[species().length()];
1515         intoArray(a, 0);
1516         return a;
1517     }
1518 
1519     /**
1520      * Stores this vector into an array starting at offset.
1521      * <p>
1522      * For each vector lane, where {@code N} is the vector lane index,
1523      * the lane element at index {@code N} is stored into the array at index
1524      * {@code offset + N}.
1525      *
1526      * @param a the array
1527      * @param offset the offset into the array
1528      * @throws IndexOutOfBoundsException if {@code offset < 0}, or
1529      * {@code offset > a.length - this.length()}
1530      */
1531     public abstract void intoArray(short[] a, int offset);
1532 
1533     /**
1534      * Stores this vector into an array starting at offset and using a mask.
1535      * <p>
1536      * For each vector lane, where {@code N} is the vector lane index,
1537      * if the mask lane at index {@code N} is set then the lane element at
1538      * index {@code N} is stored into the array index {@code offset + N}.
1539      *
1540      * @param a the array
1541      * @param offset the offset into the array
1542      * @param m the mask
1543      * @throws IndexOutOfBoundsException if {@code offset < 0}, or
1544      * for any vector lane index {@code N} where the mask at lane {@code N}
1545      * is set {@code offset >= a.length - N}
1546      */
1547     public abstract void intoArray(short[] a, int offset, VectorMask<Short> m);
1548 
1549     /**
1550      * Stores this vector into an array using indexes obtained from an index
1551      * map.
1552      * <p>
1553      * For each vector lane, where {@code N} is the vector lane index, the
1554      * lane element at index {@code N} is stored into the array at index
1555      * {@code a_offset + indexMap[i_offset + N]}.
1556      *
1557      * @param a the array
1558      * @param a_offset the offset into the array, may be negative if relative
1559      * indexes in the index map compensate to produce a value within the
1560      * array bounds
1561      * @param indexMap the index map
1562      * @param i_offset the offset into the index map
1563      * @throws IndexOutOfBoundsException if {@code i_offset < 0}, or
1564      * {@code i_offset > indexMap.length - this.length()},
1565      * or for any vector lane index {@code N} the result of
1566      * {@code a_offset + indexMap[i_offset + N]} is {@code < 0} or {@code >= a.length}
1567      */
1568     public void intoArray(short[] a, int a_offset, int[] indexMap, int i_offset) {
1569         forEach((n, e) -> a[a_offset + indexMap[i_offset + n]] = e);
1570     }
1571 
1572     /**
1573      * Stores this vector into an array using indexes obtained from an index
1574      * map and using a mask.
1575      * <p>
1576      * For each vector lane, where {@code N} is the vector lane index,
1577      * if the mask lane at index {@code N} is set then the lane element at
1578      * index {@code N} is stored into the array at index
1579      * {@code a_offset + indexMap[i_offset + N]}.
1580      *
1581      * @param a the array
1582      * @param a_offset the offset into the array, may be negative if relative
1583      * indexes in the index map compensate to produce a value within the
1584      * array bounds
1585      * @param m the mask
1586      * @param indexMap the index map
1587      * @param i_offset the offset into the index map
1588      * @throws IndexOutOfBoundsException if {@code j < 0}, or
1589      * {@code i_offset > indexMap.length - this.length()},
1590      * or for any vector lane index {@code N} where the mask at lane
1591      * {@code N} is set the result of {@code a_offset + indexMap[i_offset + N]} is
1592      * {@code < 0} or {@code >= a.length}
1593      */
1594     public void intoArray(short[] a, int a_offset, VectorMask<Short> m, int[] indexMap, int i_offset) {
1595         forEach(m, (n, e) -> a[a_offset + indexMap[i_offset + n]] = e);
1596     }
1597     // Species
1598 
1599     /**
1600      * {@inheritDoc}
1601      */
1602     @Override
1603     public abstract VectorSpecies<Short> species();
1604 
1605     /**
1606      * Class representing {@link ShortVector}'s of the same {@link VectorShape VectorShape}.
1607      */
1608     static final class ShortSpecies extends AbstractSpecies<Short> {
1609         final Function<short[], ShortVector> vectorFactory;
1610 
1611         private ShortSpecies(VectorShape shape,
1612                           Class<?> vectorType,
1613                           Class<?> maskType,
1614                           Function<short[], ShortVector> vectorFactory,
1615                           Function<boolean[], VectorMask<Short>> maskFactory,
1616                           Function<IntUnaryOperator, VectorShuffle<Short>> shuffleFromArrayFactory,
1617                           fShuffleFromArray<Short> shuffleFromOpFactory) {
1618             super(shape, short.class, Short.SIZE, vectorType, maskType, maskFactory,
1619                   shuffleFromArrayFactory, shuffleFromOpFactory);
1620             this.vectorFactory = vectorFactory;
1621         }
1622 
1623         interface FOp {
1624             short apply(int i);
1625         }
1626 
1627         ShortVector op(FOp f) {
1628             short[] res = new short[length()];
1629             for (int i = 0; i < length(); i++) {
1630                 res[i] = f.apply(i);
1631             }
1632             return vectorFactory.apply(res);
1633         }
1634 
1635         ShortVector op(VectorMask<Short> o, FOp f) {
1636             short[] res = new short[length()];
1637             boolean[] mbits = ((AbstractMask<Short>)o).getBits();
1638             for (int i = 0; i < length(); i++) {
1639                 if (mbits[i]) {
1640                     res[i] = f.apply(i);
1641                 }
1642             }
1643             return vectorFactory.apply(res);
1644         }
1645     }
1646 
1647     /**
1648      * Finds the preferred species for an element type of {@code short}.
1649      * <p>
1650      * A preferred species is a species chosen by the platform that has a
1651      * shape of maximal bit size.  A preferred species for different element
1652      * types will have the same shape, and therefore vectors, masks, and
1653      * shuffles created from such species will be shape compatible.
1654      *
1655      * @return the preferred species for an element type of {@code short}
1656      */
1657     private static ShortSpecies preferredSpecies() {
1658         return (ShortSpecies) VectorSpecies.ofPreferred(short.class);
1659     }
1660 
1661     /**
1662      * Finds a species for an element type of {@code short} and shape.
1663      *
1664      * @param s the shape
1665      * @return a species for an element type of {@code short} and shape
1666      * @throws IllegalArgumentException if no such species exists for the shape
1667      */
1668     static ShortSpecies species(VectorShape s) {
1669         Objects.requireNonNull(s);
1670         switch (s) {
1671             case S_64_BIT: return (ShortSpecies) SPECIES_64;
1672             case S_128_BIT: return (ShortSpecies) SPECIES_128;
1673             case S_256_BIT: return (ShortSpecies) SPECIES_256;
1674             case S_512_BIT: return (ShortSpecies) SPECIES_512;
1675             case S_Max_BIT: return (ShortSpecies) SPECIES_MAX;
1676             default: throw new IllegalArgumentException("Bad shape: " + s);
1677         }
1678     }
1679 
1680     /** Species representing {@link ShortVector}s of {@link VectorShape#S_64_BIT VectorShape.S_64_BIT}. */
1681     public static final VectorSpecies<Short> SPECIES_64 = new ShortSpecies(VectorShape.S_64_BIT, Short64Vector.class, Short64Vector.Short64Mask.class,
1682                                                                      Short64Vector::new, Short64Vector.Short64Mask::new,
1683                                                                      Short64Vector.Short64Shuffle::new, Short64Vector.Short64Shuffle::new);
1684 
1685     /** Species representing {@link ShortVector}s of {@link VectorShape#S_128_BIT VectorShape.S_128_BIT}. */
1686     public static final VectorSpecies<Short> SPECIES_128 = new ShortSpecies(VectorShape.S_128_BIT, Short128Vector.class, Short128Vector.Short128Mask.class,
1687                                                                       Short128Vector::new, Short128Vector.Short128Mask::new,
1688                                                                       Short128Vector.Short128Shuffle::new, Short128Vector.Short128Shuffle::new);
1689 
1690     /** Species representing {@link ShortVector}s of {@link VectorShape#S_256_BIT VectorShape.S_256_BIT}. */
1691     public static final VectorSpecies<Short> SPECIES_256 = new ShortSpecies(VectorShape.S_256_BIT, Short256Vector.class, Short256Vector.Short256Mask.class,
1692                                                                       Short256Vector::new, Short256Vector.Short256Mask::new,
1693                                                                       Short256Vector.Short256Shuffle::new, Short256Vector.Short256Shuffle::new);
1694 
1695     /** Species representing {@link ShortVector}s of {@link VectorShape#S_512_BIT VectorShape.S_512_BIT}. */
1696     public static final VectorSpecies<Short> SPECIES_512 = new ShortSpecies(VectorShape.S_512_BIT, Short512Vector.class, Short512Vector.Short512Mask.class,
1697                                                                       Short512Vector::new, Short512Vector.Short512Mask::new,
1698                                                                       Short512Vector.Short512Shuffle::new, Short512Vector.Short512Shuffle::new);
1699 
1700     /** Species representing {@link ShortVector}s of {@link VectorShape#S_Max_BIT VectorShape.S_Max_BIT}. */
1701     public static final VectorSpecies<Short> SPECIES_MAX = new ShortSpecies(VectorShape.S_Max_BIT, ShortMaxVector.class, ShortMaxVector.ShortMaxMask.class,
1702                                                                       ShortMaxVector::new, ShortMaxVector.ShortMaxMask::new,
1703                                                                       ShortMaxVector.ShortMaxShuffle::new, ShortMaxVector.ShortMaxShuffle::new);
1704 
1705     /**
1706      * Preferred species for {@link ShortVector}s.
1707      * A preferred species is a species of maximal bit size for the platform.
1708      */
1709     public static final VectorSpecies<Short> SPECIES_PREFERRED = (VectorSpecies<Short>) preferredSpecies();
1710 }