Package org.joml

# Interface Vector4fc

All Known Implementing Classes:
`Vector4f`

public interface Vector4fc
Interface to a read-only view of a 4-dimensional vector of single-precision floats.
Author:
Kai Burjack
• ## Method Summary

Modifier and Type
Method
Description
`Vector4f`
`absolute(Vector4f dest)`
Compute the absolute of each of this vector's components and store the result into `dest`.
`Vector4f`
```add(float x, float y, float z, float w, Vector4f dest)```
Increment the components of this vector by the given values and store the result in `dest`.
`Vector4f`
```add(Vector4fc v, Vector4f dest)```
Add the supplied vector to this one and store the result in `dest`.
`float`
`angle(Vector4fc v)`
Return the angle between this vector and the supplied vector.
`float`
`angleCos(Vector4fc v)`
Return the cosine of the angle between this vector and the supplied vector.
`Vector4f`
`ceil(Vector4f dest)`
Compute for each component of this vector the smallest (closest to negative infinity) `float` value that is greater than or equal to that component and is equal to a mathematical integer and store the result in `dest`.
`float`
```distance(float x, float y, float z, float w)```
Return the distance between `this` vector and `(x, y, z, w)`.
`float`
`distance(Vector4fc v)`
Return the distance between this Vector and `v`.
`float`
```distanceSquared(float x, float y, float z, float w)```
Return the square of the distance between `this` vector and `(x, y, z, w)`.
`float`
`distanceSquared(Vector4fc v)`
Return the square of the distance between this vector and `v`.
`Vector4f`
```div(float x, float y, float z, float w, Vector4f dest)```
Divide the components of this Vector4f by the given scalar values and store the result in `dest`.
`Vector4f`
```div(float scalar, Vector4f dest)```
Divide all components of this `Vector4f` by the given scalar value and store the result in `dest`.
`Vector4f`
```div(Vector4fc v, Vector4f dest)```
Divide this Vector4f component-wise by another Vector4f and store the result in `dest`.
`float`
```dot(float x, float y, float z, float w)```
Compute the dot product (inner product) of this vector and `(x, y, z, w)`.
`float`
`dot(Vector4fc v)`
Compute the dot product (inner product) of this vector and `v` .
`boolean`
```equals(float x, float y, float z, float w)```
Compare the vector components of `this` vector with the given `(x, y, z, w)` and return whether all of them are equal.
`boolean`
```equals(Vector4fc v, float delta)```
Compare the vector components of `this` vector with the given vector using the given `delta` and return whether all of them are equal within a maximum difference of `delta`.
`Vector4f`
`floor(Vector4f dest)`
Compute for each component of this vector the largest (closest to positive infinity) `float` value that is less than or equal to that component and is equal to a mathematical integer and store the result in `dest`.
`Vector4f`
```fma(float a, Vector4fc b, Vector4f dest)```
Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`Vector4f`
```fma(Vector4fc a, Vector4fc b, Vector4f dest)```
Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
`float`
`get(int component)`
Get the value of the specified component of this vector.
`ByteBuffer`
```get(int index, ByteBuffer buffer)```
Store this vector into the supplied `ByteBuffer` starting at the specified absolute buffer position/index.
`FloatBuffer`
```get(int index, FloatBuffer buffer)```
Store this vector into the supplied `FloatBuffer` starting at the specified absolute buffer position/index.
`Vector4i`
```get(int mode, Vector4i dest)```
Set the components of the given vector `dest` to those of `this` vector using the given `RoundingMode`.
`ByteBuffer`
`get(ByteBuffer buffer)`
Store this vector into the supplied `ByteBuffer` at the current buffer `position`.
`FloatBuffer`
`get(FloatBuffer buffer)`
Store this vector into the supplied `FloatBuffer` at the current buffer `position`.
`Vector4d`
`get(Vector4d dest)`
Set the components of the given vector `dest` to those of `this` vector.
`Vector4f`
`get(Vector4f dest)`
Set the components of the given vector `dest` to those of `this` vector.
`Vector4fc`
`getToAddress(long address)`
Store this vector at the given off-heap memory address.
`Vector4f`
```hermite(Vector4fc t0, Vector4fc v1, Vector4fc t1, float t, Vector4f dest)```
Compute a hermite interpolation between `this` vector and its associated tangent `t0` and the given vector `v` with its tangent `t1` and store the result in `dest`.
`boolean`
`isFinite()`
Determine whether all components are finite floating-point values, that is, they are not `NaN` and not `infinity`.
`float`
`length()`
Return the length of this vector.
`float`
`lengthSquared()`
Return the length squared of this vector.
`Vector4f`
```lerp(Vector4fc other, float t, Vector4f dest)```
Linearly interpolate `this` and `other` using the given interpolation factor `t` and store the result in `dest`.
`Vector4f`
```max(Vector4fc v, Vector4f dest)```
Set the components of `dest` to be the component-wise maximum of this and the other vector.
`int`
`maxComponent()`
Determine the component with the biggest absolute value.
`Vector4f`
```min(Vector4fc v, Vector4f dest)```
Set the components of `dest` to be the component-wise minimum of this and the other vector.
`int`
`minComponent()`
Determine the component with the smallest (towards zero) absolute value.
`Vector4f`
```mul(float x, float y, float z, float w, Vector4f dest)```
Multiply the components of this Vector4f by the given scalar values and store the result in `dest`.
`Vector4f`
```mul(float scalar, Vector4f dest)```
Multiply all components of this `Vector4f` by the given scalar value and store the result in `dest`.
`Vector4f`
```mul(Matrix4fc mat, Vector4f dest)```
Multiply the given matrix mat with this Vector4f and store the result in `dest`.
`Vector4f`
```mul(Matrix4x3fc mat, Vector4f dest)```
Multiply the given matrix mat with this Vector4f and store the result in `dest`.
`Vector4f`
```mul(Vector4fc v, Vector4f dest)```
Multiply this Vector4f component-wise by another Vector4f and store the result in `dest`.
`Vector4f`
```mulAdd(float a, Vector4fc b, Vector4f dest)```
Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
`Vector4f`
```mulAdd(Vector4fc a, Vector4fc b, Vector4f dest)```
Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
`Vector4f`
```mulAffine(Matrix4fc mat, Vector4f dest)```
Multiply the given affine matrix mat with this Vector4f and store the result in `dest`.
`Vector4f`
```mulAffineTranspose(Matrix4fc mat, Vector4f dest)```
Multiply the transpose of the given affine matrix `mat` with this Vector4f and store the result in `dest`.
`Vector3f`
```mulProject(Matrix4fc mat, Vector3f dest)```
Multiply the given matrix `mat` with this Vector4f, perform perspective division and store the `(x, y, z)` result in `dest`.
`Vector4f`
```mulProject(Matrix4fc mat, Vector4f dest)```
Multiply the given matrix `mat` with this Vector4f, perform perspective division and store the result in `dest`.
`Vector4f`
```mulTranspose(Matrix4fc mat, Vector4f dest)```
Multiply the transpose of the given matrix `mat` with this Vector4f and store the result in `dest`.
`Vector4f`
`negate(Vector4f dest)`
Negate this vector and store the result in `dest`.
`Vector4f`
```normalize(float length, Vector4f dest)```
Scale this vector to have the given length and store the result in `dest`.
`Vector4f`
`normalize(Vector4f dest)`
Normalizes this vector and store the result in `dest`.
`Vector4f`
`normalize3(Vector4f dest)`
Normalize this vector by computing only the norm of `(x, y, z)` and store the result in `dest`.
`Vector4f`
```rotate(Quaternionfc quat, Vector4f dest)```
Rotate this vector by the given quaternion `quat` and store the result in `dest`.
`Vector4f`
```rotateAxis(float angle, float aX, float aY, float aZ, Vector4f dest)```
Rotate this vector the specified radians around the given rotation axis and store the result into `dest`.
`Vector4f`
```rotateX(float angle, Vector4f dest)```
Rotate this vector the specified radians around the X axis and store the result into `dest`.
`Vector4f`
```rotateY(float angle, Vector4f dest)```
Rotate this vector the specified radians around the Y axis and store the result into `dest`.
`Vector4f`
```rotateZ(float angle, Vector4f dest)```
Rotate this vector the specified radians around the Z axis and store the result into `dest`.
`Vector4f`
`round(Vector4f dest)`
Compute for each component of this vector the closest float that is equal to a mathematical integer, with ties rounding to positive infinity and store the result in `dest`.
`Vector4f`
```smoothStep(Vector4fc v, float t, Vector4f dest)```
Compute a smooth-step (i.e. hermite with zero tangents) interpolation between `this` vector and the given vector `v` and store the result in `dest`.
`Vector4f`
```sub(float x, float y, float z, float w, Vector4f dest)```
Subtract `(x, y, z, w)` from this and store the result in `dest`.
`Vector4f`
```sub(Vector4fc v, Vector4f dest)```
Subtract the supplied vector from this one and store the result in `dest`.
`float`
`w()`

