VectorM4L (io7m-jtensors-documentation 6.0.0 API)

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

All Implemented Interfaces:

VectorReadable2LType, VectorReadable3LType, VectorReadable4LType, VectorWritable2LType, VectorWritable3LType, VectorWritable4LType
```
public class VectorM4L
extends Object
implements VectorReadable4LType, VectorWritable4LType
```
A four-dimensional mutable vector type with integer elements.

Values of this type cannot be accessed safely from multiple threads without explicit synchronization.

Since:

5.3.0

Constructor Summary

Constructors
Constructor and Description
`VectorM4L()` Default constructor, initializing the vector with values `[0, 0, 0, 1]`.
`VectorM4L(long in_x, long in_y, long in_z, long in_w)` Construct a vector initialized with the given values.
`VectorM4L(VectorReadable4LType in_v)` Construct a vector initialized with the values given in the vector `in_v`.

Method Summary

Methods
Modifier and Type	Method and Description
`static VectorM4L`	`absolute(VectorReadable4LType v, VectorM4L out)` Calculate the absolute values of the elements in vector `v`, saving the result to `out`.
`static VectorM4L`	`absoluteInPlace(VectorM4L v)` Calculate the absolute values of the elements in vector `v`, saving the result to `v`.
`static VectorM4L`	`add(VectorReadable4LType v0, VectorReadable4LType v1, VectorM4L out)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `out`.
`static VectorM4L`	`addInPlace(VectorM4L v0, VectorReadable4LType v1)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `v0`.
`static VectorM4L`	`addScaled(VectorReadable4LType v0, VectorReadable4LType v1, double r, VectorM4L out)` Calculate the element-wise sum of the vectors `v0` and the element-wise product of `v1` and `r`, saving the result to `out`.
`static VectorM4L`	`addScaledInPlace(VectorM4L v0, VectorReadable4LType v1, double r)` Calculate the element-wise sum of the vectors `v0` and the element-wise product of `v1` and `r`, saving the result to `v0`.
`static VectorM4L`	`clamp(VectorReadable4LType v, long minimum, long maximum, VectorM4L out)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM4L`	`clampByVector(VectorReadable4LType v, VectorReadable4LType minimum, VectorReadable4LType maximum, VectorM4L out)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`, saving the result to `out`.
`static VectorM4L`	`clampByVectorInPlace(VectorM4L v, VectorReadable4LType minimum, VectorReadable4LType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`, saving the result to `v`.
`static VectorM4L`	`clampInPlace(VectorM4L v, long minimum, long maximum)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM4L`	`clampMaximum(VectorReadable4LType v, long maximum, VectorM4L out)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
`static VectorM4L`	`clampMaximumByVector(VectorReadable4LType v, VectorReadable4LType maximum, VectorM4L out)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`, saving the result to `out`.
`static VectorM4L`	`clampMaximumByVectorInPlace(VectorM4L v, VectorReadable4LType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`, saving the result to `v`.
`static VectorM4L`	`clampMaximumInPlace(VectorM4L v, long maximum)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
`static VectorM4L`	`clampMinimum(VectorReadable4LType v, long minimum, VectorM4L out)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM4L`	`clampMinimumByVector(VectorReadable4LType v, VectorReadable4LType minimum, VectorM4L out)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`, saving the result to `out`.
`static VectorM4L`	`clampMinimumByVectorInPlace(VectorM4L v, VectorReadable4LType minimum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`, saving the result to `v`.
`static VectorM4L`	`clampMinimumInPlace(VectorM4L v, long minimum)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static <T extends VectorWritable4LType> T`	`copy(VectorReadable4LType input, T output)` Copy all elements of the vector `input` to the vector `output`.
`void`	`copyFrom2L(VectorReadable2LType in_v)` Set the current vector to the contents of the input vector.
`void`	`copyFrom3L(VectorReadable3LType in_v)` Set the current vector to the contents of the input vector.
`void`	`copyFrom4L(VectorReadable4LType in_v)` Set the current vector to the contents of the input vector.
`static long`	`distance(VectorReadable4LType v0, VectorReadable4LType v1)` Calculate the distance between the two vectors `v0` and `v1`.
`static long`	`dotProduct(VectorReadable4LType v0, VectorReadable4LType v1)` Calculate the scalar product of the vectors `v0` and `v1`.
`boolean`	`equals(Object obj)`
`long`	`getWL()`
`long`	`getXL()`
`long`	`getYL()`
`long`	`getZL()`
`int`	`hashCode()`
`static VectorM4L`	`interpolateLinear(VectorReadable4LType v0, VectorReadable4LType v1, double alpha, VectorM4L r)` Linearly interpolate between `v0` and `v1` by the amount `alpha`, saving the result to `r`.
`static long`	`magnitude(VectorReadable4LType v)` Calculate the magnitude of the vector `v`.
`static long`	`magnitudeSquared(VectorReadable4LType v)` Calculate the squared magnitude of the vector `v`.
`static VectorM4L`	`projection(VectorReadable4LType p, VectorReadable4LType q, VectorM4L r)` Calculate the projection of the vector `p` onto the vector `q`, saving the result in `r`.
`static VectorM4L`	`scale(VectorReadable4LType v, double r, VectorM4L out)` Scale the vector `v` by the scalar `r`, saving the result to `out`.
`static VectorM4L`	`scaleInPlace(VectorM4L v, long r)` Scale the vector `v` by the scalar `r`, saving the result to `v`.
`void`	`set2L(long in_x, long in_y)` Set the current `x` and `y` values of the current vector.
`void`	`set3L(long in_x, long in_y, long in_z)` Set the current `x`, `y` and `z` values of the current vector.
`void`	`set4L(long in_x, long in_y, long in_z, long in_w)` Set the current `x`, `y`, `z` and `w` values of the current vector.
`void`	`setWL(long in_w)` Set the current `w` value of the current vector.
`void`	`setXL(long in_x)` Set the current `x` value of the current vector.
`void`	`setYL(long in_y)` Set the current `y` value of the current vector.
`void`	`setZL(long in_z)` Set the current `z` value of the current vector.
`static VectorM4L`	`subtract(VectorReadable4LType v0, VectorReadable4LType v1, VectorM4L out)` Subtract the vector `v1` from the vector `v0`, saving the result to `out`.
`static VectorM4L`	`subtractInPlace(VectorM4L v0, VectorReadable4LType v1)` Subtract the vector `v1` from the vector `v0`, saving the result to `v0`.
`String`	`toString()`

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

- Constructor Detail
  - VectorM4L
```
public VectorM4L()
```
    Default constructor, initializing the vector with values [0, 0, 0, 1].
  - VectorM4L
```
public VectorM4L(long in_x,
         long in_y,
         long in_z,
         long 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
  - VectorM4L
```
public VectorM4L(VectorReadable4LType 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 final VectorM4L absolute(VectorReadable4LType v,
                 VectorM4L out)
                                throws ArithmeticException
```
    Calculate the absolute values of the elements in vector v, saving the result to out.
    
    Parameters:
    v - The input vector
    out - The output vector
    
    Returns:
    (abs v.x, abs v.y, abs v.z, abs.w)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - absoluteInPlace
```
public static final VectorM4L absoluteInPlace(VectorM4L v)
                                       throws ArithmeticException
```
    Calculate the absolute values of the elements in vector v, saving the result to v.
    
    Parameters:
    v - The input vector
    
    Returns:
    (abs v.x, abs v.y, abs v.z, abs.w)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - add
```
public static final VectorM4L add(VectorReadable4LType v0,
            VectorReadable4LType v1,
            VectorM4L out)
                           throws ArithmeticException
```
    Calculate the element-wise sum of the vectors v0 and v1, saving the result to out.
    
    Parameters:
    v0 - The left input vector
    v1 - The right input vector
    out - The output vector
    
    Returns:
    (v0.x + v1.x, v0.y + v1.y, v0.z + v1.z, v0.w + v1.w)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - addInPlace
```
public static final VectorM4L addInPlace(VectorM4L v0,
                   VectorReadable4LType v1)
                                  throws ArithmeticException
```
    Calculate the element-wise sum of the vectors v0 and v1, saving the result to v0.
    
    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)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - addScaled
```
public static final VectorM4L addScaled(VectorReadable4LType v0,
                  VectorReadable4LType v1,
                  double r,
                  VectorM4L out)
                                 throws ArithmeticException
```
    Calculate the element-wise sum of the vectors v0 and the element-wise product of v1 and r, saving the result to out.
    
    Parameters:
    v0 - The left input vector
    v1 - The right input vector
    out - The output 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))
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - addScaledInPlace
```
public static final VectorM4L addScaledInPlace(VectorM4L v0,
                         VectorReadable4LType v1,
                         double r)
                                        throws ArithmeticException
```
    Calculate the element-wise sum of the vectors v0 and the element-wise product of v1 and r, saving the result to v0.
    
    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))
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - clamp
```
public static final VectorM4L clamp(VectorReadable4LType v,
              long minimum,
              long maximum,
              VectorM4L out)
```
    Clamp the elements of the vector v to the range [minimum .. maximum] inclusive, saving the result to out.
    
    Parameters:
    v - The input vector
    minimum - The minimum allowed value
    maximum - The maximum allowed value
    out - The output vector
    
    Returns:
    A vector with both elements equal to at most maximum and at least minimum
  - clampByVector
```
public static final VectorM4L clampByVector(VectorReadable4LType v,
                      VectorReadable4LType minimum,
                      VectorReadable4LType maximum,
                      VectorM4L out)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum and maximum, saving the result to out.
    
    Parameters:
    v - The input vector
    minimum - The vector containing the minimum acceptable values
    maximum - The vector containing the maximum acceptable values
    out - The output vector
    
    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))
  - clampByVectorInPlace
