Class ShortVector


  • public abstract class ShortVector
    extends Vector<Short>
    A specialized Vector representing an ordered immutable sequence of short values.
    • Method Detail

      • zero

        public static ShortVector zero​(VectorSpecies<Short> species)
        Returns a vector where all lane elements are set to the default primitive value.
        Parameters:
        species - species of desired vector
        Returns:
        a zero vector of given species
      • fromByteArray

        public static ShortVector fromByteArray​(VectorSpecies<Short> species,
                                                byte[] a,
                                                int offset)
        Loads a vector from a byte array starting at an offset.

        Bytes are composed into primitive lane elements according to the native byte order of the underlying platform

        This method behaves as if it returns the result of calling the byte buffer, offset, and mask accepting method as follows:

        
         return fromByteBuffer(species, ByteBuffer.wrap(a), offset, VectorMask.allTrue());
         
        Parameters:
        species - species of desired vector
        a - the byte array
        offset - the offset into the array
        Returns:
        a vector loaded from a byte array
        Throws:
        IndexOutOfBoundsException - if i < 0 or offset > a.length - (species.length() * species.elementSize() / Byte.SIZE)
      • fromByteArray

        public static ShortVector fromByteArray​(VectorSpecies<Short> species,
                                                byte[] a,
                                                int offset,
                                                VectorMask<Short> m)
        Loads a vector from a byte array starting at an offset and using a mask.

        Bytes are composed into primitive lane elements according to the native byte order of the underlying platform.

        This method behaves as if it returns the result of calling the byte buffer, offset, and mask accepting method as follows:

        
         return fromByteBuffer(species, ByteBuffer.wrap(a), offset, m);
         
        Parameters:
        species - species of desired vector
        a - the byte array
        offset - the offset into the array
        m - the mask
        Returns:
        a vector loaded from a byte array
        Throws:
        IndexOutOfBoundsException - if offset < 0 or for any vector lane index N where the mask at lane N is set offset >= a.length - (N * species.elementSize() / Byte.SIZE)
      • fromArray

        public static ShortVector fromArray​(VectorSpecies<Short> species,
                                            short[] a,
                                            int offset)
        Loads a vector from an array starting at offset.

        For each vector lane, where N is the vector lane index, the array element at index offset + N is placed into the resulting vector at lane index N.

        Parameters:
        species - species of desired vector
        a - the array
        offset - the offset into the array
        Returns:
        the vector loaded from an array
        Throws:
        IndexOutOfBoundsException - if offset < 0, or offset > a.length - species.length()
      • fromArray

        public static ShortVector fromArray​(VectorSpecies<Short> species,
                                            short[] a,
                                            int offset,
                                            VectorMask<Short> m)
        Loads a vector from an array starting at offset and using a mask.

        For each vector lane, where N is the vector lane index, if the mask lane at index N is set then the array element at index offset + N is placed into the resulting vector at lane index N, otherwise the default element value is placed into the resulting vector at lane index N.

        Parameters:
        species - species of desired vector
        a - the array
        offset - the offset into the array
        m - the mask
        Returns:
        the vector loaded from an array
        Throws:
        IndexOutOfBoundsException - if offset < 0, or for any vector lane index N where the mask at lane N is set offset > a.length - N
      • fromArray

        public static ShortVector fromArray​(VectorSpecies<Short> species,
                                            short[] a,
                                            int a_offset,
                                            int[] indexMap,
                                            int i_offset)
        Loads a vector from an array using indexes obtained from an index map.

        For each vector lane, where N is the vector lane index, the array element at index a_offset + indexMap[i_offset + N] is placed into the resulting vector at lane index N.

        Parameters:
        species - species of desired vector
        a - the array
        a_offset - the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds
        indexMap - the index map
        i_offset - the offset into the index map
        Returns:
        the vector loaded from an array
        Throws:
        IndexOutOfBoundsException - if i_offset < 0, or i_offset > indexMap.length - species.length(), or for any vector lane index N the result of a_offset + indexMap[i_offset + N] is < 0 or >= a.length
      • fromArray

        public static ShortVector fromArray​(VectorSpecies<Short> species,
                                            short[] a,
                                            int a_offset,
                                            VectorMask<Short> m,
                                            int[] indexMap,
                                            int i_offset)
        Loads a vector from an array using indexes obtained from an index map and using a mask.

        For each vector lane, where N is the vector lane index, if the mask lane at index N is set then the array element at index a_offset + indexMap[i_offset + N] is placed into the resulting vector at lane index N.

        Parameters:
        species - species of desired vector
        a - the array
        a_offset - the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds
        m - the mask
        indexMap - the index map
        i_offset - the offset into the index map
        Returns:
        the vector loaded from an array
        Throws:
        IndexOutOfBoundsException - if i_offset < 0, or i_offset > indexMap.length - species.length(), or for any vector lane index N where the mask at lane N is set the result of a_offset + indexMap[i_offset + N] is < 0 or >= a.length
      • fromByteBuffer

        public static ShortVector fromByteBuffer​(VectorSpecies<Short> species,
                                                 ByteBuffer bb,
                                                 int offset)
        Loads a vector from a byte buffer starting at an offset into the byte buffer.

        Bytes are composed into primitive lane elements according to the native byte order of the underlying platform.

        This method behaves as if it returns the result of calling the byte buffer, offset, and mask accepting fromByteBuffer(VectorSpecies, ByteBuffer, int, VectorMask) method} as follows:

        
           return fromByteBuffer(b, offset, VectorMask.allTrue())
         
        Parameters:
        species - species of desired vector
        bb - the byte buffer
        offset - the offset into the byte buffer
        Returns:
        a vector loaded from a byte buffer
        Throws:
        IndexOutOfBoundsException - if the offset is < 0, or > b.limit(), or if there are fewer than species.length() * species.elementSize() / Byte.SIZE bytes remaining in the byte buffer from the given offset
      • fromByteBuffer

        public static ShortVector fromByteBuffer​(VectorSpecies<Short> species,
                                                 ByteBuffer bb,
                                                 int offset,
                                                 VectorMask<Short> m)
        Loads a vector from a byte buffer starting at an offset into the byte buffer and using a mask.

        This method behaves as if the byte buffer is viewed as a primitive buffer for the primitive element type, according to the native byte order of the underlying platform, and the returned vector is loaded with a mask from a primitive array obtained from the primitive buffer. The following pseudocode expresses the behaviour, where EBuffer is the primitive buffer type, e is the primitive element type, and ESpecies is the primitive species for e:

        
         EBuffer eb = b.duplicate().
             order(ByteOrder.nativeOrder()).position(offset).
             asEBuffer();
         e[] es = new e[species.length()];
         for (int n = 0; n < t.length; n++) {
             if (m.isSet(n))
                 es[n] = eb.get(n);
         }
         EVector r = EVector.fromArray(es, 0, m);
         
        Parameters:
        species - species of desired vector
        bb - the byte buffer
        offset - the offset into the byte buffer
        m - the mask
        Returns:
        a vector loaded from a byte buffer
        Throws:
        IndexOutOfBoundsException - if the offset is < 0, or > b.limit(), for any vector lane index N where the mask at lane N is set offset >= b.limit() - (N * species.elementSize() / Byte.SIZE)
      • broadcast

        public static ShortVector broadcast​(VectorSpecies<Short> species,
                                            short e)
        Returns a vector where all lane elements are set to the primitive value e.
        Parameters:
        species - species of the desired vector
        e - the value to be broadcasted
        Returns:
        a vector of vector where all lane elements are set to the primitive value e
      • scalars

        public static ShortVector scalars​(VectorSpecies<Short> species,
                                          short... es)
        Returns a vector where each lane element is set to given primitive values.

        For each vector lane, where N is the vector lane index, the the primitive value at index N is placed into the resulting vector at lane index N.

        Parameters:
        species - species of the desired vector
        es - the given primitive values
        Returns:
        a vector where each lane element is set to given primitive values
        Throws:
        IndexOutOfBoundsException - if es.length < species.length()
      • single

        public static final ShortVector single​(VectorSpecies<Short> species,
                                               short e)
        Returns a vector where the first lane element is set to the primtive value e, all other lane elements are set to the default value.
        Parameters:
        species - species of the desired vector
        e - the value
        Returns:
        a vector where the first lane element is set to the primitive value e
      • random

        public static ShortVector random​(VectorSpecies<Short> species)
        Returns a vector where each lane element is set to a randomly generated primitive value. The semantics are equivalent to calling (short)ThreadLocalRandom.nextInt()
        Parameters:
        species - species of the desired vector
        Returns:
        a vector where each lane elements is set to a randomly generated primitive value
      • add

        public abstract ShortVector add​(short s)
        Adds this vector to the broadcast of an input scalar.

        This is a lane-wise binary operation which applies the primitive addition operation (+) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the result of adding this vector to the broadcast of an input scalar
      • add

        public abstract ShortVector add​(short s,
                                        VectorMask<Short> m)
        Adds this vector to broadcast of an input scalar, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive addition operation (+) to each lane.

        Parameters:
        s - the input scalar
        m - the mask controlling lane selection
        Returns:
        the result of adding this vector to the broadcast of an input scalar
      • sub

        public abstract ShortVector sub​(short s)
        Subtracts the broadcast of an input scalar from this vector.

        This is a lane-wise binary operation which applies the primitive subtraction operation (-) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the result of subtracting the broadcast of an input scalar from this vector
      • sub

        public abstract ShortVector sub​(short s,
                                        VectorMask<Short> m)
        Subtracts the broadcast of an input scalar from this vector, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive subtraction operation (-) to each lane.

        Parameters:
        s - the input scalar
        m - the mask controlling lane selection
        Returns:
        the result of subtracting the broadcast of an input scalar from this vector
      • mul

        public abstract ShortVector mul​(short s)
        Multiplies this vector with the broadcast of an input scalar.

        This is a lane-wise binary operation which applies the primitive multiplication operation (*) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the result of multiplying this vector with the broadcast of an input scalar
      • mul

        public abstract ShortVector mul​(short s,
                                        VectorMask<Short> m)
        Multiplies this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive multiplication operation (*) to each lane.

        Parameters:
        s - the input scalar
        m - the mask controlling lane selection
        Returns:
        the result of multiplying this vector with the broadcast of an input scalar
      • min

        public abstract ShortVector min​(short s)
        Returns the minimum of this vector and the broadcast of an input scalar.

        This is a lane-wise binary operation which applies the operation (a, b) -> Math.min(a, b) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the minimum of this vector and the broadcast of an input scalar
      • max

        public abstract ShortVector max​(short s)
        Returns the maximum of this vector and the broadcast of an input scalar.

        This is a lane-wise binary operation which applies the operation (a, b) -> Math.max(a, b) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the maximum of this vector and the broadcast of an input scalar
      • equal

        public abstract VectorMask<Short> equal​(short s)
        Tests if this vector is equal to the broadcast of an input scalar.

        This is a lane-wise binary test operation which applies the primitive equals operation (==) each lane.

        Parameters:
        s - the input scalar
        Returns:
        the result mask of testing if this vector is equal to the broadcast of an input scalar
      • notEqual

        public abstract VectorMask<Short> notEqual​(short s)
        Tests if this vector is not equal to the broadcast of an input scalar.

        This is a lane-wise binary test operation which applies the primitive not equals operation (!=) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the result mask of testing if this vector is not equal to the broadcast of an input scalar
      • lessThan

        public abstract VectorMask<Short> lessThan​(short s)
        Tests if this vector is less than the broadcast of an input scalar.

        This is a lane-wise binary test operation which applies the primitive less than operation (<) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the mask result of testing if this vector is less than the broadcast of an input scalar
      • lessThanEq

        public abstract VectorMask<Short> lessThanEq​(short s)
        Tests if this vector is less or equal to the broadcast of an input scalar.

        This is a lane-wise binary test operation which applies the primitive less than or equal to operation (<=) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the mask result of testing if this vector is less than or equal to the broadcast of an input scalar
      • greaterThan

        public abstract VectorMask<Short> greaterThan​(short s)
        Tests if this vector is greater than the broadcast of an input scalar.

        This is a lane-wise binary test operation which applies the primitive greater than operation (>) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the mask result of testing if this vector is greater than the broadcast of an input scalar
      • greaterThanEq

        public abstract VectorMask<Short> greaterThanEq​(short s)
        Tests if this vector is greater than or equal to the broadcast of an input scalar.

        This is a lane-wise binary test operation which applies the primitive greater than or equal to operation (>=) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the mask result of testing if this vector is greater than or equal to the broadcast of an input scalar
      • blend

        public abstract ShortVector blend​(short s,
                                          VectorMask<Short> m)
        Blends the lane elements of this vector with those of the broadcast of an input scalar, selecting lanes controlled by a mask.

        For each lane of the mask, at lane index N, if the mask lane is set then the lane element at N from the input vector is selected and placed into the resulting vector at N, otherwise the the lane element at N from this input vector is selected and placed into the resulting vector at N.

        Parameters:
        s - the input scalar
        m - the mask controlling lane selection
        Returns:
        the result of blending the lane elements of this vector with those of the broadcast of an input scalar
      • and

        public abstract ShortVector and​(Vector<Short> v)
        Bitwise ANDs this vector with an input vector.

        This is a lane-wise binary operation which applies the primitive bitwise AND operation (&) to each lane.

        Parameters:
        v - the input vector
        Returns:
        the bitwise AND of this vector with the input vector
      • and

        public abstract ShortVector and​(short s)
        Bitwise ANDs this vector with the broadcast of an input scalar.

        This is a lane-wise binary operation which applies the primitive bitwise AND operation (&) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the bitwise AND of this vector with the broadcast of an input scalar
      • and

        public abstract ShortVector and​(Vector<Short> v,
                                        VectorMask<Short> m)
        Bitwise ANDs this vector with an input vector, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive bitwise AND operation (&) to each lane.

        Parameters:
        v - the input vector
        m - the mask controlling lane selection
        Returns:
        the bitwise AND of this vector with the input vector
      • and

        public abstract ShortVector and​(short s,
                                        VectorMask<Short> m)
        Bitwise ANDs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive bitwise AND operation (&) to each lane.

        Parameters:
        s - the input scalar
        m - the mask controlling lane selection
        Returns:
        the bitwise AND of this vector with the broadcast of an input scalar
      • or

        public abstract ShortVector or​(Vector<Short> v)
        Bitwise ORs this vector with an input vector.

        This is a lane-wise binary operation which applies the primitive bitwise OR operation (|) to each lane.

        Parameters:
        v - the input vector
        Returns:
        the bitwise OR of this vector with the input vector
      • or

        public abstract ShortVector or​(short s)
        Bitwise ORs this vector with the broadcast of an input scalar.

        This is a lane-wise binary operation which applies the primitive bitwise OR operation (|) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the bitwise OR of this vector with the broadcast of an input scalar
      • or

        public abstract ShortVector or​(Vector<Short> v,
                                       VectorMask<Short> m)
        Bitwise ORs this vector with an input vector, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive bitwise OR operation (|) to each lane.

        Parameters:
        v - the input vector
        m - the mask controlling lane selection
        Returns:
        the bitwise OR of this vector with the input vector
      • or

        public abstract ShortVector or​(short s,
                                       VectorMask<Short> m)
        Bitwise ORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive bitwise OR operation (|) to each lane.

        Parameters:
        s - the input scalar
        m - the mask controlling lane selection
        Returns:
        the bitwise OR of this vector with the broadcast of an input scalar
      • xor

        public abstract ShortVector xor​(Vector<Short> v)
        Bitwise XORs this vector with an input vector.

        This is a lane-wise binary operation which applies the primitive bitwise XOR operation (^) to each lane.

        Parameters:
        v - the input vector
        Returns:
        the bitwise XOR of this vector with the input vector
      • xor

        public abstract ShortVector xor​(short s)
        Bitwise XORs this vector with the broadcast of an input scalar.

        This is a lane-wise binary operation which applies the primitive bitwise XOR operation (^) to each lane.

        Parameters:
        s - the input scalar
        Returns:
        the bitwise XOR of this vector with the broadcast of an input scalar
      • xor

        public abstract ShortVector xor​(Vector<Short> v,
                                        VectorMask<Short> m)
        Bitwise XORs this vector with an input vector, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive bitwise XOR operation (^) to each lane.

        Parameters:
        v - the input vector
        m - the mask controlling lane selection
        Returns:
        the bitwise XOR of this vector with the input vector
      • xor

        public abstract ShortVector xor​(short s,
                                        VectorMask<Short> m)
        Bitwise XORs this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive bitwise XOR operation (^) to each lane.

        Parameters:
        s - the input scalar
        m - the mask controlling lane selection
        Returns:
        the bitwise XOR of this vector with the broadcast of an input scalar
      • not

        public abstract ShortVector not()
        Bitwise NOTs this vector.

        This is a lane-wise unary operation which applies the primitive bitwise NOT operation (~) to each lane.

        Returns:
        the bitwise NOT of this vector
      • not

        public abstract ShortVector not​(VectorMask<Short> m)
        Bitwise NOTs this vector, selecting lane elements controlled by a mask.

        This is a lane-wise unary operation which applies the primitive bitwise NOT operation (~) to each lane.

        Parameters:
        m - the mask controlling lane selection
        Returns:
        the bitwise NOT of this vector
      • shiftLeft

        public abstract ShortVector shiftLeft​(int s)
        Logically left shifts this vector by the broadcast of an input scalar.

        This is a lane-wise binary operation which applies the primitive logical left shift operation (<<) to each lane to left shift the element by shift value as specified by the input scalar. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        s - the input scalar; the number of the bits to left shift
        Returns:
        the result of logically left shifting this vector by the broadcast of an input scalar
      • shiftLeft

        public abstract ShortVector shiftLeft​(int s,
                                              VectorMask<Short> m)
        Logically left shifts this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive logical left shift operation (<<) to each lane to left shift the element by shift value as specified by the input scalar. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        s - the input scalar; the number of the bits to left shift
        m - the mask controlling lane selection
        Returns:
        the result of logically left shifting this vector by the broadcast of an input scalar
      • shiftLeft

        public abstract ShortVector shiftLeft​(Vector<Short> v)
        Logically left shifts this vector by an input vector.

        This is a lane-wise binary operation which applies the primitive logical left shift operation (<<) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        v - the input vector
        Returns:
        the result of logically left shifting this vector by the input vector
      • shiftLeft

        public ShortVector shiftLeft​(Vector<Short> v,
                                     VectorMask<Short> m)
        Logically left shifts this vector by an input vector, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive logical left shift operation (<<) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        v - the input vector
        m - the mask controlling lane selection
        Returns:
        the result of logically left shifting this vector by the input vector
      • shiftRight

        public abstract ShortVector shiftRight​(int s)
        Logically right shifts (or unsigned right shifts) this vector by the broadcast of an input scalar.

        This is a lane-wise binary operation which applies the primitive logical right shift operation (>>>) to each lane to logically right shift the element by shift value as specified by the input scalar. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        s - the input scalar; the number of the bits to right shift
        Returns:
        the result of logically right shifting this vector by the broadcast of an input scalar
      • shiftRight

        public abstract ShortVector shiftRight​(int s,
                                               VectorMask<Short> m)
        Logically right shifts (or unsigned right shifts) this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive logical right shift operation (>>) to each lane to logically right shift the element by shift value as specified by the input scalar. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        s - the input scalar; the number of the bits to right shift
        m - the mask controlling lane selection
        Returns:
        the result of logically right shifting this vector by the broadcast of an input scalar
      • shiftRight

        public abstract ShortVector shiftRight​(Vector<Short> v)
        Logically right shifts (or unsigned right shifts) this vector by an input vector.

        This is a lane-wise binary operation which applies the primitive logical right shift operation (>>>) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        v - the input vector
        Returns:
        the result of logically right shifting this vector by the input vector
      • shiftRight

        public ShortVector shiftRight​(Vector<Short> v,
                                      VectorMask<Short> m)
        Logically right shifts (or unsigned right shifts) this vector by an input vector, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive logical right shift operation (>>>) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        v - the input vector
        m - the mask controlling lane selection
        Returns:
        the result of logically right shifting this vector by the input vector
      • shiftArithmeticRight

        public abstract ShortVector shiftArithmeticRight​(int s)
        Arithmetically right shifts (or signed right shifts) this vector by the broadcast of an input scalar.

        This is a lane-wise binary operation which applies the primitive arithmetic right shift operation (>>) to each lane to arithmetically right shift the element by shift value as specified by the input scalar. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        s - the input scalar; the number of the bits to right shift
        Returns:
        the result of arithmetically right shifting this vector by the broadcast of an input scalar
      • shiftArithmeticRight

        public abstract ShortVector shiftArithmeticRight​(int s,
                                                         VectorMask<Short> m)
        Arithmetically right shifts (or signed right shifts) this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive arithmetic right shift operation (>>) to each lane to arithmetically right shift the element by shift value as specified by the input scalar. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        s - the input scalar; the number of the bits to right shift
        m - the mask controlling lane selection
        Returns:
        the result of arithmetically right shifting this vector by the broadcast of an input scalar
      • shiftArithmeticRight

        public abstract ShortVector shiftArithmeticRight​(Vector<Short> v)
        Arithmetically right shifts (or signed right shifts) this vector by an input vector.

        This is a lane-wise binary operation which applies the primitive arithmetic right shift operation (>>) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        v - the input vector
        Returns:
        the result of arithmetically right shifting this vector by the input vector
      • shiftArithmeticRight

        public ShortVector shiftArithmeticRight​(Vector<Short> v,
                                                VectorMask<Short> m)
        Arithmetically right shifts (or signed right shifts) this vector by an input vector, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which applies the primitive arithmetic right shift operation (>>) to each lane. For each lane of this vector, the shift value is the corresponding lane of input vector. Only the 4 lowest-order bits of shift value are used. It is as if the shift value were subjected to a bitwise logical AND operator (&) with the mask value 0xF. The shift distance actually used is therefore always in the range 0 to 15, inclusive.

        Parameters:
        v - the input vector
        m - the mask controlling lane selection
        Returns:
        the result of arithmetically right shifting this vector by the input vector
      • rotateLeft

        public final ShortVector rotateLeft​(int s)
        Rotates left this vector by the broadcast of an input scalar.

        This is a lane-wise binary operation which produces the result of rotating left the two's complement binary representation of each lane of first operand (this vector) by input scalar. Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. It is as if the input value were subjected to a bitwise logical AND operator (&) with the mask value 0xF.

        Parameters:
        s - the input scalar; the number of the bits to rotate left
        Returns:
        the result of rotating left this vector by the broadcast of an input scalar
      • rotateLeft

        public final ShortVector rotateLeft​(int s,
                                            VectorMask<Short> m)
        Rotates left this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which produces the result of rotating left the two's complement binary representation of each lane of first operand (this vector) by input scalar. Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. It is as if the input value were subjected to a bitwise logical AND operator (&) with the mask value 0xF.

        Parameters:
        s - the input scalar; the number of the bits to rotate left
        m - the mask controlling lane selection
        Returns:
        the result of rotating left this vector by the broadcast of an input scalar
      • rotateRight

        public final ShortVector rotateRight​(int s)
        Rotates right this vector by the broadcast of an input scalar.

        This is a lane-wise binary operation which produces the result of rotating right the two's complement binary representation of each lane of first operand (this vector) by input scalar. Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. It is as if the input value were subjected to a bitwise logical AND operator (&) with the mask value 0xF.

        Parameters:
        s - the input scalar; the number of the bits to rotate right
        Returns:
        the result of rotating right this vector by the broadcast of an input scalar
      • rotateRight

        public final ShortVector rotateRight​(int s,
                                             VectorMask<Short> m)
        Rotates right this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.

        This is a lane-wise binary operation which produces the result of rotating right the two's complement binary representation of each lane of first operand (this vector) by input scalar. Rotation by any multiple of 16 is a no-op, so only the 4 lowest-order bits of input value are used. It is as if the input value were subjected to a bitwise logical AND operator (&) with the mask value 0xF.

        Parameters:
        s - the input scalar; the number of the bits to rotate right
        m - the mask controlling lane selection
        Returns:
        the result of rotating right this vector by the broadcast of an input scalar
      • addLanes

        public abstract short addLanes()
        Adds all lane elements of this vector.

        This is an associative cross-lane reduction operation which applies the addition operation (+) to lane elements, and the identity value is 0.

        Returns:
        the addition of all the lane elements of this vector
      • addLanes

        public abstract short addLanes​(VectorMask<Short> m)
        Adds all lane elements of this vector, selecting lane elements controlled by a mask.

        This is an associative cross-lane reduction operation which applies the addition operation (+) to lane elements, and the identity value is 0.

        Parameters:
        m - the mask controlling lane selection
        Returns:
        the addition of the selected lane elements of this vector
      • mulLanes

        public abstract short mulLanes()
        Multiplies all lane elements of this vector.

        This is an associative cross-lane reduction operation which applies the multiplication operation (*) to lane elements, and the identity value is 1.

        Returns:
        the multiplication of all the lane elements of this vector
      • mulLanes

        public abstract short mulLanes​(VectorMask<Short> m)
        Multiplies all lane elements of this vector, selecting lane elements controlled by a mask.

        This is an associative cross-lane reduction operation which applies the multiplication operation (*) to lane elements, and the identity value is 1.

        Parameters:
        m - the mask controlling lane selection
        Returns:
        the multiplication of all the lane elements of this vector
      • minLanes

        public abstract short minLanes()
        Returns the minimum lane element of this vector.

        This is an associative cross-lane reduction operation which applies the operation (a, b) -> Math.min(a, b) to lane elements, and the identity value is Short.MAX_VALUE.

        Returns:
        the minimum lane element of this vector
      • minLanes

        public abstract short minLanes​(VectorMask<Short> m)
        Returns the minimum lane element of this vector, selecting lane elements controlled by a mask.

        This is an associative cross-lane reduction operation which applies the operation (a, b) -> Math.min(a, b) to lane elements, and the identity value is Short.MAX_VALUE.

        Parameters:
        m - the mask controlling lane selection
        Returns:
        the minimum lane element of this vector
      • maxLanes

        public abstract short maxLanes()
        Returns the maximum lane element of this vector.

        This is an associative cross-lane reduction operation which applies the operation (a, b) -> Math.max(a, b) to lane elements, and the identity value is Short.MIN_VALUE.

        Returns:
        the maximum lane element of this vector
      • maxLanes

        public abstract short maxLanes​(VectorMask<Short> m)
        Returns the maximum lane element of this vector, selecting lane elements controlled by a mask.

        This is an associative cross-lane reduction operation which applies the operation (a, b) -> Math.max(a, b) to lane elements, and the identity value is Short.MIN_VALUE.

        Parameters:
        m - the mask controlling lane selection
        Returns:
        the maximum lane element of this vector
      • orLanes

        public abstract short orLanes()
        Logically ORs all lane elements of this vector.

        This is an associative cross-lane reduction operation which applies the logical OR operation (|) to lane elements, and the identity value is 0.

        Returns:
        the logical OR all the lane elements of this vector
      • orLanes

        public abstract short orLanes​(VectorMask<Short> m)
        Logically ORs all lane elements of this vector, selecting lane elements controlled by a mask.

        This is an associative cross-lane reduction operation which applies the logical OR operation (|) to lane elements, and the identity value is 0.

        Parameters:
        m - the mask controlling lane selection
        Returns:
        the logical OR all the lane elements of this vector
      • andLanes

        public abstract short andLanes()
        Logically ANDs all lane elements of this vector.

        This is an associative cross-lane reduction operation which applies the logical AND operation (|) to lane elements, and the identity value is -1.

        Returns:
        the logical AND all the lane elements of this vector
      • andLanes

        public abstract short andLanes​(VectorMask<Short> m)
        Logically ANDs all lane elements of this vector, selecting lane elements controlled by a mask.

        This is an associative cross-lane reduction operation which applies the logical AND operation (|) to lane elements, and the identity value is -1.

        Parameters:
        m - the mask controlling lane selection
        Returns:
        the logical AND all the lane elements of this vector
      • xorLanes

        public abstract short xorLanes()
        Logically XORs all lane elements of this vector.

        This is an associative cross-lane reduction operation which applies the logical XOR operation (^) to lane elements, and the identity value is 0.

        Returns:
        the logical XOR all the lane elements of this vector
      • xorLanes

        public abstract short xorLanes​(VectorMask<Short> m)
        Logically XORs all lane elements of this vector, selecting lane elements controlled by a mask.

        This is an associative cross-lane reduction operation which applies the logical XOR operation (^) to lane elements, and the identity value is 0.

        Parameters:
        m - the mask controlling lane selection
        Returns:
        the logical XOR all the lane elements of this vector
      • lane

        public abstract short lane​(int i)
        Gets the lane element at lane index i
        Parameters:
        i - the lane index
        Returns:
        the lane element at lane index i
        Throws:
        IllegalArgumentException - if the index is is out of range (< 0 || >= length())
      • with

        public abstract ShortVector with​(int i,
                                         short e)
        Replaces the lane element of this vector at lane index i with value e.

        This is a cross-lane operation and behaves as if it returns the result of blending this vector with an input vector that is the result of broadcasting e and a mask that has only one lane set at lane index i.

        Parameters:
        i - the lane index of the lane element to be replaced
        e - the value to be placed
        Returns:
        the result of replacing the lane element of this vector at lane index i with value e.
        Throws:
        IllegalArgumentException - if the index is is out of range (< 0 || >= length())
      • toArray

        public final short[] toArray()
        Returns an array containing the lane elements of this vector.

        This method behaves as if it intoArray(short[], int) stores} this vector into an allocated array and returns the array as follows:

        
           short[] a = new short[this.length()];
           this.intoArray(a, 0);
           return a;
         
        Returns:
        an array containing the the lane elements of this vector
      • intoArray

        public abstract void intoArray​(short[] a,
                                       int offset)
        Stores this vector into an array starting at offset.

        For each vector lane, where N is the vector lane index, the lane element at index N is stored into the array at index offset + N.

        Parameters:
        a - the array
        offset - the offset into the array
        Throws:
        IndexOutOfBoundsException - if offset < 0, or offset > a.length - this.length()
      • intoArray

        public abstract void intoArray​(short[] a,
                                       int offset,
                                       VectorMask<Short> m)
        Stores this vector into an array starting at offset and using a mask.

        For each vector lane, where N is the vector lane index, if the mask lane at index N is set then the lane element at index N is stored into the array index offset + N.

        Parameters:
        a - the array
        offset - the offset into the array
        m - the mask
        Throws:
        IndexOutOfBoundsException - if offset < 0, or for any vector lane index N where the mask at lane N is set offset >= a.length - N
      • intoArray

        public void intoArray​(short[] a,
                              int a_offset,
                              int[] indexMap,
                              int i_offset)
        Stores this vector into an array using indexes obtained from an index map.

        For each vector lane, where N is the vector lane index, the lane element at index N is stored into the array at index a_offset + indexMap[i_offset + N].

        Parameters:
        a - the array
        a_offset - the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds
        indexMap - the index map
        i_offset - the offset into the index map
        Throws:
        IndexOutOfBoundsException - if i_offset < 0, or i_offset > indexMap.length - this.length(), or for any vector lane index N the result of a_offset + indexMap[i_offset + N] is < 0 or >= a.length
      • intoArray

        public void intoArray​(short[] a,
                              int a_offset,
                              VectorMask<Short> m,
                              int[] indexMap,
                              int i_offset)
        Stores this vector into an array using indexes obtained from an index map and using a mask.

        For each vector lane, where N is the vector lane index, if the mask lane at index N is set then the lane element at index N is stored into the array at index a_offset + indexMap[i_offset + N].

        Parameters:
        a - the array
        a_offset - the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds
        m - the mask
        indexMap - the index map
        i_offset - the offset into the index map
        Throws:
        IndexOutOfBoundsException - if j < 0, or i_offset > indexMap.length - this.length(), or for any vector lane index N where the mask at lane N is set the result of a_offset + indexMap[i_offset + N] is < 0 or >= a.length