`float`
`x()`

`float`
`y()`

`float`
`z()`

• ## Method Details

• ### x

float x()
Returns:
the value of the x component
• ### y

float y()
Returns:
the value of the y component
• ### z

float z()
Returns:
the value of the z component
• ### w

float w()
Returns:
the value of the w component
• ### get

FloatBuffer get(FloatBuffer buffer)
Store this vector into the supplied `FloatBuffer` at the current buffer `position`.

This method will not increment the position of the given FloatBuffer.

In order to specify the offset into the FloatBuffer at which the vector is stored, use `get(int, FloatBuffer)`, taking the absolute position as parameter.

Parameters:
`buffer` - will receive the values of this vector in `x, y, z, w` order
Returns:
the passed in buffer
• ### get

FloatBuffer get(int index, FloatBuffer buffer)
Store this vector into the supplied `FloatBuffer` starting at the specified absolute buffer position/index.

This method will not increment the position of the given FloatBuffer.

Parameters:
`index` - the absolute position into the FloatBuffer
`buffer` - will receive the values of this vector in `x, y, z, w` order
Returns:
the passed in buffer
• ### get

ByteBuffer get(ByteBuffer buffer)
Store this vector into the supplied `ByteBuffer` at the current buffer `position`.

This method will not increment the position of the given ByteBuffer.