```
public static final VectorM4L clampByVectorInPlace(VectorM4L v,
                             VectorReadable4LType minimum,
                             VectorReadable4LType maximum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum and maximum, saving the result to v.
    
    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))
  - clampInPlace
```
public static final VectorM4L clampInPlace(VectorM4L v,
                     long minimum,
                     long maximum)
```
    Clamp the elements of the vector v to the range [minimum .. maximum] inclusive, saving the result to v.
    
    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, in v
  - clampMaximum
```
public static final VectorM4L clampMaximum(VectorReadable4LType v,
                     long maximum,
                     VectorM4L out)
```
    Clamp the elements of the vector v to the range [-Infinity .. maximum] inclusive, saving the result to out.
    
    Parameters:
    v - The input vector
    out - The output vector
    maximum - The maximum allowed value
    
    Returns:
    A vector with both elements equal to at most maximum
  - clampMaximumByVector
```
public static final VectorM4L clampMaximumByVector(VectorReadable4LType v,
                             VectorReadable4LType maximum,
                             VectorM4L out)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in maximum, saving the result to out.
    
    Parameters:
    v - The input vector
    maximum - The vector containing the maximum acceptable values
    out - The output vector
    
    Returns:
    (min(v.x, maximum.x), min(v.y, maximum.y), min(v.z, maximum.z), min(v.w, maximum.w))
  - clampMaximumByVectorInPlace
