VectorI4F (io7m-jtensors-documentation 7.0.0-beta0004 API)

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

All Implemented Interfaces:

VectorReadable2FType, VectorReadable3FType, VectorReadable4FType
```
@Immutable
public final class VectorI4F
extends Object
implements VectorReadable4FType
```
A four-dimensional immutable vector type with float 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 VectorI4F ZERO
The zero vector.

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

Constructor Summary

Constructors
Constructor and Description
`VectorI4F()` Default constructor, initializing the vector with values `[0.0, 0.0, 0.0, 1.0]`.
`VectorI4F(float in_x, float in_y, float in_z, float in_w)` Construct a vector initialized with the given values.
`VectorI4F(VectorReadable4FType 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 VectorI4F`	`absolute(VectorReadable4FType v)` Calculate the absolute value of the vector `v`.
`static VectorI4F`	`add(VectorReadable4FType v0, VectorReadable4FType v1)` Calculate the element-wise sum of the vectors `v0` and `v1`.
`static VectorI4F`	`addScaled(VectorReadable4FType v0, VectorReadable4FType v1, float 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.AlmostEqualFloat.ContextRelative context, VectorReadable4FType va, VectorReadable4FType vb)` Determine whether or not the vectors `va` and `vb` are equal to within the degree of error given in `context`.
`static VectorI4F`	`clamp(VectorReadable4FType v, float minimum, float maximum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
`static VectorI4F`	`clampByVector(VectorReadable4FType v, VectorReadable4FType minimum, VectorReadable4FType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`.
`static VectorI4F`	`clampMaximum(VectorReadable4FType v, float maximum)` Clamp the elements of the vector `v` to the range {@code [-Infinity ..
`static VectorI4F`	`clampMaximumByVector(VectorReadable4FType v, VectorReadable4FType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`.
`static VectorI4F`	`clampMinimum(VectorReadable4FType v, float minimum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
`static VectorI4F`	`clampMinimumByVector(VectorReadable4FType v, VectorReadable4FType minimum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`.
`static float`	`distance(VectorReadable4FType v0, VectorReadable4FType v1)` Calculate the distance between the two vectors `v0` and `v1`.
`static float`	`dotProduct(VectorReadable4FType v0, VectorReadable4FType v1)` Calculate the scalar product of the vectors `v0` and `v1`.
`boolean`	`equals(Object obj)`
`float`	`getWF()`
`float`	`getXF()`
`float`	`getYF()`
`float`	`getZF()`
`int`	`hashCode()`
`static VectorI4F`	`interpolateLinear(VectorReadable4FType v0, VectorReadable4FType v1, float alpha)` Linearly interpolate between `v0` and `v1` by the amount `alpha`.
`static float`	`magnitude(VectorReadable4FType v)` Calculate the magnitude of the vector `v`.
`static float`	`magnitudeSquared(VectorReadable4FType v)` Calculate the squared magnitude of the vector `v`.
`static VectorI4F`	`normalize(VectorReadable4FType v)` Normalize the vector `v`, preserving its direction but reducing it to unit length.
`static com.io7m.jfunctional.Pair<VectorI4F,VectorI4F>`	`orthoNormalize(VectorReadable4FType v0, VectorReadable4FType v1)` Orthonormalize and return the vectors `v0` and `v1` .
`static VectorI4F`	`projection(VectorReadable4FType p, VectorReadable4FType q)` Calculate the projection of the vector `p` onto the vector `q`.
`static VectorI4F`	`scale(VectorReadable4FType v, float r)` Scale the vector `v` by the scalar `r`.
`static VectorI4F`	`subtract(VectorReadable4FType v0, VectorReadable4FType 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 VectorI4F ZERO
```
    The zero vector.
- Constructor Detail
  - VectorI4F
```
public VectorI4F()
```
    Default constructor, initializing the vector with values [0.0, 0.0, 0.0, 1.0].
  - VectorI4F
```
public VectorI4F(float in_x,
                 float in_y,
                 float in_z,
                 float 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
  - VectorI4F
```
public VectorI4F(VectorReadable4FType in_v)
```
    Construct a vector initialized with the values given in the vector in_v.
    
    Parameters:
    
    in_v - The source vector
- Method Detail
  - absolute
```
public static VectorI4F absolute(VectorReadable4FType v)
```
    Calculate the absolute value of the vector v.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    (abs v.getXF(), abs v.getYF(), abs v.getZF(), abs v.getWF())
  - add
```
public static VectorI4F add(VectorReadable4FType v0,
                            VectorReadable4FType 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.getXF() + v1.getXF(), v0.getYF() + v1.getYF(), v0.getZF() + v1.getZF(), v0.getWF() + v1.getWF())
  - addScaled
```
public static VectorI4F addScaled(VectorReadable4FType v0,
                                  VectorReadable4FType v1,
                                  float 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.getXF() + (v1.getXF() * r), v0.getYF() + (v1.getYF() * r), v0.getZF() + (v1.getZF() * r), v0.getWF() + (v1.getWF() * r))
  - almostEqual
```
public static boolean almostEqual(com.io7m.jequality.AlmostEqualFloat.ContextRelative context,
                                  VectorReadable4FType va,
                                  VectorReadable4FType 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:
    
    AlmostEqualFloat.almostEqual(AlmostEqualFloat.ContextRelative, float, float)
  - clamp
```
public static VectorI4F clamp(VectorReadable4FType v,
                              float minimum,
                              float 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 VectorI4F clampByVector(VectorReadable4FType v,
                                      VectorReadable4FType minimum,
                                      VectorReadable4FType 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.getXF(), minimum.getXF()), maximum.getXF()), min(max(v.getYF(), minimum.getYF()), maximum.getYF()), min(max(v.getZF(), minimum.getZF()), maximum.getZF()), min(max(v.getWF(), minimum.getWF()), maximum.getWF()) )
  - clampMaximum
```
public static VectorI4F clampMaximum(VectorReadable4FType v,
                                     float 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 VectorI4F clampMaximumByVector(VectorReadable4FType v,
                                             VectorReadable4FType 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.getXF(), maximum.getXF()), min(v.getYF(), maximum.getYF()), min(v.getZF(), maximum.getZF()), min(v.getWF(), maximum.getWF()))
  - clampMinimum
```
public static VectorI4F clampMinimum(VectorReadable4FType v,
                                     float 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 VectorI4F clampMinimumByVector(VectorReadable4FType v,
                                             VectorReadable4FType 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.getXF(), minimum.getXF()), max(v.getYF(), minimum.getYF()), max(v.getZF(), minimum.getZF()), max(v.getWF(), minimum.getWF()))
  - distance
```
public static float distance(VectorReadable4FType v0,
                             VectorReadable4FType 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 float dotProduct(VectorReadable4FType v0,
                               VectorReadable4FType 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 VectorI4F interpolateLinear(VectorReadable4FType v0,
                                          VectorReadable4FType v1,
                                          float 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 float magnitude(VectorReadable4FType 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 float magnitudeSquared(VectorReadable4FType 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 VectorI4F normalize(VectorReadable4FType 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<VectorI4F,VectorI4F> orthoNormalize(VectorReadable4FType v0,
                                                                            VectorReadable4FType 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 VectorI4F projection(VectorReadable4FType p,
                                   VectorReadable4FType 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 VectorI4F scale(VectorReadable4FType v,
                              float r)
```
    Scale the vector v by the scalar r.
    
    Parameters:
    
    v - The input vector
    
    r - The scaling value
    
    Returns:
    
    (v.getXF() * r, v.getYF() * r, v.getZF() * r, v.getWF() * r)
  - subtract
```
public static VectorI4F subtract(VectorReadable4FType v0,
                                 VectorReadable4FType v1)
```
    Subtract the vector v1 from the vector v0.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    (v0.getXF() - v1.getXF(), v0.getYF() - v1.getYF(), v0.getZF() - v1.getZF())
  - equals
```
public boolean equals(@Nullable
                      Object obj)
```
    Overrides:
    
    equals in class Object
  - getWF
```
public float getWF()
```
    Specified by:
    
    getWF in interface VectorReadable4FType
    
    Returns:
    
    The W value of the given vector.
  - getXF
```
public float getXF()
```
    Specified by:
    
    getXF in interface VectorReadable2FType
    
    Returns:
    
    The X value of the given vector.
  - getYF
```
public float getYF()
```
    Specified by:
    
    getYF in interface VectorReadable2FType
    
    Returns:
    
    The Y value of the given vector.
  - getZF
```
public float getZF()
```
    Specified by:
    
    getZF in interface VectorReadable3FType
    
    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 VectorI4F

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ZERO

Constructor Detail

VectorI4F

VectorI4F

VectorI4F

Method Detail

absolute

add

addScaled

almostEqual

clamp

clampByVector

clampMaximum

clampMaximumByVector

clampMinimum

clampMinimumByVector

distance

dotProduct

interpolateLinear

magnitude

magnitudeSquared

normalize

orthoNormalize

projection

scale

subtract

equals

getWF

getXF

getYF

getZF

hashCode

toString