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

java.lang.Object
- com.io7m.jtensors.parameterized.PVectorI4D<T>

Type Parameters:

T - A phantom type parameter.

All Implemented Interfaces:

PVectorReadable2DType<T>, PVectorReadable3DType<T>, PVectorReadable4DType<T>, VectorReadable2DType, VectorReadable3DType, VectorReadable4DType
```
@Immutable
public final class PVectorI4D<T>
extends Object
implements PVectorReadable4DType<T>
```
A four-dimensional immutable vector type with double elements.

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

Constructor Summary

Constructors
Constructor and Description
`PVectorI4D()` Default constructor, initializing the vector with values `[0.0, 0.0, 0.0, 1.0]`.
`PVectorI4D(double in_x, double in_y, double in_z, double in_w)` Construct a vector initialized with the given values.
`PVectorI4D(PVectorReadable4DType<T> 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 <T> PVectorI4D<T>`	`absolute(PVectorReadable4DType<T> v)` Calculate the absolute value of the vector `v`.
`static <T> PVectorI4D<T>`	`add(PVectorReadable4DType<T> v0, PVectorReadable4DType<T> v1)` Calculate the element-wise sum of the vectors `v0` and `v1`.
`static <T> PVectorI4D<T>`	`addScaled(PVectorReadable4DType<T> v0, PVectorReadable4DType<T> v1, double r)` Calculate the element-wise sum of the vectors `v0` and the element-wise product of `v1` and `r`.
`static <T> boolean`	`almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context, PVectorReadable4DType<T> va, PVectorReadable4DType<T> vb)` Determine whether or not the vectors `va` and `vb` are equal to within the degree of error given in `context`.
`static <T> PVectorI4D<T>`	`clamp(PVectorReadable4DType<T> v, double minimum, double maximum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
`static <T> PVectorI4D<T>`	`clampByPVector(PVectorReadable4DType<T> v, PVectorReadable4DType<T> minimum, PVectorReadable4DType<T> maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`.
`static <T> PVectorI4D<T>`	`clampMaximum(PVectorReadable4DType<T> v, double maximum)` Clamp the elements of the vector `v` to the range {@code [-Infinity ..
`static <T> PVectorI4D<T>`	`clampMaximumByPVector(PVectorReadable4DType<T> v, PVectorReadable4DType<T> maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`.
`static <T> PVectorI4D<T>`	`clampMinimum(PVectorReadable4DType<T> v, double minimum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
`static <T> PVectorI4D<T>`	`clampMinimumByPVector(PVectorReadable4DType<T> v, PVectorReadable4DType<T> minimum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`.
`static <T> double`	`distance(PVectorReadable4DType<T> v0, PVectorReadable4DType<T> v1)` Calculate the distance between the two vectors `v0` and `v1`.
`static <T> double`	`dotProduct(PVectorReadable4DType<T> v0, PVectorReadable4DType<T> 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 <T> PVectorI4D<T>`	`interpolateLinear(PVectorReadable4DType<T> v0, PVectorReadable4DType<T> v1, double alpha)` Linearly interpolate between `v0` and `v1` by the amount `alpha`.
`static <T> double`	`magnitude(PVectorReadable4DType<T> v)` Calculate the magnitude of the vector `v`.
`static <T> double`	`magnitudeSquared(PVectorReadable4DType<T> v)` Calculate the squared magnitude of the vector `v`.
`static <T> PVectorI4D<T>`	`normalize(PVectorReadable4DType<T> v)` Normalize the vector `v`, preserving its direction but reducing it to unit length.
`static <T> com.io7m.jfunctional.Pair<PVectorI4D<T>,PVectorI4D<T>>`	`orthoNormalize(PVectorReadable4DType<T> v0, PVectorReadable4DType<T> v1)` Orthonormalize and return the vectors `v0` and `v1` .
`static <T> PVectorI4D<T>`	`projection(PVectorReadable4DType<T> p, PVectorReadable4DType<T> q)` Calculate the projection of the vector `p` onto the vector `q`.
`static <T> PVectorI4D<T>`	`scale(PVectorReadable4DType<T> v, double r)` Scale the vector `v` by the scalar `r`.
`static <T> PVectorI4D<T>`	`subtract(PVectorReadable4DType<T> v0, PVectorReadable4DType<T> v1)` Subtract the vector `v1` from the vector `v0`.
`String`	`toString()`
`static <T> PVectorI4D<T>`	`zero()`

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

- Constructor Detail
  - PVectorI4D
```
public PVectorI4D()
```
    Default constructor, initializing the vector with values [0.0, 0.0, 0.0, 1.0].
  - PVectorI4D
```
public PVectorI4D(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
  - PVectorI4D
```
public PVectorI4D(PVectorReadable4DType<T> 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 <T> PVectorI4D<T> absolute(PVectorReadable4DType<T> v)
```
    Calculate the absolute value of the vector v.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    (abs v.x, abs v.y, abs v.z, abs v.w)
  - add
```
public static <T> PVectorI4D<T> add(PVectorReadable4DType<T> v0,
                                    PVectorReadable4DType<T> v1)
```
    Calculate the element-wise sum of the vectors v0 and v1.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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 <T> PVectorI4D<T> addScaled(PVectorReadable4DType<T> v0,
                                          PVectorReadable4DType<T> v1,
                                          double r)
```
    Calculate the element-wise sum of the vectors v0 and the element-wise product of v1 and r.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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 <T> boolean almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context,
                                      PVectorReadable4DType<T> va,
                                      PVectorReadable4DType<T> vb)
```
    Determine whether or not the vectors va and vb are equal to within the degree of error given in context.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    context - The equality context
    
    va - The left input vector
    
    vb - The right input vector
    
    Returns:
    
    true iff the vectors are almost equal.
    
    Since:
    
    7.0.0
    
    See Also:
    
    AlmostEqualDouble.almostEqual(AlmostEqualDouble.ContextRelative, double, double)
  - clamp
```
public static <T> PVectorI4D<T> clamp(PVectorReadable4DType<T> v,
                                      double minimum,
                                      double maximum)
```
    Clamp the elements of the vector v to the range [minimum .. maximum] inclusive.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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
  - clampByPVector
```
public static <T> PVectorI4D<T> clampByPVector(PVectorReadable4DType<T> v,
                                               PVectorReadable4DType<T> minimum,
                                               PVectorReadable4DType<T> maximum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum and maximum.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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 <T> PVectorI4D<T> clampMaximum(PVectorReadable4DType<T> v,
                                             double maximum)
```
    Clamp the elements of the vector v to the range [-Infinity .. maximum] inclusive.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v - The input vector
    
    maximum - The maximum allowed value
    
    Returns:
    
    A vector with both elements equal to at most maximum
  - clampMaximumByPVector
```
public static <T> PVectorI4D<T> clampMaximumByPVector(PVectorReadable4DType<T> v,
                                                      PVectorReadable4DType<T> maximum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in maximum.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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 <T> PVectorI4D<T> clampMinimum(PVectorReadable4DType<T> v,
                                             double minimum)
```
    Clamp the elements of the vector v to the range [minimum .. Infinity] inclusive.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v - The input vector
    
    minimum - The minimum allowed value
    
    Returns:
    
    A vector with both elements equal to at least minimum.
  - clampMinimumByPVector
```
public static <T> PVectorI4D<T> clampMinimumByPVector(PVectorReadable4DType<T> v,
                                                      PVectorReadable4DType<T> minimum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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 <T> double distance(PVectorReadable4DType<T> v0,
                                  PVectorReadable4DType<T> v1)
```
    Calculate the distance between the two vectors v0 and v1.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    The distance between the two vectors.
  - dotProduct
```
public static <T> double dotProduct(PVectorReadable4DType<T> v0,
                                    PVectorReadable4DType<T> v1)
```
    Calculate the scalar product of the vectors v0 and v1.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    The scalar product of the two vectors
  - interpolateLinear
```
public static <T> PVectorI4D<T> interpolateLinear(PVectorReadable4DType<T> v0,
                                                  PVectorReadable4DType<T> 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
    Type Parameters:
    
    T - A phantom type parameter.
    
    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 <T> double magnitude(PVectorReadable4DType<T> v)
```
    Calculate the magnitude of the vector v. Correspondingly, magnitude(normalize(v)) == 1.0.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    The magnitude of the input vector
  - magnitudeSquared
```
public static <T> double magnitudeSquared(PVectorReadable4DType<T> v)
```
    Calculate the squared magnitude of the vector v.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    The squared magnitude of the input vector
  - normalize
```
public static <T> PVectorI4D<T> normalize(PVectorReadable4DType<T> v)
```
    Normalize the vector v, preserving its direction but reducing it to unit length.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    A vector with the same orientation as v but with magnitude equal to 1.0
  - orthoNormalize
```
public static <T> com.io7m.jfunctional.Pair<PVectorI4D<T>,PVectorI4D<T>> orthoNormalize(PVectorReadable4DType<T> v0,
                                                                                        PVectorReadable4DType<T> v1)
```
    Orthonormalize and return the vectors v0 and v1 .
    
    See GSP
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v0 - The left vector
    
    v1 - The right vector
    
    Returns:
    
    A pair (v0, v1), orthonormalized.
    
    Since:
    
    7.0.0
  - projection
```
public static <T> PVectorI4D<T> projection(PVectorReadable4DType<T> p,
                                           PVectorReadable4DType<T> q)
```
    Calculate the projection of the vector p onto the vector q.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    p - The left vector
    
    q - The right vector
    
    Returns:
    
    ((dotProduct p q) / magnitudeSquared q) * q
  - scale
```
public static <T> PVectorI4D<T> scale(PVectorReadable4DType<T> v,
                                      double r)
```
    Scale the vector v by the scalar r.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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 <T> PVectorI4D<T> subtract(PVectorReadable4DType<T> v0,
                                         PVectorReadable4DType<T> v1)
```
    Subtract the vector v1 from the vector v0.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    (v0.x - v1.x, v0.y - v1.y, v0.z - v1.z)
  - zero
```
public static <T> PVectorI4D<T> zero()
```
    Type Parameters:
    
    T - A phantom type parameter.
    
    Returns:
    
    The zero vector.
  - 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 PVectorI4D<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

PVectorI4D

PVectorI4D

PVectorI4D

Method Detail

absolute

add

addScaled

almostEqual

clamp

clampByPVector

clampMaximum

clampMaximumByPVector

clampMinimum

clampMinimumByPVector

distance

dotProduct

interpolateLinear

magnitude

magnitudeSquared

normalize

orthoNormalize

projection

scale

subtract

zero

equals

getWD

getXD

getYD

getZD

hashCode

toString