# Class DoubleVector

• ```public abstract class DoubleVector
extends Vector<Double>```
A specialized `Vector` representing an ordered immutable sequence of `double` values.
• ## Method Summary

Modifier and Type Method Description
`DoubleVector` `acos()`
Calculates the arc cosine of this vector.
`DoubleVector` `acos​(Mask<Double> m)`
Calculates the arc cosine of this vector, selecting lane elements controlled by a mask.
`abstract DoubleVector` `add​(double s)`
`abstract DoubleVector` ```add​(double s, Mask<Double> m)```
`abstract double` `addAll()`
Adds all lane elements of this vector.
`abstract double` `addAll​(Mask<Double> m)`
Adds all lane elements of this vector, selecting lane elements controlled by a mask.
`DoubleVector` `asin()`
Calculates the arc sine of this vector.
`DoubleVector` `asin​(Mask<Double> m)`
Calculates the arc sine of this vector, selecting lane elements controlled by a mask.
`DoubleVector` `atan()`
Calculates the arc tangent of this vector.
`DoubleVector` `atan​(Mask<Double> m)`
Calculates the arc tangent of this vector, selecting lane elements controlled by a mask.
`abstract DoubleVector` `atan2​(double s)`
Calculates the arc tangent of this vector divided by the broadcast of an an input scalar.
`abstract DoubleVector` ```atan2​(double s, Mask<Double> m)```
Calculates the arc tangent of this vector divided by the broadcast of an an input scalar, selecting lane elements controlled by a mask.
`DoubleVector` `atan2​(Vector<Double> v)`
Calculates the arc tangent of this vector divided by an input vector.
`DoubleVector` ```atan2​(Vector<Double> v, Mask<Double> m)```
Calculates the arc tangent of this vector divided by an input vector, selecting lane elements controlled by a mask.
`abstract DoubleVector` ```blend​(double s, Mask<Double> m)```
Blends the lane elements of this vector with those of the broadcast of an input scalar, selecting lanes controlled by a mask.
`static DoubleVector` ```broadcast​(Species<Double> s, double e)```
Returns a vector where all lane elements are set to the primitive value `e`.
`DoubleVector` `cbrt()`
Calculates the cube root of this vector.
`DoubleVector` `cbrt​(Mask<Double> m)`
Calculates the cube root of this vector, selecting lane elements controlled by a mask.
`DoubleVector` `cos()`
Calculates the trigonometric cosine of this vector.
`DoubleVector` `cos​(Mask<Double> m)`
Calculates the trigonometric cosine of this vector, selecting lane elements controlled by a mask.
`DoubleVector` `cosh()`
Calculates the hyperbolic cosine of this vector.
`DoubleVector` `cosh​(Mask<Double> m)`
Calculates the hyperbolic cosine of this vector, selecting lane elements controlled by a mask.
`abstract DoubleVector` `div​(double s)`
Divides this vector by the broadcast of an input scalar.
`abstract DoubleVector` ```div​(double s, Mask<Double> m)```
Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
`abstract DoubleVector` `div​(Vector<Double> v)`
Divides this vector by an input vector.
`abstract DoubleVector` ```div​(Vector<Double> v, Mask<Double> m)```
Divides this vector by an input vector, selecting lane elements controlled by a mask.
`abstract Mask<Double>` `equal​(double s)`
Tests if this vector is equal to the broadcast of an input scalar.
`DoubleVector` `exp()`
Calculates the broadcast of Euler's number `e` raised to the power of this vector.
`DoubleVector` `exp​(Mask<Double> m)`
Calculates the broadcast of Euler's number `e` raised to the power of this vector, selecting lane elements controlled by a mask.
`DoubleVector` `expm1()`
Calculates the broadcast of Euler's number `e` raised to the power of this vector minus the broadcast of `-1`.
`DoubleVector` `expm1​(Mask<Double> m)`
Calculates the broadcast of Euler's number `e` raised to the power of this vector minus the broadcast of `-1`, selecting lane elements controlled by a mask More specifically as if the following (ignoring any differences in numerical accuracy):
`abstract DoubleVector` ```fma​(double s1, double s2)```
Calculates the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar.
`abstract DoubleVector` ```fma​(double s1, double s2, Mask<Double> m)```
Calculates the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar, selecting lane elements controlled by a mask More specifically as if the following:
`abstract DoubleVector` ```fma​(Vector<Double> v1, Vector<Double> v2)```
Calculates the product of this vector and a first input vector summed with a second input vector.
`DoubleVector` ```fma​(Vector<Double> v1, Vector<Double> v2, Mask<Double> m)```
Calculates the product of this vector and a first input vector summed with a second input vector, selecting lane elements controlled by a mask.
`static DoubleVector` ```fromArray​(Species<Double> species, double[] a, int i)```
Loads a vector from an array starting at offset.
`static DoubleVector` ```fromArray​(Species<Double> species, double[] a, int i, int[] indexMap, int j)```
Loads a vector from an array using indexes obtained from an index map.
`static DoubleVector` ```fromArray​(Species<Double> species, double[] a, int i, Mask<Double> m)```
Loads a vector from an array starting at offset and using a mask.
`static DoubleVector` ```fromArray​(Species<Double> species, double[] a, int i, Mask<Double> m, int[] indexMap, int j)```
Loads a vector from an array using indexes obtained from an index map and using a mask.
`static DoubleVector` ```fromByteArray​(Species<Double> species, byte[] a, int ix)```
Loads a vector from a byte array starting at an offset.
`static DoubleVector` ```fromByteArray​(Species<Double> species, byte[] a, int ix, Mask<Double> m)```
Loads a vector from a byte array starting at an offset and using a mask.
`static DoubleVector` ```fromByteBuffer​(Species<Double> species, ByteBuffer bb, int ix)```
Loads a vector from a `byte buffer` starting at an offset into the byte buffer.
`static DoubleVector` ```fromByteBuffer​(Species<Double> species, ByteBuffer bb, int ix, Mask<Double> m)```
Loads a vector from a `byte buffer` starting at an offset into the byte buffer and using a mask.
`abstract double` `get​(int i)`
Gets the lane element at lane index `i`
`abstract Mask<Double>` `greaterThan​(double s)`
Tests if this vector is greater than the broadcast of an input scalar.
`abstract Mask<Double>` `greaterThanEq​(double s)`
Tests if this vector is greater than or equal to the broadcast of an input scalar.
`abstract DoubleVector` `hypot​(double s)`
Calculates square root of the sum of the squares of this vector and the broadcast of an input scalar.
`abstract DoubleVector` ```hypot​(double s, Mask<Double> m)```
Calculates square root of the sum of the squares of this vector and the broadcast of an input scalar, selecting lane elements controlled by a mask.
`DoubleVector` `hypot​(Vector<Double> v)`
Calculates square root of the sum of the squares of this vector and an input vector.
`DoubleVector` ```hypot​(Vector<Double> v, Mask<Double> m)```
Calculates square root of the sum of the squares of this vector and an input vector, selecting lane elements controlled by a mask.
`abstract void` ```intoArray​(double[] a, int i)```
Stores this vector into an array starting at offset.
`abstract void` ```intoArray​(double[] a, int i, int[] indexMap, int j)```
Stores this vector into an array using indexes obtained from an index map.
`abstract void` ```intoArray​(double[] a, int i, Mask<Double> m)```
Stores this vector into an array starting at offset and using a mask.
`abstract void` ```intoArray​(double[] a, int i, Mask<Double> m, int[] indexMap, int j)```
Stores this vector into an array using indexes obtained from an index map and using a mask.
`abstract Mask<Double>` `lessThan​(double s)`
Tests if this vector is less than the broadcast of an input scalar.
`abstract Mask<Double>` `lessThanEq​(double s)`
Tests if this vector is less or equal to the broadcast of an input scalar.
`DoubleVector` `log()`
Calculates the natural logarithm of this vector.
`DoubleVector` `log​(Mask<Double> m)`
Calculates the natural logarithm of this vector, selecting lane elements controlled by a mask.
`DoubleVector` `log10()`
Calculates the base 10 logarithm of this vector.
`DoubleVector` `log10​(Mask<Double> m)`
Calculates the base 10 logarithm of this vector, selecting lane elements controlled by a mask.
`DoubleVector` `log1p()`
Calculates the natural logarithm of the sum of this vector and the broadcast of `1`.
`DoubleVector` `log1p​(Mask<Double> m)`
Calculates the natural logarithm of the sum of this vector and the broadcast of `1`, selecting lane elements controlled by a mask.
`abstract DoubleVector` `max​(double s)`
Returns the maximum of this vector and the broadcast of an input scalar.
`abstract double` `maxAll()`
Returns the maximum lane element of this vector.
`abstract double` `maxAll​(Mask<Double> m)`
Returns the maximum lane element of this vector, selecting lane elements controlled by a mask.
`abstract DoubleVector` `min​(double s)`
Returns the minimum of this vector and the broadcast of an input scalar.
`abstract double` `minAll()`
Returns the minimum lane element of this vector.
`abstract double` `minAll​(Mask<Double> m)`
Returns the minimum lane element of this vector, selecting lane elements controlled by a mask.
`abstract DoubleVector` `mul​(double s)`
Multiplies this vector with the broadcast of an input scalar.
`abstract DoubleVector` ```mul​(double s, Mask<Double> m)```
Multiplies this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.
`abstract double` `mulAll()`
Multiplies all lane elements of this vector.
`abstract double` `mulAll​(Mask<Double> m)`
Multiplies all lane elements of this vector, selecting lane elements controlled by a mask.
`abstract Mask<Double>` `notEqual​(double s)`
Tests if this vector is not equal to the broadcast of an input scalar.
`abstract DoubleVector` `pow​(double s)`
Calculates this vector raised to the power of the broadcast of an input scalar.
`abstract DoubleVector` ```pow​(double s, Mask<Double> m)```
Calculates this vector raised to the power of the broadcast of an input scalar, selecting lane elements controlled by a mask.
`DoubleVector` `pow​(Vector<Double> v)`
Calculates this vector raised to the power of an input vector.
`DoubleVector` ```pow​(Vector<Double> v, Mask<Double> m)```
Calculates this vector raised to the power of an input vector, selecting lane elements controlled by a mask.
`static DoubleVector` `random​(Species<Double> s)`
Returns a vector where each lane element is set to a randomly generated primitive value.
`static DoubleVector` ```scalars​(Species<Double> s, double... es)```
Returns a vector where each lane element is set to a given primitive value.
`DoubleVector` `sin()`
Calculates the trigonometric sine of this vector.
`DoubleVector` `sin​(Mask<Double> m)`
Calculates the trigonometric sine of this vector, selecting lane elements controlled by a mask.
`static DoubleVector` ```single​(Species<Double> s, double 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.
`DoubleVector` `sinh()`
Calculates the hyperbolic sine of this vector.
`DoubleVector` `sinh​(Mask<Double> m)`
Calculates the hyperbolic sine of this vector, selecting lane elements controlled by a mask.
`abstract DoubleVector` `sqrt()`
Calculates the square root of this vector.
`DoubleVector` `sqrt​(Mask<Double> m)`
Calculates the square root of this vector, selecting lane elements controlled by a mask.
`abstract DoubleVector` `sub​(double s)`
Subtracts the broadcast of an input scalar from this vector.
`abstract DoubleVector` ```sub​(double s, Mask<Double> m)```
Subtracts the broadcast of an input scalar from this vector, selecting lane elements controlled by a mask.
`DoubleVector` `tan()`
Calculates the trigonometric tangent of this vector.
`DoubleVector` `tan​(Mask<Double> m)`
Calculates the trigonometric tangent of this vector, selecting lane elements controlled by a mask.
`DoubleVector` `tanh()`
Calculates the hyperbolic tangent of this vector.
`DoubleVector` `tanh​(Mask<Double> m)`
Calculates the hyperbolic tangent of this vector, selecting lane elements controlled by a mask.
`double[]` `toArray()`
Returns an array containing the lane elements of this vector.
`abstract DoubleVector` ```with​(int i, double e)```
Replaces the lane element of this vector at lane index `i` with value `e`.
`static DoubleVector` `zero​(Species<Double> species)`
Returns a vector where all lane elements are set to the default primitive value.
• ### Methods declared in class jdk.incubator.vector.Vector

`abs, abs, add, add, bitSize, bitSizeForVectorLength, blend, cast, elementSize, elementType, equal, greaterThan, greaterThanEq, intoByteArray, intoByteArray, intoByteBuffer, intoByteBuffer, length, lessThan, lessThanEq, max, max, min, min, mul, mul, neg, neg, notEqual, rearrange, rearrange, reinterpret, reshape, rotateEL, rotateER, shape, shiftEL, shiftER, species, sub, sub, toShuffle`
• ### Methods declared in class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ## Method Detail

• ### zero

`public static DoubleVector zero​(Species<Double> 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 DoubleVector fromByteArray​(Species<Double> species,
byte[] a,
int ix)```
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:

``````
``````
Parameters:
`species` - species of desired vector
`a` - the byte array
`ix` - the offset into the array
Returns:
a vector loaded from a byte array
Throws:
`IndexOutOfBoundsException` - if `i < 0` or `i > a.length - (this.length() * this.elementSize() / Byte.SIZE)`
• ### fromByteArray

```public static DoubleVector fromByteArray​(Species<Double> species,
byte[] a,
int ix,
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 this.fromByteBuffer(ByteBuffer.wrap(a), i, m);
``````
Parameters:
`species` - species of desired vector
`a` - the byte array
`ix` - the offset into the array
`m` - the mask
Returns:
a vector loaded from a byte array
Throws:
`IndexOutOfBoundsException` - if `i < 0` or `i > a.length - (this.length() * this.elementSize() / Byte.SIZE)`
`IndexOutOfBoundsException` - if the offset is `< 0`, or `> a.length`, for any vector lane index `N` where the mask at lane `N` is set `i >= a.length - (N * this.elementSize() / Byte.SIZE)`
• ### fromArray

```public static DoubleVector fromArray​(Species<Double> species,
double[] a,
int i)```
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 `i + N` is placed into the resulting vector at lane index `N`.

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

```public static DoubleVector fromArray​(Species<Double> species,
double[] a,
int i,
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 `i + 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
`i` - the offset into the array
`m` - the mask
Returns:
the vector loaded from an array
Throws:
`IndexOutOfBoundsException` - if `i < 0`, or for any vector lane index `N` where the mask at lane `N` is set `i > a.length - N`
• ### fromArray

```public static DoubleVector fromArray​(Species<Double> species,
double[] a,
int i,
int[] indexMap,
int j)```
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 `i + indexMap[j + N]` is placed into the resulting vector at lane index `N`.

Parameters:
`species` - species of desired vector
`a` - the array
`i` - 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
`j` - the offset into the index map
Returns:
the vector loaded from an array
Throws:
`IndexOutOfBoundsException` - if `j < 0`, or `j > indexMap.length - this.length()`, or for any vector lane index `N` the result of `i + indexMap[j + N]` is `< 0` or `>= a.length`
• ### fromArray

```public static DoubleVector fromArray​(Species<Double> species,
double[] a,
int i,
int[] indexMap,
int j)```
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 `i + indexMap[j + N]` is placed into the resulting vector at lane index `N`.

Parameters:
`species` - species of desired vector
`a` - the array
`i` - 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
`j` - the offset into the index map
Returns:
the vector loaded from an array
Throws:
`IndexOutOfBoundsException` - if `j < 0`, or `j > indexMap.length - this.length()`, or for any vector lane index `N` where the mask at lane `N` is set the result of `i + indexMap[j + N]` is `< 0` or `>= a.length`
• ### fromByteBuffer

```public static DoubleVector fromByteBuffer​(Species<Double> species,
ByteBuffer bb,
int ix)```
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(Species, ByteBuffer, int, Mask)` method} as follows:

``````
``````
Parameters:
`species` - species of desired vector
`bb` - the byte buffer
`ix` - 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 `this.length() * this.elementSize() / Byte.SIZE` bytes remaining in the byte buffer from the given offset
• ### fromByteBuffer

```public static DoubleVector fromByteBuffer​(Species<Double> species,
ByteBuffer bb,
int ix,
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 is the primitive buffer type, `e` is the primitive element type, and `ESpecies<S>` is the primitive species for `e`:

``````
EBuffer eb = b.duplicate().
order(ByteOrder.nativeOrder()).position(i).
asEBuffer();
e[] es = new e[this.length()];
for (int n = 0; n < t.length; n++) {
if (m.isSet(n))
es[n] = eb.get(n);
}
Vector<E> r = ((ESpecies<S>)this).fromArray(es, 0, m);
``````
Parameters:
`species` - species of desired vector
`bb` - the byte buffer
`ix` - 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 `i >= b.limit() - (N * this.elementSize() / Byte.SIZE)`

```public static DoubleVector broadcast​(Species<Double> s,
double e)```
Returns a vector where all lane elements are set to the primitive value `e`.
Parameters:
`s` - species of the desired vector
`e` - the value
Returns:
a vector of vector where all lane elements are set to the primitive value `e`
• ### scalars

```public static DoubleVector scalars​(Species<Double> s,
double... es)```
Returns a vector where each lane element is set to a given primitive value.

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:
`s` - species of the desired vector
`es` - the given primitive values
Returns:
a vector where each lane element is set to a given primitive value
Throws:
`IndexOutOfBoundsException` - if `es.length < this.length()`
• ### single

```public static final DoubleVector single​(Species<Double> s,
double 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:
`s` - 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 DoubleVector random​(Species<Double> s)`
Returns a vector where each lane element is set to a randomly generated primitive value. The semantics are equivalent to calling `ThreadLocalRandom.nextDouble()`
Parameters:
`s` - species of the desired vector
Returns:
a vector where each lane elements is set to a randomly generated primitive value

`public abstract DoubleVector add​(double s)`

This is a vector binary operation where the primitive addition operation (`+`) is applied to lane elements.

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

```public abstract DoubleVector add​(double s,

This is a vector binary operation where the primitive addition operation (`+`) is applied to lane elements.

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 DoubleVector sub​(double s)`
Subtracts the broadcast of an input scalar from this vector.

This is a vector binary operation where the primitive subtraction operation (`-`) is applied to lane elements.

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

```public abstract DoubleVector sub​(double s,
Subtracts the broadcast of an input scalar from this vector, selecting lane elements controlled by a mask.

This is a vector binary operation where the primitive subtraction operation (`-`) is applied to lane elements.

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 DoubleVector mul​(double s)`
Multiplies this vector with the broadcast of an input scalar.

This is a vector binary operation where the primitive multiplication operation (`*`) is applied to lane elements.

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

```public abstract DoubleVector mul​(double s,
Multiplies this vector with the broadcast of an input scalar, selecting lane elements controlled by a mask.

This is a vector binary operation where the primitive multiplication operation (`*`) is applied to lane elements.

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 DoubleVector min​(double s)`
Returns the minimum of this vector and the broadcast of an input scalar.

This is a vector binary operation where the operation `(a, b) -> Math.min(a, b)` is applied to lane elements.

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

`public abstract DoubleVector max​(double s)`
Returns the maximum of this vector and the broadcast of an input scalar.

This is a vector binary operation where the operation `(a, b) -> Math.max(a, b)` is applied to lane elements.

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

`public abstract Mask<Double> equal​(double s)`
Tests if this vector is equal to the broadcast of an input scalar.

This is a vector binary test operation where the primitive equals operation (`==`) is applied to lane elements.

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 Mask<Double> notEqual​(double s)`
Tests if this vector is not equal to the broadcast of an input scalar.

This is a vector binary test operation where the primitive not equals operation (`!=`) is applied to lane elements.

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 Mask<Double> lessThan​(double s)`
Tests if this vector is less than the broadcast of an input scalar.

This is a vector binary test operation where the primitive less than operation (`<`) is applied to lane elements.

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 Mask<Double> lessThanEq​(double s)`
Tests if this vector is less or equal to the broadcast of an input scalar.

This is a vector binary test operation where the primitive less than or equal to operation (`<=`) is applied to lane elements.

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 Mask<Double> greaterThan​(double s)`
Tests if this vector is greater than the broadcast of an input scalar.

This is a vector binary test operation where the primitive greater than operation (`>`) is applied to lane elements.

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 Mask<Double> greaterThanEq​(double s)`
Tests if this vector is greater than or equal to the broadcast of an input scalar.

This is a vector binary test operation where the primitive greater than or equal to operation (`>=`) is applied to lane elements.

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 DoubleVector blend​(double s,
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
• ### div

`public abstract DoubleVector div​(Vector<Double> v)`
Divides this vector by an input vector.

This is a vector binary operation where the primitive division operation (`/`) is applied to lane elements.

Parameters:
`v` - the input vector
Returns:
the result of dividing this vector by the input vector
• ### div

`public abstract DoubleVector div​(double s)`
Divides this vector by the broadcast of an input scalar.

This is a vector binary operation where the primitive division operation (`/`) is applied to lane elements.

Parameters:
`s` - the input scalar
Returns:
the result of dividing this vector by the broadcast of an input scalar
• ### div

```public abstract DoubleVector div​(Vector<Double> v,
Divides this vector by an input vector, selecting lane elements controlled by a mask.

This is a vector binary operation where the primitive division operation (`/`) is applied to lane elements.

Parameters:
`v` - the input vector
`m` - the mask controlling lane selection
Returns:
the result of dividing this vector by the input vector
• ### div

```public abstract DoubleVector div​(double s,
Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.

This is a vector binary operation where the primitive division operation (`/`) is applied to lane elements.

Parameters:
`s` - the input scalar
`m` - the mask controlling lane selection
Returns:
the result of dividing this vector by the broadcast of an input scalar
• ### sqrt

`public abstract DoubleVector sqrt()`
Calculates the square root of this vector.

This is a vector unary operation where the `Math.sqrt(double)` operation is applied to lane elements.

Returns:
the square root of this vector
• ### sqrt

`public DoubleVector sqrt​(Mask<Double> m)`
Calculates the square root of this vector, selecting lane elements controlled by a mask.

This is a vector unary operation where the `Math.sqrt(double)` operation is applied to lane elements.

Parameters:
`m` - the mask controlling lane selection
Returns:
the square root of this vector
• ### tan

`public DoubleVector tan()`
Calculates the trigonometric tangent of this vector.

This is a vector unary operation with same semantic definition as `Math.tan(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.tan(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.tan(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the tangent of this vector
• ### tan

`public DoubleVector tan​(Mask<Double> m)`
Calculates the trigonometric tangent of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `tan()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the tangent of this vector
• ### tanh

`public DoubleVector tanh()`
Calculates the hyperbolic tangent of this vector.

This is a vector unary operation with same semantic definition as `Math.tanh(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.tanh(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.tanh(double)` specifications. The computed result will be within 2.5 ulps of the exact result.

Returns:
the hyperbolic tangent of this vector
• ### tanh

`public DoubleVector tanh​(Mask<Double> m)`
Calculates the hyperbolic tangent of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `tanh()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the hyperbolic tangent of this vector
• ### sin

`public DoubleVector sin()`
Calculates the trigonometric sine of this vector.

This is a vector unary operation with same semantic definition as `Math.sin(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.sin(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.sin(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the sine of this vector
• ### sin

`public DoubleVector sin​(Mask<Double> m)`
Calculates the trigonometric sine of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `sin()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the sine of this vector
• ### sinh

`public DoubleVector sinh()`
Calculates the hyperbolic sine of this vector.

This is a vector unary operation with same semantic definition as `Math.sinh(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.sinh(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.sinh(double)` specifications. The computed result will be within 2.5 ulps of the exact result.

Returns:
the hyperbolic sine of this vector
• ### sinh

`public DoubleVector sinh​(Mask<Double> m)`
Calculates the hyperbolic sine of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `sinh()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the hyperbolic sine of this vector
• ### cos

`public DoubleVector cos()`
Calculates the trigonometric cosine of this vector.

This is a vector unary operation with same semantic definition as `Math.cos(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.cos(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.cos(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the cosine of this vector
• ### cos

`public DoubleVector cos​(Mask<Double> m)`
Calculates the trigonometric cosine of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `cos()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the cosine of this vector
• ### cosh

`public DoubleVector cosh()`
Calculates the hyperbolic cosine of this vector.

This is a vector unary operation with same semantic definition as `Math.cosh(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.cosh(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.cosh(double)` specifications. The computed result will be within 2.5 ulps of the exact result.

Returns:
the hyperbolic cosine of this vector
• ### cosh

`public DoubleVector cosh​(Mask<Double> m)`
Calculates the hyperbolic cosine of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `cosh()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the hyperbolic cosine of this vector
• ### asin

`public DoubleVector asin()`
Calculates the arc sine of this vector.

This is a vector unary operation with same semantic definition as `Math.asin(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.asin(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.asin(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the arc sine of this vector
• ### asin

`public DoubleVector asin​(Mask<Double> m)`
Calculates the arc sine of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `asin()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the arc sine of this vector
• ### acos

`public DoubleVector acos()`
Calculates the arc cosine of this vector.

This is a vector unary operation with same semantic definition as `Math.acos(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.acos(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.acos(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the arc cosine of this vector
• ### acos

`public DoubleVector acos​(Mask<Double> m)`
Calculates the arc cosine of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `acos()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the arc cosine of this vector
• ### atan

`public DoubleVector atan()`
Calculates the arc tangent of this vector.

This is a vector unary operation with same semantic definition as `Math.atan(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.atan(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.atan(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the arc tangent of this vector
• ### atan

`public DoubleVector atan​(Mask<Double> m)`
Calculates the arc tangent of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `atan()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the arc tangent of this vector
• ### atan2

`public DoubleVector atan2​(Vector<Double> v)`
Calculates the arc tangent of this vector divided by an input vector.

This is a vector binary operation with same semantic definition as `Math.atan2(double, double)` operation applied to lane elements. The implementation is not required to return same results as `Math.atan2(double, double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.atan2(double, double)` specifications. The computed result will be within 2 ulps of the exact result.

Parameters:
`v` - the input vector
Returns:
the arc tangent of this vector divided by the input vector
• ### atan2

`public abstract DoubleVector atan2​(double s)`
Calculates the arc tangent of this vector divided by the broadcast of an an input scalar.

This is a vector binary operation with same semantic definition as `Math.atan2(double, double)` operation applied to lane elements. The implementation is not required to return same results as `Math.atan2(double, double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.atan2(double, double)` specifications. The computed result will be within 1 ulp of the exact result.

Parameters:
`s` - the input scalar
Returns:
the arc tangent of this vector over the input vector
• ### atan2

```public DoubleVector atan2​(Vector<Double> v,
Calculates the arc tangent of this vector divided by an input vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `atan2(jdk.incubator.vector.Vector<java.lang.Double>)`

Parameters:
`v` - the input vector
`m` - the mask controlling lane selection
Returns:
the arc tangent of this vector divided by the input vector
• ### atan2

```public abstract DoubleVector atan2​(double s,
Calculates the arc tangent of this vector divided by the broadcast of an an input scalar, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `atan2(jdk.incubator.vector.Vector<java.lang.Double>)`

Parameters:
`s` - the input scalar
`m` - the mask controlling lane selection
Returns:
the arc tangent of this vector over the input vector
• ### cbrt

`public DoubleVector cbrt()`
Calculates the cube root of this vector.

This is a vector unary operation with same semantic definition as `Math.cbrt(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.cbrt(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.cbrt(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the cube root of this vector
• ### cbrt

`public DoubleVector cbrt​(Mask<Double> m)`
Calculates the cube root of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `cbrt()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the cube root of this vector
• ### log

`public DoubleVector log()`
Calculates the natural logarithm of this vector.

This is a vector unary operation with same semantic definition as `Math.log(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.log(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.log(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the natural logarithm of this vector
• ### log

`public DoubleVector log​(Mask<Double> m)`
Calculates the natural logarithm of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `log()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the natural logarithm of this vector
• ### log10

`public DoubleVector log10()`
Calculates the base 10 logarithm of this vector.

This is a vector unary operation with same semantic definition as `Math.log10(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.log10(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.log10(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the base 10 logarithm of this vector
• ### log10

`public DoubleVector log10​(Mask<Double> m)`
Calculates the base 10 logarithm of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `log10()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the base 10 logarithm of this vector
• ### log1p

`public DoubleVector log1p()`
Calculates the natural logarithm of the sum of this vector and the broadcast of `1`.

This is a vector unary operation with same semantic definition as `Math.log1p(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.log1p(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.log1p(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the natural logarithm of the sum of this vector and the broadcast of `1`
• ### log1p

`public DoubleVector log1p​(Mask<Double> m)`
Calculates the natural logarithm of the sum of this vector and the broadcast of `1`, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `log1p()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the natural logarithm of the sum of this vector and the broadcast of `1`
• ### pow

`public DoubleVector pow​(Vector<Double> v)`
Calculates this vector raised to the power of an input vector.

This is a vector binary operation with same semantic definition as `Math.pow(double, double)` operation applied to lane elements. The implementation is not required to return same results as `Math.pow(double, double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.pow(double, double)` specifications. The computed result will be within 1 ulp of the exact result.

Parameters:
`v` - the input vector
Returns:
this vector raised to the power of an input vector
• ### pow

`public abstract DoubleVector pow​(double s)`
Calculates this vector raised to the power of the broadcast of an input scalar.

This is a vector binary operation with same semantic definition as `Math.pow(double, double)` operation applied to lane elements. The implementation is not required to return same results as `Math.pow(double, double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.pow(double, double)` specifications. The computed result will be within 1 ulp of the exact result.

Parameters:
`s` - the input scalar
Returns:
this vector raised to the power of the broadcast of an input scalar.
• ### pow

```public DoubleVector pow​(Vector<Double> v,
Calculates this vector raised to the power of an input vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `pow(jdk.incubator.vector.Vector<java.lang.Double>)`

Parameters:
`v` - the input vector
`m` - the mask controlling lane selection
Returns:
this vector raised to the power of an input vector
• ### pow

```public abstract DoubleVector pow​(double s,
Calculates this vector raised to the power of the broadcast of an input scalar, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `pow(jdk.incubator.vector.Vector<java.lang.Double>)`

Parameters:
`s` - the input scalar
`m` - the mask controlling lane selection
Returns:
this vector raised to the power of the broadcast of an input scalar.
• ### exp

`public DoubleVector exp()`
Calculates the broadcast of Euler's number `e` raised to the power of this vector.

This is a vector unary operation with same semantic definition as `Math.exp(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.exp(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.exp(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the broadcast of Euler's number `e` raised to the power of this vector
• ### exp

`public DoubleVector exp​(Mask<Double> m)`
Calculates the broadcast of Euler's number `e` raised to the power of this vector, selecting lane elements controlled by a mask.

Semantics for rounding, monotonicity, and special cases are described in `exp()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the broadcast of Euler's number `e` raised to the power of this vector
• ### expm1

`public DoubleVector expm1()`
Calculates the broadcast of Euler's number `e` raised to the power of this vector minus the broadcast of `-1`. More specifically as if the following (ignoring any differences in numerical accuracy):
``````
``````

This is a vector unary operation with same semantic definition as `Math.expm1(double)` operation applied to lane elements. The implementation is not required to return same results as `Math.expm1(double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.expm1(double)` specifications. The computed result will be within 1 ulp of the exact result.

Returns:
the broadcast of Euler's number `e` raised to the power of this vector minus the broadcast of `-1`
• ### expm1

`public DoubleVector expm1​(Mask<Double> m)`
Calculates the broadcast of Euler's number `e` raised to the power of this vector minus the broadcast of `-1`, selecting lane elements controlled by a mask More specifically as if the following (ignoring any differences in numerical accuracy):
``````
``````

Semantics for rounding, monotonicity, and special cases are described in `expm1()`

Parameters:
`m` - the mask controlling lane selection
Returns:
the broadcast of Euler's number `e` raised to the power of this vector minus the broadcast of `-1`
• ### fma

```public abstract DoubleVector fma​(Vector<Double> v1,
Vector<Double> v2)```
Calculates the product of this vector and a first input vector summed with a second input vector. More specifically as if the following (ignoring any differences in numerical accuracy):
``````
``````

This is a vector ternary operation where the `Math.fma(double, double, double)` operation is applied to lane elements.

Parameters:
`v1` - the first input vector
`v2` - the second input vector
Returns:
the product of this vector and the first input vector summed with the second input vector
• ### fma

```public abstract DoubleVector fma​(double s1,
double s2)```
Calculates the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar. More specifically as if the following:
``````
``````

This is a vector ternary operation where the `Math.fma(double, double, double)` operation is applied to lane elements.

Parameters:
`s1` - the first input scalar
`s2` - the second input scalar
Returns:
the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar
• ### fma

```public DoubleVector fma​(Vector<Double> v1,
Vector<Double> v2,
Calculates the product of this vector and a first input vector summed with a second input vector, selecting lane elements controlled by a mask. More specifically as if the following (ignoring any differences in numerical accuracy):
``````
``````

This is a vector ternary operation where the `Math.fma(double, double, double)` operation is applied to lane elements.

Parameters:
`v1` - the first input vector
`v2` - the second input vector
`m` - the mask controlling lane selection
Returns:
the product of this vector and the first input vector summed with the second input vector
• ### fma

```public abstract DoubleVector fma​(double s1,
double s2,
Calculates the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar, selecting lane elements controlled by a mask More specifically as if the following:
``````
``````

This is a vector ternary operation where the `Math.fma(double, double, double)` operation is applied to lane elements.

Parameters:
`s1` - the first input scalar
`s2` - the second input scalar
`m` - the mask controlling lane selection
Returns:
the product of this vector and the broadcast of a first input scalar summed with the broadcast of a second input scalar
• ### hypot

`public DoubleVector hypot​(Vector<Double> v)`
Calculates square root of the sum of the squares of this vector and an input vector. More specifically as if the following (ignoring any differences in numerical accuracy):
``````
``````

This is a vector binary operation with same semantic definition as `Math.hypot(double, double)` operation applied to lane elements. The implementation is not required to return same results as `Math.hypot(double, double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.hypot(double, double)` specifications. The computed result will be within 1 ulp of the exact result.

Parameters:
`v` - the input vector
Returns:
square root of the sum of the squares of this vector and an input vector
• ### hypot

`public abstract DoubleVector hypot​(double s)`
Calculates square root of the sum of the squares of this vector and the broadcast of an input scalar. More specifically as if the following (ignoring any differences in numerical accuracy):
``````
``````

This is a vector binary operation with same semantic definition as `Math.hypot(double, double)` operation applied to lane elements. The implementation is not required to return same results as `Math.hypot(double, double)`, but adheres to rounding, monotonicity, and special case semantics as defined in the `Math.hypot(double, double)` specifications. The computed result will be within 1 ulp of the exact result.

Parameters:
`s` - the input scalar
Returns:
square root of the sum of the squares of this vector and the broadcast of an input scalar
• ### hypot

```public DoubleVector hypot​(Vector<Double> v,
Calculates square root of the sum of the squares of this vector and an input vector, selecting lane elements controlled by a mask. More specifically as if the following (ignoring any differences in numerical accuracy):
``````
``````

Semantics for rounding, monotonicity, and special cases are described in `hypot(jdk.incubator.vector.Vector<java.lang.Double>)`

Parameters:
`v` - the input vector
`m` - the mask controlling lane selection
Returns:
square root of the sum of the squares of this vector and an input vector
• ### hypot

```public abstract DoubleVector hypot​(double s,
Calculates square root of the sum of the squares of this vector and the broadcast of an input scalar, selecting lane elements controlled by a mask. More specifically as if the following (ignoring any differences in numerical accuracy):
``````
``````

Semantics for rounding, monotonicity, and special cases are described in `hypot(jdk.incubator.vector.Vector<java.lang.Double>)`

Parameters:
`s` - the input scalar
`m` - the mask controlling lane selection
Returns:
square root of the sum of the squares of this vector and the broadcast of an input scalar

`public abstract double addAll()`
Adds all lane elements of this vector.

This is a vector reduction operation where the addition operation (`+`) is applied to lane elements, and the identity value is `0.0`.

The value of a floating-point sum is a function both of the input values as well as the order of addition operations. The order of addition operations of this method is intentionally not defined to allow for JVM to generate optimal machine code for the underlying platform at runtime. If the platform supports a vector instruction to add all values in the vector, or if there is some other efficient machine code sequence, then the JVM has the option of generating this machine code. Otherwise, the default implementation of adding vectors sequentially from left to right is used. For this reason, the output of this method may vary for the same input values.

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

`public abstract double addAll​(Mask<Double> m)`
Adds all lane elements of this vector, selecting lane elements controlled by a mask.

This is a vector reduction operation where the addition operation (`+`) is applied to lane elements, and the identity value is `0.0`.

The value of a floating-point sum is a function both of the input values as well as the order of addition operations. The order of addition operations of this method is intentionally not defined to allow for JVM to generate optimal machine code for the underlying platform at runtime. If the platform supports a vector instruction to add all values in the vector, or if there is some other efficient machine code sequence, then the JVM has the option of generating this machine code. Otherwise, the default implementation of adding vectors sequentially from left to right is used. For this reason, the output of this method may vary on the same input values.

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

`public abstract double mulAll()`
Multiplies all lane elements of this vector.

This is a vector reduction operation where the multiplication operation (`*`) is applied to lane elements, and the identity value is `1.0`.

The order of multiplication operations of this method is intentionally not defined to allow for JVM to generate optimal machine code for the underlying platform at runtime. If the platform supports a vector instruction to multiply all values in the vector, or if there is some other efficient machine code sequence, then the JVM has the option of generating this machine code. Otherwise, the default implementation of multiplying vectors sequentially from left to right is used. For this reason, the output of this method may vary on the same input values.

Returns:
the multiplication of all the lane elements of this vector
• ### mulAll

`public abstract double mulAll​(Mask<Double> m)`
Multiplies all lane elements of this vector, selecting lane elements controlled by a mask.

This is a vector reduction operation where the multiplication operation (`*`) is applied to lane elements, and the identity value is `1.0`.

The order of multiplication operations of this method is intentionally not defined to allow for JVM to generate optimal machine code for the underlying platform at runtime. If the platform supports a vector instruction to multiply all values in the vector, or if there is some other efficient machine code sequence, then the JVM has the option of generating this machine code. Otherwise, the default implementation of multiplying vectors sequentially from left to right is used. For this reason, the output of this method may vary on the same input values.

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

`public abstract double minAll()`
Returns the minimum lane element of this vector.

This is an associative vector reduction operation where the operation `(a, b) -> Math.min(a, b)` is applied to lane elements, and the identity value is `Double.POSITIVE_INFINITY`.

Returns:
the minimum lane element of this vector
• ### minAll

`public abstract double minAll​(Mask<Double> m)`
Returns the minimum lane element of this vector, selecting lane elements controlled by a mask.

This is an associative vector reduction operation where the operation `(a, b) -> Math.min(a, b)` is applied to lane elements, and the identity value is `Double.POSITIVE_INFINITY`.

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

`public abstract double maxAll()`
Returns the maximum lane element of this vector.

This is an associative vector reduction operation where the operation `(a, b) -> Math.max(a, b)` is applied to lane elements, and the identity value is `Double.NEGATIVE_INFINITY`.

Returns:
the maximum lane element of this vector
• ### maxAll

`public abstract double maxAll​(Mask<Double> m)`
Returns the maximum lane element of this vector, selecting lane elements controlled by a mask.

This is an associative vector reduction operation where the operation `(a, b) -> Math.max(a, b)` is applied to lane elements, and the identity value is `Double.NEGATIVE_INFINITY`.

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

`public abstract double get​(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 DoubleVector with​(int i,
double 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 double[] toArray()`
Returns an array containing the lane elements of this vector.

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

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

```public abstract void intoArray​(double[] a,
int i)```
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 `i + N`.

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

```public abstract void intoArray​(double[] a,
int i,
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 `i + N`.

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

```public abstract void intoArray​(double[] a,
int i,
int[] indexMap,
int j)```
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 `i + indexMap[j + N]`.

Parameters:
`a` - the array
`i` - 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
`j` - the offset into the index map
Throws:
`IndexOutOfBoundsException` - if `j < 0`, or `j > indexMap.length - this.length()`, or for any vector lane index `N` the result of `i + indexMap[j + N]` is `< 0` or `>= a.length`
• ### intoArray

```public abstract void intoArray​(double[] a,
int i,
int[] indexMap,
int j)```
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 `i + indexMap[j + N]`.

Parameters:
`a` - the array
`i` - 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
`j` - the offset into the index map
Throws:
`IndexOutOfBoundsException` - if `j < 0`, or `j > indexMap.length - this.length()`, or for any vector lane index `N` where the mask at lane `N` is set the result of `i + indexMap[j + N]` is `< 0` or `>= a.length`