VectorM3D (io7m-jtensors-documentation 6.0.2 API)

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

All Implemented Interfaces:

VectorReadable2DType, VectorReadable3DType, VectorWritable2DType, VectorWritable3DType
```
public class VectorM3D
extends Object
implements VectorReadable3DType, VectorWritable3DType
```
A three-dimensional mutable vector type with double precision elements.

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

Constructor Summary

Constructors
Constructor and Description
`VectorM3D()` Default constructor, initializing the vector with values `[0.0, 0.0, 0.0]`.
`VectorM3D(double in_x, double in_y, double in_z)` Construct a vector initialized with the given values.
`VectorM3D(VectorReadable3DType in_v)` Construct a vector initialized with the values given in the vector `v`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static VectorM3D`	`absolute(VectorReadable3DType v, VectorM3D out)` Calculate the absolute values of the elements in vector `v`, saving the result to `out`.
`static VectorM3D`	`absoluteInPlace(VectorM3D v)` Calculate the absolute values of the elements in vector `v`, modifying the vector in-place.
`static VectorM3D`	`add(VectorReadable3DType v0, VectorReadable3DType v1, VectorM3D out)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `out`.
`static VectorM3D`	`addInPlace(VectorM3D v0, VectorReadable3DType v1)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `v0`.
`static VectorM3D`	`addScaled(VectorReadable3DType v0, VectorReadable3DType v1, double r, VectorM3D 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 VectorM3D`	`addScaledInPlace(VectorM3D v0, VectorReadable3DType 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 boolean`	`almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context, VectorReadable3DType qa, VectorReadable3DType qb)` Determine whether or not the vectors `qa` and `qb` are equal to within the degree of error given in `context`.
`static VectorM3D`	`clamp(VectorReadable3DType v, double minimum, double maximum, VectorM3D out)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM3D`	`clampByVector(VectorReadable3DType v, VectorReadable3DType minimum, VectorReadable3DType maximum, VectorM3D 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 VectorM3D`	`clampByVectorInPlace(VectorM3D v, VectorReadable3DType minimum, VectorReadable3DType 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 VectorM3D`	`clampInPlace(VectorM3D v, double minimum, double maximum)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM3D`	`clampMaximum(VectorReadable3DType v, double maximum, VectorM3D out)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
`static VectorM3D`	`clampMaximumByVector(VectorReadable3DType v, VectorReadable3DType maximum, VectorM3D 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 VectorM3D`	`clampMaximumByVectorInPlace(VectorM3D v, VectorReadable3DType 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 VectorM3D`	`clampMaximumInPlace(VectorM3D v, double maximum)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
`static VectorM3D`	`clampMinimum(VectorReadable3DType v, double minimum, VectorM3D out)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM3D`	`clampMinimumByVector(VectorReadable3DType v, VectorReadable3DType minimum, VectorM3D 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 VectorM3D`	`clampMinimumByVectorInPlace(VectorM3D v, VectorReadable3DType 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 VectorM3D`	`clampMinimumInPlace(VectorM3D v, double minimum)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorWritable3DType`	`copy(VectorReadable3DType input, VectorWritable3DType output)` Copy all elements of the vector `input` to the vector `output`.
`void`	`copyFrom2D(VectorReadable2DType in_v)` Set the current vector to the contents of the input vector.
`void`	`copyFrom3D(VectorReadable3DType in_v)` Set the current vector to the contents of the input vector.
`static VectorM3D`	`crossProduct(VectorReadable3DType v0, VectorReadable3DType v1, VectorM3D out)` Return a vector perpendicular to both `v0` and `v1` , saving the result in `out`.
`static double`	`distance(VectorReadable3DType v0, VectorReadable3DType v1)` Calculate the distance between the two vectors `v0` and `v1`.
`static double`	`dotProduct(VectorReadable3DType v0, VectorReadable3DType v1)` Calculate the scalar product of the vectors `v0` and `v1`.
`boolean`	`equals(Object obj)`
`double`	`getXD()`
`double`	`getYD()`
`double`	`getZD()`
`int`	`hashCode()`
`static VectorM3D`	`interpolateLinear(VectorReadable3DType v0, VectorReadable3DType v1, double alpha, VectorM3D r)` Linearly interpolate between `v0` and `v1` by the amount `alpha`, saving the result to `r`.
`static double`	`magnitude(VectorReadable3DType v)` Calculate the magnitude of the vector `v`.
`static double`	`magnitudeSquared(VectorReadable3DType v)` Calculate the squared magnitude of the vector `v`.
`static VectorM3D`	`normalize(VectorReadable3DType v, VectorM3D out)` Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `out`.
`static VectorM3D`	`normalizeInPlace(VectorM3D v)` Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `v`.
`static com.io7m.jfunctional.Pair<VectorM3D,VectorM3D>`	`orthoNormalize(VectorReadable3DType v0, VectorReadable3DType v1)` Orthonormalize and return the vectors `v0` and `v1` .
`static void`	`orthoNormalizeInPlace(VectorM3D v0, VectorM3D v1)` Orthonormalize and the vectors `v0` and `v1`.
`static VectorM3D`	`projection(VectorReadable3DType p, VectorReadable3DType q, VectorM3D r)` Calculate the projection of the vector `p` onto the vector `q`, saving the result in `r`.
`static VectorM3D`	`scale(VectorReadable3DType v, double r, VectorM3D out)` Scale the vector `v` by the scalar `r`, saving the result to `out`.
`static VectorM3D`	`scaleInPlace(VectorM3D v, double r)` Scale the vector `v` by the scalar `r`, saving the result to `v`.
`void`	`set2D(double in_x, double in_y)` Set the current `x` and `y` values of the current vector.
`void`	`set3D(double in_x, double in_y, double in_z)` Set the current `x`, `y` and `z` values of the current vector.
`void`	`setXD(double in_x)` Set the current `x` value of the current vector.
`void`	`setYD(double in_y)` Set the current `y` value of the current vector.
`void`	`setZD(double in_z)` Set the current `z` value of the current vector.
`static VectorM3D`	`subtract(VectorReadable3DType v0, VectorReadable3DType v1, VectorM3D out)` Subtract the vector `v1` from the vector `v0`, saving the result to `out`.
`static VectorM3D`	`subtractInPlace(VectorM3D v0, VectorReadable3DType 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
  - VectorM3D
```
public VectorM3D()
```
    Default constructor, initializing the vector with values [0.0, 0.0, 0.0].
  - VectorM3D
```
public VectorM3D(double in_x,
                 double in_y,
                 double in_z)
```
    Construct a vector initialized with the given values.
    
    Parameters:
    
    in_x - The x value
    
    in_y - The y value
    
    in_z - The z value
  - VectorM3D
```
public VectorM3D(VectorReadable3DType in_v)
```
    Construct a vector initialized with the values given in the vector v.
    
    Parameters:
    
    in_v - The source vector
- Method Detail
  - absolute
```
public static final VectorM3D absolute(VectorReadable3DType v,
                                       VectorM3D out)
```
    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)
  - absoluteInPlace
```
public static final VectorM3D absoluteInPlace(VectorM3D v)
```
    Calculate the absolute values of the elements in vector v, modifying the vector in-place.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    (abs v.x, abs v.y, abs v.z)
  - add
```
public static final VectorM3D add(VectorReadable3DType v0,
                                  VectorReadable3DType v1,
                                  VectorM3D out)
```
    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)
  - addInPlace
```
public static final VectorM3D addInPlace(VectorM3D v0,
                                         VectorReadable3DType v1)
```
    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)
  - addScaled
```
public static final VectorM3D addScaled(VectorReadable3DType v0,
                                        VectorReadable3DType v1,
                                        double r,
                                        VectorM3D out)
```
    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))
  - addScaledInPlace
```
public static final VectorM3D addScaledInPlace(VectorM3D v0,
                                               VectorReadable3DType 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.
    
    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))
  - almostEqual
```
public static final boolean almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context,
                                        VectorReadable3DType qa,
                                        VectorReadable3DType qb)
