PVectors4D (com.io7m.jtensors.documentation 9.0.0 API)

java.lang.Object
- com.io7m.jtensors.core.parameterized.vectors.PVectors4D

```
public final class PVectors4D
extends Object
```
Functions over PVector4D values.

See "Mathematics for 3D Game Programming and Computer Graphics" 2nd Ed for the derivations of most of the code in this class (ISBN: 1-58450-277-0).

Since:

8.0.0

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static <T> PVector4D<T>`	`absolute(PVector4D<T> v0)`	Calculate the absolute of `v0`.
`static <T> PVector4D<T>`	`add(PVector4D<T> v0, PVector4D<T> v1)`	Add `v0` to `v1`.
`static <T> PVector4D<T>`	`addScaled(PVector4D<T> v0, PVector4D<T> v1, double r)`	Add `v0` to `v1 * r`.
`static <T> PVector4D<T>`	`clamp(PVector4D<T> v, PVector4D<T> v_min, PVector4D<T> v_max)`	Clamp the values in `v` by `v_min` and `v_max`.
`static <T> double`	`distance(PVector4D<T> v0, PVector4D<T> v1)`	Calculate the distance between `v0` and `v1`.
`static <T> double`	`dotProduct(PVector4D<T> v0, PVector4D<T> v1)`	Calculate the scalar product of the vectors `v0` and `v1`.
`static <T> PVector4D<T>`	`interpolateBilinear(PVector4D<T> x0y0, PVector4D<T> x1y0, PVector4D<T> x0y1, PVector4D<T> x1y1, double px, double py)`	Bilinearly interpolate between `x0y0`, `x1y0`, `x0y1`, `x1y1`.
`static <T> PVector4D<T>`	`interpolateLinear(PVector4D<T> v0, PVector4D<T> v1, double alpha)`	Linearly interpolate between `v0` and `v1` by the amount `alpha`.
`static <T> double`	`magnitude(PVector4D<T> v0)`	Calculate the magnitude of the vector `v0`.
`static <T> double`	`magnitudeSquared(PVector4D<T> v0)`	Calculate the squared magnitude of the vector `v0`.
`static <T> PVector4D<T>`	`negate(PVector4D<T> v)`	Calculate the negation of `v`.
`static <T> PVector4D<T>`	`normalize(PVector4D<T> v0)`	Normalize the vector `v0`.
`static <T> PVector4D<T>`	`scale(PVector4D<T> v0, double r)`	Scale `v0` by `r`.
`static <T> PVector4D<T>`	`subtract(PVector4D<T> v0, PVector4D<T> v1)`	Subtract `v1` from `v0`.
`static <A> PVector4D<A>`	`toParameterized(Vector4D v)`
`static <A> Vector4D`	`toUnparameterized(PVector4D<A> v)`
`static <T> PVector4D<T>`	`zero()`	The zero vector.

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

- Method Detail
  - absolute
```
public static <T> PVector4D<T> absolute(PVector4D<T> v0)
```
    Calculate the absolute of v0.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v0 The vector
    
    Returns:
    
    (abs v0.x, abs v0.y, abs v0.z, abs v0.w)
  - add
```
public static <T> PVector4D<T> add(PVector4D<T> v0,
                                   PVector4D<T> v1)
```
    Add v0 to v1.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v0 The left vector
    
    Parameters:
    
    v1 - The right vector
    
    Returns:
    
    (v0.x + v1.x, v0.y + v0.y, v0.z + v1.z, v0.w + v1.w)
  - addScaled
```
public static <T> PVector4D<T> addScaled(PVector4D<T> v0,
                                         PVector4D<T> v1,
                                         double r)
```
    Add v0 to v1 * r.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v0 The left vector
    
    Parameters:
    
    v1 - The right vector
    
    r - The scaling value
    
    Returns:
    
    (v0.x + (v1.x * r), v0.y + (v0.y * r), v0.z + (v1.z * r), v0.w + (v1.w * r))
  - clamp
```
public static <T> PVector4D<T> clamp(PVector4D<T> v,
                                     PVector4D<T> v_min,
                                     PVector4D<T> v_max)
```
    Clamp the values in v by v_min and v_max.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v The source vector
    
    Parameters:
    
    v_min - The minimum vector
    
    v_max - The maximum vector
    
    Returns:
    
    (max(min(v.x, v_max.x()), v_min.x()), max(min(v.y, v_max.y()), v_min.y()), max(min(v.z, v_max.z()), v_min.z()), max(min(v.w, v_max.w()), v_min.w()))
  - distance
```
public static <T> double distance(PVector4D<T> v0,
                                  PVector4D<T> v1)
