PVectors4L (com.io7m.jtensors.documentation 8.2.0 API)

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

```
public final class PVectors4L
extends Object
```
Functions over PVector4L 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 and Description
`static <T> PVector4L<T>`	`absolute(PVector4L<T> v0)` Calculate the absolute of `v0`.
`static <T> PVector4L<T>`	`add(PVector4L<T> v0, PVector4L<T> v1)` Add `v0` to `v1`.
`static <T> PVector4L<T>`	`addScaled(PVector4L<T> v0, PVector4L<T> v1, double r)` Add `v0` to `v1 * r`.
`static <T> PVector4L<T>`	`clamp(PVector4L<T> v, PVector4L<T> v_min, PVector4L<T> v_max)` Clamp the values in `v` by `v_min` and `v_max`.
`static <T> long`	`distance(PVector4L<T> v0, PVector4L<T> v1)` Calculate the distance between `v0` and `v1`.
`static <T> long`	`dotProduct(PVector4L<T> v0, PVector4L<T> v1)` Calculate the scalar product of the vectors `v0` and `v1`.
`static <T> PVector4L<T>`	`interpolateBilinear(PVector4L<T> x0y0, PVector4L<T> x1y0, PVector4L<T> x0y1, PVector4L<T> x1y1, double px, double py)` Bilinearly interpolate between `x0y0`, `x1y0`, `x0y1`, `x1y1`.
`static <T> PVector4L<T>`	`interpolateLinear(PVector4L<T> v0, PVector4L<T> v1, double alpha)` Linearly interpolate between `v0` and `v1` by the amount `alpha`.
`static <T> double`	`magnitude(PVector4L<T> v0)` Calculate the magnitude of the vector `v0`.
`static <T> long`	`magnitudeSquared(PVector4L<T> v0)` Calculate the squared magnitude of the vector `v0`.
`static <T> PVector4L<T>`	`negate(PVector4L<T> v)` Calculate the negation of `v`.
`static <T> PVector4L<T>`	`scale(PVector4L<T> v0, double r)` Scale `v0` by `r`.
`static <T> PVector4L<T>`	`subtract(PVector4L<T> v0, PVector4L<T> v1)` Subtract `v1` from `v0`.
`static <A> PVector4L<A>`	`toParameterized(Vector4L v)`
`static <A> Vector4L`	`toUnparameterized(PVector4L<A> v)`
`static <T> PVector4L<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> PVector4L<T> absolute(PVector4L<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> PVector4L<T> add(PVector4L<T> v0,
                                   PVector4L<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> PVector4L<T> addScaled(PVector4L<T> v0,
                                         PVector4L<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> PVector4L<T> clamp(PVector4L<T> v,
                                     PVector4L<T> v_min,
                                     PVector4L<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> long distance(PVector4L<T> v0,
                                PVector4L<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> long dotProduct(PVector4L<T> v0,
                                  PVector4L<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> PVector4L<T> interpolateLinear(PVector4L<T> v0,
                                                 PVector4L<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> PVector4L<T> interpolateBilinear(PVector4L<T> x0y0,
                                                   PVector4L<T> x1y0,
                                                   PVector4L<T> x0y1,
                                                   PVector4L<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> long magnitudeSquared(PVector4L<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(PVector4L<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> PVector4L<T> negate(PVector4L<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)
  - scale
```
public static <T> PVector4L<T> scale(PVector4L<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> PVector4L<T> subtract(PVector4L<T> v0,
                                        PVector4L<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> PVector4L<T> zero()
```
    The zero vector.
    
    Type Parameters:
    
    T - A phantom type parameter
    
    Returns:
    
    (0, 0, 0, 0)
  - toUnparameterized
```
public static <A> Vector4L toUnparameterized(PVector4L<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> PVector4L<A> toParameterized(Vector4L 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 PVectors4L

Method Summary

Methods inherited from class java.lang.Object

Method Detail

absolute

add

addScaled

clamp

distance

dotProduct

interpolateLinear

interpolateBilinear

magnitudeSquared

magnitude

negate

scale

subtract

zero

toUnparameterized

toParameterized