VectorI4D (io7m-jtensors-documentation 7.0.0-beta0011 API)

java.lang.Object
- com.io7m.jtensors.VectorI4D

All Implemented Interfaces:

VectorReadable2DType, VectorReadable3DType, VectorReadable4DType
```
@Immutable
public final class VectorI4D
extends Object
implements VectorReadable4DType
```
A four-dimensional immutable vector type with double elements.

Values of this type are immutable and can therefore be safely accessed from multiple threads.

Field Summary

Fields
Modifier and Type Field and Description

static VectorI4D ZERO
The zero vector.

Fields
Modifier and Type	Field and Description
`static VectorI4D`	`ZERO` The zero vector.

Constructor Summary

Constructors
Constructor and Description
`VectorI4D()` Default constructor, initializing the vector with values `[0.0, 0.0, 0.0, 1.0]`.
`VectorI4D(double in_x, double in_y, double in_z, double in_w)` Construct a vector initialized with the given values.
`VectorI4D(VectorReadable4DType in_v)` Construct a vector initialized with the values given in the vector `in_v`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static VectorI4D`	`absolute(VectorReadable4DType v)` Calculate the absolute value of the vector `v`.
`static VectorI4D`	`add(VectorReadable4DType v0, VectorReadable4DType v1)` Calculate the element-wise sum of the vectors `v0` and `v1`.
`static VectorI4D`	`addScaled(VectorReadable4DType v0, VectorReadable4DType v1, double r)` Calculate the element-wise sum of the vectors `v0` and the element-wise product of `v1` and `r`.
`static boolean`	`almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context, VectorReadable4DType va, VectorReadable4DType vb)` Determine whether or not the vectors `va` and `vb` are equal to within the degree of error given in `context`.
`static VectorI4D`	`clamp(VectorReadable4DType v, double minimum, double maximum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
`static VectorI4D`	`clampByVector(VectorReadable4DType v, VectorReadable4DType minimum, VectorReadable4DType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`.
`static VectorI4D`	`clampMaximum(VectorReadable4DType v, double maximum)` Clamp the elements of the vector `v` to the range {@code [-Infinity ..
`static VectorI4D`	`clampMaximumByVector(VectorReadable4DType v, VectorReadable4DType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`.
`static VectorI4D`	`clampMinimum(VectorReadable4DType v, double minimum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
`static VectorI4D`	`clampMinimumByVector(VectorReadable4DType v, VectorReadable4DType minimum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`.
`static double`	`distance(VectorReadable4DType v0, VectorReadable4DType v1)` Calculate the distance between the two vectors `v0` and `v1`.
`static double`	`dotProduct(VectorReadable4DType v0, VectorReadable4DType v1)` Calculate the scalar product of the vectors `v0` and `v1`.
`boolean`	`equals(Object obj)`
`double`	`getWD()`
`double`	`getXD()`
`double`	`getYD()`
`double`	`getZD()`
`int`	`hashCode()`
`static VectorI4D`	`interpolateLinear(VectorReadable4DType v0, VectorReadable4DType v1, double alpha)` Linearly interpolate between `v0` and `v1` by the amount `alpha`.
`static double`	`magnitude(VectorReadable4DType v)` Calculate the magnitude of the vector `v`.
`static double`	`magnitudeSquared(VectorReadable4DType v)` Calculate the squared magnitude of the vector `v`.
`static VectorI4D`	`normalize(VectorReadable4DType v)` Normalize the vector `v`, preserving its direction but reducing it to unit length.
`static com.io7m.jfunctional.Pair<VectorI4D,VectorI4D>`	`orthoNormalize(VectorReadable4DType v0, VectorReadable4DType v1)` Orthonormalize and return the vectors `v0` and `v1` .
`static VectorI4D`	`projection(VectorReadable4DType p, VectorReadable4DType q)` Calculate the projection of the vector `p` onto the vector `q`.
`static VectorI4D`	`scale(VectorReadable4DType v, double r)` Scale the vector `v` by the scalar `r`.
`static VectorI4D`	`subtract(VectorReadable4DType v0, VectorReadable4DType v1)` Subtract the vector `v1` from the vector `v0`.
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - ZERO
```
public static final VectorI4D ZERO
```
    The zero vector.
- Constructor Detail
  - VectorI4D
```
public VectorI4D()
```
    Default constructor, initializing the vector with values [0.0, 0.0, 0.0, 1.0].
  - VectorI4D
```
public VectorI4D(double in_x,
                 double in_y,
                 double in_z,
                 double in_w)
```
    Construct a vector initialized with the given values.
    
    Parameters:
    
    in_x - The x value
    
    in_y - The y value
    
    in_z - The z value
    
    in_w - The w value
  - VectorI4D
```
public VectorI4D(VectorReadable4DType in_v)
```
    Construct a vector initialized with the values given in the vector in_v.
    
    Parameters:
    
    in_v - The input vector.
- Method Detail
  - absolute
```
public static VectorI4D absolute(VectorReadable4DType v)
```
    Calculate the absolute value of the vector v.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    (abs v.x, abs v.y, abs v.z, abs v.w)
  - add
```
public static VectorI4D add(VectorReadable4DType v0,
                            VectorReadable4DType v1)
```
    Calculate the element-wise sum of the vectors v0 and v1.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    (v0.x + v1.x, v0.y + v1.y, v0.z + v1.z, v0.w + v1.w)
  - addScaled
```
public static VectorI4D addScaled(VectorReadable4DType v0,
                                  VectorReadable4DType v1,
                                  double r)
```
    Calculate the element-wise sum of the vectors v0 and the element-wise product of v1 and r.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    r - The scaling value
    
    Returns:
    
    (v0.x + (v1.x * r), v0.y + (v1.y * r), v0.z + (v1.z * r), v0.w + (v1.w * r))
  - almostEqual
```
public static boolean almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context,
                                  VectorReadable4DType va,
                                  VectorReadable4DType vb)
```
    Determine whether or not the vectors va and vb are equal to within the degree of error given in context.
    
    Parameters:
    
    context - The equality context
    
    va - The left input vector
    
    vb - The right input vector
    
    Returns:
    
    true iff the vectors are almost equal.
    
    Since:
    
    5.0.0
    
    See Also:
    
    AlmostEqualDouble.almostEqual(AlmostEqualDouble.ContextRelative, double, double)
  - clamp
```
public static VectorI4D clamp(VectorReadable4DType v,
                              double minimum,
                              double maximum)
```
    Clamp the elements of the vector v to the range [minimum .. maximum] inclusive.
    
    Parameters:
    
    v - The input vector
    
    minimum - The minimum allowed value
    
    maximum - The maximum allowed value
    
    Returns:
    
    A vector with both elements equal to at most maximum and at least minimum
  - clampByVector
```
public static VectorI4D clampByVector(VectorReadable4DType v,
                                      VectorReadable4DType minimum,
                                      VectorReadable4DType maximum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum and maximum.
    
    Parameters:
    
    v - The input vector
    
    minimum - The vector containing the minimum acceptable values
    
    maximum - The vector containing the maximum acceptable values
    
    Returns:
    
    (min(max(v.x, minimum.x), maximum.x), min(max(v.y, minimum.y), maximum.y), min(max(v.z, minimum.z), maximum.z), min(max(v.w, minimum.w), maximum.w))
  - clampMaximum
```
public static VectorI4D clampMaximum(VectorReadable4DType v,
                                     double maximum)
```
    Clamp the elements of the vector v to the range [-Infinity .. maximum] inclusive.
    
    Parameters:
    
    v - The input vector
    
    maximum - The maximum allowed value
    
    Returns:
    
    A vector with both elements equal to at most maximum
  - clampMaximumByVector
```
public static VectorI4D clampMaximumByVector(VectorReadable4DType v,
                                             VectorReadable4DType maximum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in maximum.
    
    Parameters:
    
    v - The input vector
    
    maximum - The vector containing the maximum acceptable values
    
    Returns:
    
    (min(v.x, maximum.x), min(v.y, maximum.y), min(v.z, maximum.z), min(v.w, maximum.w))
  - clampMinimum
```
public static VectorI4D clampMinimum(VectorReadable4DType v,
                                     double minimum)
```
    Clamp the elements of the vector v to the range [minimum .. Infinity] inclusive.
    
    Parameters:
    
    v - The input vector
    
    minimum - The minimum allowed value
    
    Returns:
    
    A vector with both elements equal to at least minimum.
  - clampMinimumByVector
```
public static VectorI4D clampMinimumByVector(VectorReadable4DType v,
                                             VectorReadable4DType minimum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum.
    
    Parameters:
    
    v - The input vector
    
    minimum - The vector containing the minimum acceptable values
    
    Returns:
    
    (max(v.x, minimum.x), max(v.y, minimum.y), max(v.z, minimum.z), max(v.w, minimum.w))
  - distance
```
public static double distance(VectorReadable4DType v0,
                              VectorReadable4DType v1)
```
    Calculate the distance between the two vectors v0 and v1.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    The distance between the two vectors.
  - dotProduct
```
public static double dotProduct(VectorReadable4DType v0,
                                VectorReadable4DType v1)
```
    Calculate the scalar product of the vectors v0 and v1.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    The scalar product of the two vectors
  - interpolateLinear
```
public static VectorI4D interpolateLinear(VectorReadable4DType v0,
                                          VectorReadable4DType v1,
                                          double alpha)
```
    Linearly interpolate between v0 and v1 by the amount alpha. The alpha parameter controls the degree of interpolation, such that:
    - interpolateLinear(v0, v1, 0.0) = v0
    - interpolateLinear(v0, v1, 1.0) = v1
    Parameters:
    
    v0 - The left input vector.
    
    v1 - The right input vector.
    
    alpha - The interpolation value, between 0.0 and 1.0.
    
    Returns:
    
    (1 - alpha) * v0 + alpha * v1
  - magnitude
```
public static double magnitude(VectorReadable4DType v)
```
    Calculate the magnitude of the vector v. Correspondingly, magnitude(normalize(v)) == 1.0.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    The magnitude of the input vector
  - magnitudeSquared
```
public static double magnitudeSquared(VectorReadable4DType v)
```
    Calculate the squared magnitude of the vector v.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    The squared magnitude of the input vector
  - normalize
```
public static VectorI4D normalize(VectorReadable4DType v)
```
    Normalize the vector v, preserving its direction but reducing it to unit length.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    A vector with the same orientation as v but with magnitude equal to 1.0
  - orthoNormalize
```
public static com.io7m.jfunctional.Pair<VectorI4D,VectorI4D> orthoNormalize(VectorReadable4DType v0,
                                                                            VectorReadable4DType v1)
```
    Orthonormalize and return the vectors v0 and v1 .
    
    See GSP
    
    Parameters:
    
    v0 - The left vector
    
    v1 - The right vector
    
    Returns:
    
    A pair (v0, v1), orthonormalized.
    
    Since:
    
    5.0.0
  - projection
```
public static VectorI4D projection(VectorReadable4DType p,
                                   VectorReadable4DType q)
```
    Calculate the projection of the vector p onto the vector q.
    
    Parameters:
    
    p - The left vector
    
    q - The right vector
    
    Returns:
    
    ((dotProduct p q) / magnitudeSquared q) * q
  - scale
```
public static VectorI4D scale(VectorReadable4DType v,
                              double r)
```
    Scale the vector v by the scalar r.
    
    Parameters:
    
    v - The input vector
    
    r - The scaling value
    
    Returns:
    
    (v.x * r, v.y * r, v.z * r, v.w * r)
  - subtract
```
public static VectorI4D subtract(VectorReadable4DType v0,
                                 VectorReadable4DType v1)
```
    Subtract the vector v1 from the vector v0.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    (v0.x - v1.x, v0.y - v1.y, v0.z - v1.z)
  - equals
```
public boolean equals(@Nullable
                      Object obj)
```
    Overrides:
    
    equals in class Object
  - getWD
```
public double getWD()
```
    Specified by:
    
    getWD in interface VectorReadable4DType
    
    Returns:
    
    The W value of the given vector.
  - getXD
```
public double getXD()
```
    Specified by:
    
    getXD in interface VectorReadable2DType
    
    Returns:
    
    The X value of the given vector.
  - getYD
```
public double getYD()
```
    Specified by:
    
    getYD in interface VectorReadable2DType
    
    Returns:
    
    The Y value of the given vector.
  - getZD
```
public double getZD()
```
    Specified by:
    
    getZD in interface VectorReadable3DType
    
    Returns:
    
    The Z value of the given vector.
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class VectorI4D

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ZERO

Constructor Detail

VectorI4D

VectorI4D

VectorI4D

Method Detail

absolute

add

addScaled

almostEqual

clamp

clampByVector

clampMaximum

clampMaximumByVector

clampMinimum

clampMinimumByVector

distance

dotProduct

interpolateLinear

magnitude

magnitudeSquared

normalize

orthoNormalize

projection

scale

subtract

equals

getWD

getXD

getYD

getZD

hashCode

toString