```
public static final VectorM4L clampMaximumByVectorInPlace(VectorM4L v,
                                    VectorReadable4LType maximum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in maximum, saving the result to v.
    
    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))
  - clampMaximumInPlace
```
public static final VectorM4L clampMaximumInPlace(VectorM4L v,
                            long maximum)
```
    Clamp the elements of the vector v to the range [-Infinity .. maximum] inclusive, saving the result to v.
    
    Parameters:
    v - The input vector
    maximum - The maximum allowed value
    
    Returns:
    A vector with both elements equal to at most maximum , in v
  - clampMinimum
```
public static final VectorM4L clampMinimum(VectorReadable4LType v,
                     long minimum,
                     VectorM4L out)
```
    Clamp the elements of the vector v to the range [minimum .. Infinity] inclusive, saving the result to out.
    
    Parameters:
    v - The input vector
    out - The output vector
    minimum - The minimum allowed value
    
    Returns:
    A vector with both elements equal to at least minimum
  - clampMinimumByVector
```
public static final VectorM4L clampMinimumByVector(VectorReadable4LType v,
                             VectorReadable4LType minimum,
                             VectorM4L out)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum, saving the result to out.
    
    Parameters:
    v - The input vector
    out - The output 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))
  - clampMinimumByVectorInPlace