In order to specify the offset into the ByteBuffer at which the vector is stored, use `get(int, ByteBuffer)`, taking the absolute position as parameter.

Parameters:
`buffer` - will receive the values of this vector in `x, y, z, w` order
Returns:
the passed in buffer
• ### get

ByteBuffer get(int index, ByteBuffer buffer)
Store this vector into the supplied `ByteBuffer` starting at the specified absolute buffer position/index.

This method will not increment the position of the given ByteBuffer.

Parameters:
`index` - the absolute position into the ByteBuffer
`buffer` - will receive the values of this vector in `x, y, z, w` order
Returns:
the passed in buffer

Store this vector at the given off-heap memory address.

This method will throw an `UnsupportedOperationException` when JOML is used with `-Djoml.nounsafe`.

This method is unsafe as it can result in a crash of the JVM process when the specified address range does not belong to this process.

Parameters:
`address` - the off-heap address where to store this vector
Returns:
this
• ### sub

Vector4f sub(Vector4fc v, Vector4f dest)
Subtract the supplied vector from this one and store the result in `dest`.
Parameters:
`v` - the vector to subtract from `this`
`dest` - will hold the result
Returns:
dest
• ### sub

Vector4f sub(float x, float y, float z, float w, Vector4f dest)
Subtract `(x, y, z, w)` from this and store the result in `dest`.
Parameters:
`x` - the x component to subtract
`y` - the y component to subtract
`z` - the z component to subtract
`w` - the w component to subtract
`dest` - will hold the result
Returns:
dest

Add the supplied vector to this one and store the result in `dest`.
Parameters:
`v` - the vector to add
`dest` - will hold the result
Returns:
dest

Vector4f add(float x, float y, float z, float w, Vector4f dest)
Increment the components of this vector by the given values and store the result in `dest`.
Parameters:
`x` - the x component to add
`y` - the y component to add
`z` - the z component to add
`w` - the w component to add
`dest` - will hold the result
Returns:
dest
• ### fma

Vector4f fma(Vector4fc a, Vector4fc b, Vector4f dest)
Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
Parameters:
`a` - the first multiplicand
`b` - the second multiplicand
`dest` - will hold the result
Returns:
dest
• ### fma

Vector4f fma(float a, Vector4fc b, Vector4f dest)
Add the component-wise multiplication of `a * b` to this vector and store the result in `dest`.
Parameters:
`a` - the first multiplicand
`b` - the second multiplicand
`dest` - will hold the result
Returns:
dest

