VectorI3D (io7m-jtensors-documentation 7.1.0 API)

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

All Implemented Interfaces:

VectorReadable2DType, VectorReadable3DType
```
@Immutable
public final class VectorI3D
extends Object
implements VectorReadable3DType
```
A three-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 VectorI3D ZERO
The zero vector.

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

Constructor Summary

Constructors
Constructor and Description
`VectorI3D()` Default constructor, initializing the vector with values `[0.0, 0.0, 0.0]`.
`VectorI3D(double in_x, double in_y, double in_z)` Construct a vector initialized with the given values.
`VectorI3D(VectorReadable3DType 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 VectorI3D`	`absolute(VectorReadable3DType v)` Calculate the absolute value of the vector `v`.
`static VectorI3D`	`add(VectorReadable3DType v0, VectorReadable3DType v1)` Calculate the element-wise sum of the vectors `v0` and `v1`.
`static VectorI3D`	`addScaled(VectorReadable3DType v0, VectorReadable3DType 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, VectorReadable3DType qa, VectorReadable3DType qb)` Determine whether or not the vectors `qa` and `qb` are equal to within the degree of error given in `context`.
`static VectorI3D`	`clamp(VectorReadable3DType v, double minimum, double maximum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
`static VectorI3D`	`clampByVector(VectorReadable3DType v, VectorReadable3DType minimum, VectorReadable3DType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`.
`static VectorI3D`	`clampMaximum(VectorReadable3DType v, double maximum)` Clamp the elements of the vector `v` to the range {@code [-Infinity ..
`static VectorI3D`	`clampMaximumByVector(VectorReadable3DType v, VectorReadable3DType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`.
`static VectorI3D`	`clampMinimum(VectorReadable3DType v, double minimum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
`static VectorI3D`	`clampMinimumByVector(VectorReadable3DType v, VectorReadable3DType minimum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`.
`static VectorI3D`	`crossProduct(VectorReadable3DType v0, VectorReadable3DType v1)` Calculate the cross product of the vectors `v0` and `v1`.
`static double`	`distance(VectorReadable3DType v0, VectorReadable3DType v1)` Calculate the distance between the two vectors `v0` and `v1`.
`static double`	`dotProduct(VectorReadable3DType v0, VectorReadable3DType v1)` Calculate the scalar product of the vectors `v0` and `v1`.
`boolean`	`equals(Object obj)`
`double`	`getXD()`
`double`	`getYD()`
`double`	`getZD()`
`int`	`hashCode()`
`static VectorI3D`	`interpolateLinear(VectorReadable3DType v0, VectorReadable3DType v1, double alpha)` Linearly interpolate between `v0` and `v1` by the amount `alpha`.
`static double`	`magnitude(VectorReadable3DType v)` Calculate the magnitude of the vector `v`.
`static double`	`magnitudeSquared(VectorReadable3DType v)` Calculate the squared magnitude of the vector `v`.
`static VectorI3D`	`normalize(VectorReadable3DType v)` Normalize the vector `v`, preserving its direction but reducing it to unit length.
`static com.io7m.jfunctional.Pair<VectorI3D,VectorI3D>`	`orthoNormalize(VectorReadable3DType v0, VectorReadable3DType v1)` Orthonormalize and return the vectors `v0` and `v1` .
`static VectorI3D`	`projection(VectorReadable3DType p, VectorReadable3DType q)` Calculate the projection of the vector `p` onto the vector `q`.
`static VectorI3D`	`scale(VectorReadable3DType v, double r)` Scale the vector `v` by the scalar `r`.
`static VectorI3D`	`subtract(VectorReadable3DType v0, VectorReadable3DType 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 VectorI3D ZERO
```
    The zero vector.
- Constructor Detail
  - VectorI3D
```
public VectorI3D()
```
    Default constructor, initializing the vector with values [0.0, 0.0, 0.0].
  - VectorI3D
```
public VectorI3D(double in_x,
                 double in_y,
                 double in_z)
```
    Construct a vector initialized with the given values.
    
    Parameters:
    
    in_x - The x value
    
    in_y - The y value
    
    in_z - The z value
  - VectorI3D
```
public VectorI3D(VectorReadable3DType 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 VectorI3D absolute(VectorReadable3DType v)
```
    Calculate the absolute value of the vector v.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    (abs v.x, abs v.y, abs v.z)
  - add
```
public static VectorI3D add(VectorReadable3DType v0,
                            VectorReadable3DType 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)
  - addScaled
```
public static VectorI3D addScaled(VectorReadable3DType v0,
                                  VectorReadable3DType 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))
  - almostEqual
```
public static boolean almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context,
                                  VectorReadable3DType qa,
                                  VectorReadable3DType qb)
```
    Determine whether or not the vectors qa and qb are equal to within the degree of error given in context.
    
    Parameters:
    
    context - The equality context
    
    qa - The left input vector
    
    qb - The right input vector
    
    Returns:
    
    true iff the vectors are almost equal.
    
    Since:
    
    5.0.0
    
    See Also:
    
    AlmostEqualDouble.almostEqual(ContextRelative, double, double)
  - clamp
```
public static VectorI3D clamp(VectorReadable3DType 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 VectorI3D clampByVector(VectorReadable3DType v,
                                      VectorReadable3DType minimum,
                                      VectorReadable3DType 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))
  - clampMaximum
```
public static VectorI3D clampMaximum(VectorReadable3DType 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 VectorI3D clampMaximumByVector(VectorReadable3DType v,
                                             VectorReadable3DType 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))
  - clampMinimum
```
public static VectorI3D clampMinimum(VectorReadable3DType 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 VectorI3D clampMinimumByVector(VectorReadable3DType v,
                                             VectorReadable3DType 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))
  - crossProduct
```
public static VectorI3D crossProduct(VectorReadable3DType v0,
                                     VectorReadable3DType v1)
```
    Calculate the cross product of the vectors v0 and v1. The result is a vector perpendicular to both vectors.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    A vector perpendicular to both v0 and v1
  - distance
```
public static double distance(VectorReadable3DType v0,
                              VectorReadable3DType 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(VectorReadable3DType v0,
                                VectorReadable3DType 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 VectorI3D interpolateLinear(VectorReadable3DType v0,
                                          VectorReadable3DType 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(VectorReadable3DType 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(VectorReadable3DType 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 VectorI3D normalize(VectorReadable3DType 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<VectorI3D,VectorI3D> orthoNormalize(VectorReadable3DType v0,
                                                                            VectorReadable3DType 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 VectorI3D projection(VectorReadable3DType p,
                                   VectorReadable3DType 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 VectorI3D scale(VectorReadable3DType 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)
  - subtract
```
public static VectorI3D subtract(VectorReadable3DType v0,
                                 VectorReadable3DType 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
  - 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 VectorI3D

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ZERO

Constructor Detail

VectorI3D

VectorI3D

VectorI3D

Method Detail

absolute

add

addScaled

almostEqual

clamp

clampByVector

clampMaximum

clampMaximumByVector

clampMinimum

clampMinimumByVector

crossProduct

distance

dotProduct

interpolateLinear

magnitude

magnitudeSquared

normalize

orthoNormalize

projection

scale

subtract

equals

getXD

getYD

getZD

hashCode

toString