```
public static final VectorM4L clampMinimumByVectorInPlace(VectorM4L v,
                                    VectorReadable4LType minimum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum, saving the result to v.
    
    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)) , in v
  - clampMinimumInPlace
```
public static final VectorM4L clampMinimumInPlace(VectorM4L v,
                            long minimum)
```
    Clamp the elements of the vector v to the range [minimum .. Infinity] inclusive, saving the result to v.
    
    Parameters:
    v - The input vector
    minimum - The minimum allowed value
    
    Returns:
    A vector with both elements equal to at least minimum, in v.
  - copy
```
public static final <T extends VectorWritable4LType> T copy(VectorReadable4LType input,
                                      T output)
```
    Copy all elements of the vector input to the vector output.
    
    Type Parameters:
    T - The specific vector type
    Parameters:
    input - The input vector
    output - The output vector
    
    Returns:
    output
  - distance
```
public static final long distance(VectorReadable4LType v0,
            VectorReadable4LType v1)
                           throws ArithmeticException
```
    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.
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - dotProduct
```
public static final long dotProduct(VectorReadable4LType v0,
              VectorReadable4LType v1)
                             throws ArithmeticException
```
    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
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - interpolateLinear
```
public static final VectorM4L interpolateLinear(VectorReadable4LType v0,
                          VectorReadable4LType v1,
                          double alpha,
                          VectorM4L r)
                                         throws ArithmeticException
```
    Linearly interpolate between v0 and v1 by the amount alpha, saving the result to r. The alpha parameter controls the degree of interpolation, such that:
    - interpolateLinear(v0, v1, 0.0, r) -> r = v0
    - interpolateLinear(v0, v1, 1.0, r) -> r = v1
    Parameters:
    v0 - The left input vector.
    v1 - The right input vector.
    alpha - The interpolation value, between 0.0 and 1.0.
    r - The result vector.
    
    Returns:
    r
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - magnitude
```
public static final long magnitude(VectorReadable4LType v)
                            throws ArithmeticException
```
    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
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - magnitudeSquared
```
public static final long magnitudeSquared(VectorReadable4LType v)
                                   throws ArithmeticException
```
    Calculate the squared magnitude of the vector v.
    
    Parameters:
    v - The input vector
    
    Returns:
    The squared magnitude of the input vector
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - projection
```
public static final VectorM4L projection(VectorReadable4LType p,
                   VectorReadable4LType q,
                   VectorM4L r)
                                  throws ArithmeticException
```
    Calculate the projection of the vector p onto the vector q, saving the result in r.
    
    Parameters:
    p - The left vector
    q - The right vector
    r - The output vector
    
    Returns:
    ((dotProduct p q) / magnitudeSquared q) * q
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - scale
```
public static final VectorM4L scale(VectorReadable4LType v,
              double r,
              VectorM4L out)
                             throws ArithmeticException
```
    Scale the vector v by the scalar r, saving the result to out.
    
    Parameters:
    v - The input vector
    r - The scaling value
    out - The output vector
    
    Returns:
    (v.x * r, v.y * r, v.z * r, v.w * r)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - scaleInPlace
```
public static final VectorM4L scaleInPlace(VectorM4L v,
                     long r)
                                    throws ArithmeticException
```
    Scale the vector v by the scalar r, saving the result to v.
    
    Parameters:
    v - The input vector
    r - The scaling value
    
    Returns:
    (v.x * r, v.y * r, v.z * r, v.w * r)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - subtract
```
public static final VectorM4L subtract(VectorReadable4LType v0,
                 VectorReadable4LType v1,
                 VectorM4L out)
                                throws ArithmeticException
```
    Subtract the vector v1 from the vector v0, saving the result to out.
    
    Parameters:
    v0 - The left input vector
    v1 - The right input vector
    out - The output vector
    
    Returns:
    (v0.x - v1.x, v0.y - v1.y, v0.z - v1.z, v0.w - v1.w)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - subtractInPlace
```
public static final VectorM4L subtractInPlace(VectorM4L v0,
                        VectorReadable4LType v1)
                                       throws ArithmeticException