```
    Calculate the distance between v0 and v1.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v0 The left vector
    
    Parameters:
    
    v1 - The right vector
    
    Returns:
    
    The distance between v0 and v1.
  - dotProduct
```
public static <T> double dotProduct(PVector4D<T> v0,
                                    PVector4D<T> v1)
```
    Calculate the scalar product of the vectors v0 and v1.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v0 The left vector
    
    Parameters:
    
    v1 - The right vector
    
    Returns:
    
    The scalar product of the two vectors
  - interpolateLinear
```
public static <T> PVector4D<T> interpolateLinear(PVector4D<T> v0,
                                                 PVector4D<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 * @return ((1 - alpha) * v0) + (alpha * v1)
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    alpha - The interpolation value in the range [0, 1]
  - interpolateBilinear
```
public static <T> PVector4D<T> interpolateBilinear(PVector4D<T> x0y0,
                                                   PVector4D<T> x1y0,
                                                   PVector4D<T> x0y1,
                                                   PVector4D<T> x1y1,
                                                   double px,
                                                   double py)
```
    Bilinearly interpolate between x0y0, x1y0, x0y1, x1y1.
    
    The px and py parameters control the degree of interpolation, such that:
    - interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 0.0, 0.0) = x0y0
    - interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 1.0, 0.0) = x1y0
    - interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 0.0, 1.0) = x0y1
    - interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 1.0, 1.0) = x1y1
    Type Parameters:
    
    T - A phantom type parameter * @return The bilinearly interpolated value
    
    Parameters:
    
    x0y0 - The top left input vector
    
    x1y0 - The top right input vector
    
    x0y1 - The bottom left input vector
    
    x1y1 - The bottom right input vector
    
    px - The X interpolation value in the range [0, 1]
    
    py - The Y interpolation value in the range [0, 1]
  - magnitudeSquared
```
public static <T> double magnitudeSquared(PVector4D<T> v0)
```
    Calculate the squared magnitude of the vector v0.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v0 The vector
    
    Returns:
    
    The squared magnitude of the vector
  - magnitude
```
public static <T> double magnitude(PVector4D<T> v0)
```
    Calculate the magnitude of the vector v0.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v0 The vector
    
    Returns:
    
    The magnitude of the vector
  - negate
```
public static <T> PVector4D<T> negate(PVector4D<T> v)
```
    Calculate the negation of v.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v The vector
    
    Returns:
    
    (-v.x, -v.y, -v.z, -v.w)
  - normalize
```
public static <T> PVector4D<T> normalize(PVector4D<T> v0)
```
    Normalize the vector v0.
    
    If the magnitude of the vector is zero, the function returns v0.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v0 The vector
    
    Returns:
    
    A normalized copy of v0
  - scale
```
public static <T> PVector4D<T> scale(PVector4D<T> v0,
                                     double r)
```
    Scale v0 by r.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v0 The left vector
    
    Parameters:
    
    r - The scaling value
    
    Returns:
    
    (v0.x * r, v0.y * r, v0.z * r, v0.w * r)
  - subtract
```
public static <T> PVector4D<T> subtract(PVector4D<T> v0,
                                        PVector4D<T> v1)
```
    Subtract v1 from v0.
    
    Type Parameters:
    
    T - A phantom type parameter * @param v0 The left vector
    
    Parameters:
    
    v1 - The right vector
    
    Returns:
    
    (v0.x - v1.x, v0.y - v0.y, v0.z - v1.z, v0.w - v1.w)
  - zero
```
public static <T> PVector4D<T> zero()
```
    The zero vector.
    
    Type Parameters:
    
    T - A phantom type parameter
    
    Returns:
    
    (0, 0, 0, 0)
  - toUnparameterized
```
public static <A> Vector4D toUnparameterized(PVector4D<A> v)
```
    Type Parameters:
    
    A - A phantom type parameter (possibly representing a coordinate system)
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    A vector equal to m but without type parameters
  - toParameterized
```
public static <A> PVector4D<A> toParameterized(Vector4D v)
```
    Type Parameters:
    
    A - A phantom type parameter (possibly representing a coordinate system)
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    A vector equal to v with type parameters

Class PVectors4D

Method Summary

Methods inherited from class java.lang.Object

Method Detail

absolute

add

addScaled

clamp

distance

dotProduct

interpolateLinear

interpolateBilinear

magnitudeSquared

magnitude

negate

normalize

scale

subtract

zero

toUnparameterized

toParameterized