Vector4f mulAdd(Vector4fc a, Vector4fc b, Vector4f dest)
Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
Parameters:
`a` - the multiplicand
`b` - the addend
`dest` - will hold the result
Returns:
dest

Vector4f mulAdd(float a, Vector4fc b, Vector4f dest)
Add the component-wise multiplication of `this * a` to `b` and store the result in `dest`.
Parameters:
`a` - the multiplicand
`b` - the addend
`dest` - will hold the result
Returns:
dest
• ### mul

Vector4f mul(Vector4fc v, Vector4f dest)
Multiply this Vector4f component-wise by another Vector4f and store the result in `dest`.
Parameters:
`v` - the other vector
`dest` - will hold the result
Returns:
dest
• ### div

Vector4f div(Vector4fc v, Vector4f dest)
Divide this Vector4f component-wise by another Vector4f and store the result in `dest`.
Parameters:
`v` - the vector to divide by
`dest` - will hold the result
Returns:
dest
• ### mul

Vector4f mul(Matrix4fc mat, Vector4f dest)
Multiply the given matrix mat with this Vector4f and store the result in `dest`.
Parameters:
`mat` - the matrix to multiply the vector with
`dest` - the destination vector to hold the result
Returns:
dest
• ### mulTranspose

Vector4f mulTranspose(Matrix4fc mat, Vector4f dest)
Multiply the transpose of the given matrix `mat` with this Vector4f and store the result in `dest`.
Parameters:
`mat` - the matrix whose transpose to multiply the vector with
`dest` - the destination vector to hold the result
Returns:
dest
• ### mulAffine

Vector4f mulAffine(Matrix4fc mat, Vector4f dest)
Multiply the given affine matrix mat with this Vector4f and store the result in `dest`.
Parameters:
`mat` - the affine matrix to multiply the vector with
`dest` - the destination vector to hold the result
Returns:
dest
• ### mulAffineTranspose

Vector4f mulAffineTranspose(Matrix4fc mat, Vector4f dest)
Multiply the transpose of the given affine matrix `mat` with this Vector4f and store the result in `dest`.
Parameters:
`mat` - the affine matrix whose transpose to multiply the vector with
`dest` - the destination vector to hold the result
Returns:
dest
• ### mul

Vector4f mul(Matrix4x3fc mat, Vector4f dest)
Multiply the given matrix mat with this Vector4f and store the result in `dest`.
Parameters:
`mat` - the matrix to multiply the vector with
`dest` - the destination vector to hold the result
Returns:
dest
• ### mulProject

Vector4f mulProject(Matrix4fc mat, Vector4f dest)
Multiply the given matrix `mat` with this Vector4f, perform perspective division and store the result in `dest`.
Parameters:
`mat` - the matrix to multiply this vector by
`dest` - will hold the result
Returns:
dest
• ### mulProject

Vector3f mulProject(Matrix4fc mat, Vector3f dest)
Multiply the given matrix `mat` with this Vector4f, perform perspective division and store the `(x, y, z)` result in `dest`.
Parameters:
`mat` - the matrix to multiply this vector by
`dest` - will hold the result
Returns:
dest
• ### mul

Vector4f mul(float scalar, Vector4f dest)
Multiply all components of this `Vector4f` by the given scalar value and store the result in `dest`.
Parameters:
`scalar` - the scalar to multiply by
`dest` - will hold the result
Returns:
dest
• ### mul

Vector4f mul(float x, float y, float z, float w, Vector4f dest)
Multiply the components of this Vector4f by the given scalar values and store the result in `dest`.
Parameters:
`x` - the x component to multiply by
`y` - the y component to multiply by
`z` - the z component to multiply by
`w` - the w component to multiply by
`dest` - will hold the result
Returns:
dest
• ### div

Vector4f div(float scalar, Vector4f dest)
Divide all components of this `Vector4f` by the given scalar value and store the result in `dest`.
Parameters:
`scalar` - the scalar to divide by
`dest` - will hold the result
Returns:
dest
• ### div

Vector4f div(float x, float y, float z, float w, Vector4f dest)
Divide the components of this Vector4f by the given scalar values and store the result in `dest`.
Parameters:
`x` - the x component to divide by
`y` - the y component to divide by
`z` - the z component to divide by
`w` - the w component to divide by
`dest` - will hold the result
Returns:
dest
• ### rotate