```
    Subtract the vector v1 from the vector v0, saving the result to v0.
    
    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)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - copyFrom2L
```
public final void copyFrom2L(VectorReadable2LType in_v)
```
    Description copied from interface: VectorWritable2LType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom2L in interface VectorWritable2LType
    
    Parameters:
    in_v - The input vector
  - copyFrom3L
```
public final void copyFrom3L(VectorReadable3LType in_v)
```
    Description copied from interface: VectorWritable3LType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom3L in interface VectorWritable3LType
    
    Parameters:
    in_v - The input vector
  - copyFrom4L
```
public final void copyFrom4L(VectorReadable4LType in_v)
```
    Description copied from interface: VectorWritable4LType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom4L in interface VectorWritable4LType
    
    Parameters:
    in_v - The input vector
  - equals
```
public final boolean equals(@Nullable
             Object obj)
```
    Overrides:
    
    equals in class Object
  - getWL
```
public final long getWL()
```
    Specified by:
    
    getWL in interface VectorReadable4LType
    
    Returns:
    The W value of the given vector.
  - getXL
```
public final long getXL()
```
    Specified by:
    
    getXL in interface VectorReadable2LType
    
    Returns:
    The X value of the given vector.
  - getYL
```
public final long getYL()
```
    Specified by:
    
    getYL in interface VectorReadable2LType
    
    Returns:
    The Y value of the given vector.
  - getZL
```
public final long getZL()
```
    Specified by:
    
    getZL in interface VectorReadable3LType
    
    Returns:
    The Z value of the given vector.
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - set2L
```
public final void set2L(long in_x,
         long in_y)
```
    Description copied from interface: VectorWritable2LType
    
    Set the current x and y values of the current vector.
    
    Specified by:
    
    set2L in interface VectorWritable2LType
    
    Parameters:
    in_x - The new x value.
    in_y - The new y value.
  - set3L
```
public final void set3L(long in_x,
         long in_y,
         long in_z)
```
    Description copied from interface: VectorWritable3LType
    
    Set the current x, y and z values of the current vector.
    
    Specified by:
    
    set3L in interface VectorWritable3LType
    
    Parameters:
    in_x - The new x value.
    in_y - The new y value.
    in_z - The new z value.
  - set4L
```
public final void set4L(long in_x,
         long in_y,
         long in_z,
         long in_w)
```
    Description copied from interface: VectorWritable4LType
    
    Set the current x, y, z and w values of the current vector.
    
    Specified by:
    
    set4L in interface VectorWritable4LType
    
    Parameters:
    in_x - The new x value.
    in_y - The new y value.
    in_z - The new z value.
    in_w - The new w value.
  - setWL
```
public final void setWL(long in_w)
```
    Description copied from interface: VectorWritable4LType
    
    Set the current w value of the current vector.
    
    Specified by:
    
    setWL in interface VectorWritable4LType
    
    Parameters:
    in_w - The new w value.
  - setXL
```
public final void setXL(long in_x)
```
    Description copied from interface: VectorWritable2LType
    
    Set the current x value of the current vector.
    
    Specified by:
    
    setXL in interface VectorWritable2LType
    
    Parameters:
    in_x - The new x value.
  - setYL
```
public final void setYL(long in_y)
```
    Description copied from interface: VectorWritable2LType
    
    Set the current y value of the current vector.
    
    Specified by:
    
    setYL in interface VectorWritable2LType
    
    Parameters:
    in_y - The new y value.
  - setZL
```
public final void setZL(long in_z)
```
    Description copied from interface: VectorWritable3LType
    
    Set the current z value of the current vector.
    
    Specified by:
    
    setZL in interface VectorWritable3LType
    
    Parameters:
    in_z - The new z value.
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object

Class VectorM4L

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

VectorM4L

VectorM4L

VectorM4L

Method Detail

absolute

absoluteInPlace

add

addInPlace

addScaled

addScaledInPlace

clamp

clampByVector

clampByVectorInPlace

clampInPlace

clampMaximum

clampMaximumByVector

clampMaximumByVectorInPlace

clampMaximumInPlace

clampMinimum

clampMinimumByVector

clampMinimumByVectorInPlace

clampMinimumInPlace

copy

distance

dotProduct

interpolateLinear

magnitude

magnitudeSquared

projection

scale

scaleInPlace

subtract

subtractInPlace

copyFrom2L

copyFrom3L

copyFrom4L

equals

getWL

getXL

getYL

getZL

hashCode

set2L

set3L

set4L

setWL

setXL

setYL

setZL

toString