```
    Determine whether or not the vectors qa and qb are equal to within the degree of error given in context.
    
    Parameters:
    
    context - The equality context
    
    qa - The left input vector
    
    qb - The right input vector
    
    Returns:
    
    true if the vectors are almost equal
    
    Since:
    
    5.0.0
    
    See Also:
    
    AlmostEqualDouble.almostEqual(ContextRelative, double, double)
  - clamp
```
public static final VectorM3D clamp(VectorReadable3DType v,
                                    double minimum,
                                    double maximum,
                                    VectorM3D 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 VectorM3D clampByVector(VectorReadable3DType v,
                                            VectorReadable3DType minimum,
                                            VectorReadable3DType maximum,
                                            VectorM3D 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))
  - clampByVectorInPlace
```
public static final VectorM3D clampByVectorInPlace(VectorM3D v,
                                                   VectorReadable3DType minimum,
                                                   VectorReadable3DType 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))
  - clampInPlace
```
public static final VectorM3D clampInPlace(VectorM3D v,
                                           double minimum,
                                           double 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 VectorM3D clampMaximum(VectorReadable3DType v,
                                           double maximum,
                                           VectorM3D 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 VectorM3D clampMaximumByVector(VectorReadable3DType v,
                                                   VectorReadable3DType maximum,
                                                   VectorM3D 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))
  - clampMaximumByVectorInPlace
```
public static final VectorM3D clampMaximumByVectorInPlace(VectorM3D v,
                                                          VectorReadable3DType 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))
  - clampMaximumInPlace
```
public static final VectorM3D clampMaximumInPlace(VectorM3D v,
                                                  double 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 VectorM3D clampMinimum(VectorReadable3DType v,
                                           double minimum,
                                           VectorM3D 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 VectorM3D clampMinimumByVector(VectorReadable3DType v,
                                                   VectorReadable3DType minimum,
                                                   VectorM3D 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))
  - clampMinimumByVectorInPlace
```
public static final VectorM3D clampMinimumByVectorInPlace(VectorM3D v,
                                                          VectorReadable3DType 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)) , in v
  - clampMinimumInPlace
```
public static final VectorM3D clampMinimumInPlace(VectorM3D v,
                                                  double 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 VectorWritable3DType copy(VectorReadable3DType input,
                                              VectorWritable3DType output)
```
    Copy all elements of the vector input to the vector output.
    
    Parameters:
    
    input - The input vector
    
    output - The output vector
    
    Returns:
    
    output
  - crossProduct
```
public static final VectorM3D crossProduct(VectorReadable3DType v0,
                                           VectorReadable3DType v1,
                                           VectorM3D out)
```
    Return a vector perpendicular to both v0 and v1 , saving the result in out.
    
    Parameters:
    
    v0 - The left input vector.
    
    v1 - The right input vector.
    
    out - The output vector.
    
    Returns:
    
    out
  - distance
```
public static final double distance(VectorReadable3DType v0,
                                    VectorReadable3DType 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 final double dotProduct(VectorReadable3DType v0,
                                      VectorReadable3DType 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 final VectorM3D interpolateLinear(VectorReadable3DType v0,
                                                VectorReadable3DType v1,
                                                double alpha,
                                                VectorM3D r)
```
    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
  - magnitude
```
public static final double magnitude(VectorReadable3DType 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 final double magnitudeSquared(VectorReadable3DType 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 final VectorM3D normalize(VectorReadable3DType v,
                                        VectorM3D out)
```
    Returns a vector with the same orientation as v but with magnitude equal to 1.0 in out. The function returns the zero vector iff the input is the zero vector.
    
    Parameters:
    
    v - The input vector
    
    out - The output vector
    
    Returns:
    
    out
  - normalizeInPlace
```
public static final VectorM3D normalizeInPlace(VectorM3D v)
```
    Returns a vector with the same orientation as v but with magnitude equal to 1.0 in v. The function returns the zero vector iff the input is the zero vector.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    v
  - orthoNormalize
```
public static final com.io7m.jfunctional.Pair<VectorM3D,VectorM3D> orthoNormalize(VectorReadable3DType v0,
                                                                                  VectorReadable3DType 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
  - orthoNormalizeInPlace
```
public static final void orthoNormalizeInPlace(VectorM3D v0,
                                               VectorM3D v1)
```
    Orthonormalize and the vectors v0 and v1.
    
    See GSP
    
    Parameters:
    
    v0 - The left vector
    
    v1 - The right vector
    
    Since:
    
    5.0.0
  - projection
```
public static final VectorM3D projection(VectorReadable3DType p,
                                         VectorReadable3DType q,
                                         VectorM3D r)
```
    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
  - scale
```
public static final VectorM3D scale(VectorReadable3DType v,
                                    double r,
                                    VectorM3D out)
```
    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)
  - scaleInPlace
```
public static final VectorM3D scaleInPlace(VectorM3D v,
                                           double r)
```
    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)
  - subtract
```
public static final VectorM3D subtract(VectorReadable3DType v0,
                                       VectorReadable3DType v1,
                                       VectorM3D out)
```
    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)
  - subtractInPlace
```
public static final VectorM3D subtractInPlace(VectorM3D v0,
                                              VectorReadable3DType v1)
```
    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)
  - copyFrom2D
```
public final void copyFrom2D(VectorReadable2DType in_v)
```
    Description copied from interface: VectorWritable2DType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom2D in interface VectorWritable2DType
    
    Parameters:
    
    in_v - The input vector
  - copyFrom3D
```
public final void copyFrom3D(VectorReadable3DType in_v)
```
    Description copied from interface: VectorWritable3DType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom3D in interface VectorWritable3DType
    
    Parameters:
    
    in_v - The input vector
  - equals
```
public final boolean equals(@Nullable
                            Object obj)
```
    Overrides:
    
    equals in class Object
  - getXD
```
public final double getXD()
```
    Specified by:
    
    getXD in interface VectorReadable2DType
    
    Returns:
    
    The X value of the given vector.
  - getYD
```
public final double getYD()
```
    Specified by:
    
    getYD in interface VectorReadable2DType
    
    Returns:
    
    The Y value of the given vector.
  - getZD
```
public final double getZD()
```
    Specified by:
    
    getZD in interface VectorReadable3DType
    
    Returns:
    
    The Z value of the given vector.
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - set2D
```
public final void set2D(double in_x,
                        double in_y)
```
    Description copied from interface: VectorWritable2DType
    
    Set the current x and y values of the current vector.
    
    Specified by:
    
    set2D in interface VectorWritable2DType
    
    Parameters:
    
    in_x - The new x value.
    
    in_y - The new y value.
  - set3D
```
public final void set3D(double in_x,
                        double in_y,
                        double in_z)
```
    Description copied from interface: VectorWritable3DType
    
    Set the current x, y and z values of the current vector.
    
    Specified by:
    
    set3D in interface VectorWritable3DType
    
    Parameters:
    
    in_x - The new x value.
    
    in_y - The new y value.
    
    in_z - The new z value.
  - setXD
```
public final void setXD(double in_x)
```
    Description copied from interface: VectorWritable2DType
    
    Set the current x value of the current vector.
    
    Specified by:
    
    setXD in interface VectorWritable2DType
    
    Parameters:
    
    in_x - The new x value.
  - setYD
```
public final void setYD(double in_y)
```
    Description copied from interface: VectorWritable2DType
    
    Set the current y value of the current vector.
    
    Specified by:
    
    setYD in interface VectorWritable2DType
    
    Parameters:
    
    in_y - The new y value.
  - setZD
```
public final void setZD(double in_z)
```
    Description copied from interface: VectorWritable3DType
    
    Set the current z value of the current vector.
    
    Specified by:
    
    setZD in interface VectorWritable3DType
    
    Parameters:
    
    in_z - The new z value.
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object

Class VectorM3D

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

VectorM3D

VectorM3D

VectorM3D

Method Detail

absolute

absoluteInPlace

add

addInPlace

addScaled

addScaledInPlace

almostEqual

clamp

clampByVector

clampByVectorInPlace

clampInPlace

clampMaximum

clampMaximumByVector

clampMaximumByVectorInPlace

clampMaximumInPlace

clampMinimum

clampMinimumByVector

clampMinimumByVectorInPlace

clampMinimumInPlace

copy

crossProduct

distance

dotProduct

interpolateLinear

magnitude

magnitudeSquared

normalize

normalizeInPlace

orthoNormalize

orthoNormalizeInPlace

projection

scale

scaleInPlace

subtract

subtractInPlace

copyFrom2D

copyFrom3D

equals

getXD

getYD

getZD

hashCode

set2D

set3D

setXD

setYD

setZD

toString