Vector4f rotate(Quaternionfc quat, Vector4f dest)
Rotate this vector by the given quaternion `quat` and store the result in `dest`.
Parameters:
`quat` - the quaternion to rotate this vector
`dest` - will hold the result
Returns:
dest
• ### rotateAxis

Vector4f rotateAxis(float angle, float aX, float aY, float aZ, Vector4f dest)
Rotate this vector the specified radians around the given rotation axis and store the result into `dest`.
Parameters:
`angle` - the angle in radians
`aX` - the x component of the rotation axis
`aY` - the y component of the rotation axis
`aZ` - the z component of the rotation axis
`dest` - will hold the result
Returns:
dest
• ### rotateX

Vector4f rotateX(float angle, Vector4f dest)
Rotate this vector the specified radians around the X axis and store the result into `dest`.
Parameters:
`angle` - the angle in radians
`dest` - will hold the result
Returns:
dest
• ### rotateY

Vector4f rotateY(float angle, Vector4f dest)
Rotate this vector the specified radians around the Y axis and store the result into `dest`.
Parameters:
`angle` - the angle in radians
`dest` - will hold the result
Returns:
dest
• ### rotateZ

Vector4f rotateZ(float angle, Vector4f dest)
Rotate this vector the specified radians around the Z axis and store the result into `dest`.
Parameters:
`angle` - the angle in radians
`dest` - will hold the result
Returns:
dest
• ### lengthSquared

float lengthSquared()
Return the length squared of this vector.
Returns:
the length squared
• ### length

float length()
Return the length of this vector.
Returns:
the length
• ### normalize

Vector4f normalize(Vector4f dest)
Normalizes this vector and store the result in `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest
• ### normalize

Vector4f normalize(float length, Vector4f dest)
Scale this vector to have the given length and store the result in `dest`.
Parameters:
`length` - the desired length
`dest` - will hold the result
Returns:
dest
• ### normalize3

Vector4f normalize3(Vector4f dest)
Normalize this vector by computing only the norm of `(x, y, z)` and store the result in `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest
• ### distance

float distance(Vector4fc v)
Return the distance between this Vector and `v`.
Parameters:
`v` - the other vector
Returns:
the distance
• ### distance

float distance(float x, float y, float z, float w)
Return the distance between `this` vector and `(x, y, z, w)`.
Parameters:
`x` - the x component of the other vector
`y` - the y component of the other vector
`z` - the z component of the other vector
`w` - the w component of the other vector
Returns:
the euclidean distance
• ### distanceSquared

float distanceSquared(Vector4fc v)
Return the square of the distance between this vector and `v`.
Parameters:
`v` - the other vector
Returns:
the squared of the distance
• ### distanceSquared

float distanceSquared(float x, float y, float z, float w)
Return the square of the distance between `this` vector and `(x, y, z, w)`.
Parameters:
`x` - the x component of the other vector
`y` - the y component of the other vector
`z` - the z component of the other vector
`w` - the w component of the other vector
Returns:
the square of the distance
• ### dot

float dot(Vector4fc v)
Compute the dot product (inner product) of this vector and `v` .
Parameters:
`v` - the other vector
Returns:
the dot product
• ### dot

float dot(float x, float y, float z, float w)
Compute the dot product (inner product) of this vector and `(x, y, z, w)`.
Parameters:
`x` - the x component of the other vector
`y` - the y component of the other vector
`z` - the z component of the other vector
`w` - the w component of the other vector
Returns:
the dot product
• ### angleCos

float angleCos(Vector4fc v)
Return the cosine of the angle between this vector and the supplied vector. Use this instead of `Math.cos(angle(v))`.
Parameters:
`v` - the other vector
Returns:
the cosine of the angle
• ### angle

float angle(Vector4fc v)
Return the angle between this vector and the supplied vector.
Parameters:
`v` - the other vector
Returns:
• ### negate

Vector4f negate(Vector4f dest)
Negate this vector and store the result in `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest
• ### min

Vector4f min(Vector4fc v, Vector4f dest)
Set the components of `dest` to be the component-wise minimum of this and the other vector.
Parameters:
`v` - the other vector
`dest` - will hold the result
Returns:
dest
• ### max

Vector4f max(Vector4fc v, Vector4f dest)
Set the components of `dest` to be the component-wise maximum of this and the other vector.
Parameters:
`v` - the other vector
`dest` - will hold the result
Returns:
dest
• ### lerp

Vector4f lerp(Vector4fc other, float t, Vector4f dest)
Linearly interpolate `this` and `other` using the given interpolation factor `t` and store the result in `dest`.

If `t` is `0.0` then the result is `this`. If the interpolation factor is `1.0` then the result is `other`.

Parameters:
`other` - the other vector
`t` - the interpolation factor between 0.0 and 1.0
`dest` - will hold the result
Returns:
dest
• ### smoothStep

Vector4f smoothStep(Vector4fc v, float t, Vector4f dest)
Compute a smooth-step (i.e. hermite with zero tangents) interpolation between `this` vector and the given vector `v` and store the result in `dest`.
Parameters:
`v` - the other vector
`t` - the interpolation factor, within `[0..1]`
`dest` - will hold the result
Returns:
dest
• ### hermite

Vector4f hermite(Vector4fc t0, Vector4fc v1, Vector4fc t1, float t, Vector4f dest)
Compute a hermite interpolation between `this` vector and its associated tangent `t0` and the given vector `v` with its tangent `t1` and store the result in `dest`.
Parameters:
`t0` - the tangent of `this` vector
`v1` - the other vector
`t1` - the tangent of the other vector
`t` - the interpolation factor, within `[0..1]`
`dest` - will hold the result
Returns:
dest
• ### get

float get(int component) throws IllegalArgumentException
Get the value of the specified component of this vector.
Parameters:
`component` - the component, within `[0..3]`
Returns:
the value
Throws:
`IllegalArgumentException` - if `component` is not within `[0..3]`
• ### get

Vector4i get(int mode, Vector4i dest)
Set the components of the given vector `dest` to those of `this` vector using the given `RoundingMode`.
Parameters:
`mode` - the `RoundingMode` to use
`dest` - will hold the result
Returns:
dest
• ### get

Vector4f get(Vector4f dest)
Set the components of the given vector `dest` to those of `this` vector.
Parameters:
`dest` - will hold the result
Returns:
dest
• ### get

Vector4d get(Vector4d dest)
Set the components of the given vector `dest` to those of `this` vector.
Parameters:
`dest` - will hold the result
Returns:
dest
• ### maxComponent

int maxComponent()
Determine the component with the biggest absolute value.
Returns:
the component index, within `[0..3]`
• ### minComponent

int minComponent()
Determine the component with the smallest (towards zero) absolute value.
Returns:
the component index, within `[0..3]`
• ### floor

Vector4f floor(Vector4f dest)
Compute for each component of this vector the largest (closest to positive infinity) `float` value that is less than or equal to that component and is equal to a mathematical integer and store the result in `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest
• ### ceil

Vector4f ceil(Vector4f dest)
Compute for each component of this vector the smallest (closest to negative infinity) `float` value that is greater than or equal to that component and is equal to a mathematical integer and store the result in `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest
• ### round

Vector4f round(Vector4f dest)
Compute for each component of this vector the closest float that is equal to a mathematical integer, with ties rounding to positive infinity and store the result in `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest
• ### isFinite

boolean isFinite()
Determine whether all components are finite floating-point values, that is, they are not `NaN` and not `infinity`.
Returns:
`true` if all components are finite floating-point values; `false` otherwise
• ### absolute

Vector4f absolute(Vector4f dest)
Compute the absolute of each of this vector's components and store the result into `dest`.
Parameters:
`dest` - will hold the result
Returns:
dest
• ### equals

boolean equals(Vector4fc v, float delta)
Compare the vector components of `this` vector with the given vector using the given `delta` and return whether all of them are equal within a maximum difference of `delta`.

Please note that this method is not used by any data structure such as `ArrayList` `HashSet` or `HashMap` and their operations, such as `ArrayList.contains(Object)` or `HashSet.remove(Object)`, since those data structures only use the `Object.equals(Object)` and `Object.hashCode()` methods.

Parameters:
`v` - the other vector
`delta` - the allowed maximum difference
Returns:
`true` whether all of the vector components are equal; `false` otherwise
• ### equals

boolean equals(float x, float y, float z, float w)
Compare the vector components of `this` vector with the given `(x, y, z, w)` and return whether all of them are equal.
Parameters:
`x` - the x component to compare to
`y` - the y component to compare to
`z` - the z component to compare to
`w` - the w component to compare to
Returns:
`true` if all the vector components are equal