com.io7m.jtensors

## Class VectorI4I

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

- All Implemented Interfaces:
    VectorReadable2IType, VectorReadable3IType, VectorReadable4IType

      public class VectorI4I
      extends Object
      implements VectorReadable4IType

  A four-dimensional immutable vector type with integer 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 VectorI4I` | `ZERO` The zero vector.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `VectorI4I()` Default constructor, initializing the vector with values `[0, 0, 0, 1]`.
    `VectorI4I(int in_x, int in_y, int in_z, int in_w)` Construct a vector initialized with the given values.
    `VectorI4I(VectorReadable4IType 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 VectorI4I` | `absolute(VectorReadable4IType v)` Calculate the absolute values of the elements in vector `v`.
    `static VectorI4I` | `add(VectorReadable4IType v0, VectorReadable4IType v1)` Calculate the element-wise sum of the vectors `v0` and `v1`.
    `static VectorI4I` | `addScaled(VectorReadable4IType v0, VectorReadable4IType v1, double r)` Calculate the element-wise sum of the vectors `v0` and the element-wise product of `v1` and `r`.
    `static VectorI4I` | `clamp(VectorReadable4IType v, int minimum, int maximum)` Clamp the elements of the vector `v` to the range `[minimum ..`
    `static VectorI4I` | `clampByVector(VectorReadable4IType v, VectorReadable4IType minimum, VectorReadable4IType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`.
    `static VectorI4I` | `clampMaximum(VectorReadable4IType v, int maximum)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
    `static VectorI4I` | `clampMaximumByVector(VectorReadable4IType v, VectorReadable4IType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`.
    `static VectorI4I` | `clampMinimum(VectorReadable4IType v, int minimum)` Clamp the elements of the vector `v` to the range `[minimum ..`
    `static VectorI4I` | `clampMinimumByVector(VectorReadable4IType v, VectorReadable4IType minimum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`.
    `static int` | `distance(VectorReadable4IType v0, VectorReadable4IType v1)` Calculate the distance between the two vectors `v0` and `v1`.
    `static int` | `dotProduct(VectorReadable4IType v0, VectorReadable4IType v1)` Calculate the scalar product of the vectors `v0` and `v1`.
    `boolean` | `equals(Object obj)`
    `int` | `getWI()`
    `int` | `getXI()`
    `int` | `getYI()`
    `int` | `getZI()`
    `int` | `hashCode()`
    `static VectorI4I` | `interpolateLinear(VectorReadable4IType v0, VectorReadable4IType v1, double alpha)` Linearly interpolate between `v0` and `v1` by the amount `alpha`.
    `static int` | `magnitude(VectorReadable4IType v)` Calculate the magnitude of the vector `v`.
    `static int` | `magnitudeSquared(VectorReadable4IType v)` Calculate the squared magnitude of the vector `v`.
    `static VectorI4I` | `projection(VectorReadable4IType p, VectorReadable4IType q)` Calculate the projection of the vector `p` onto the vector `q`.
    `static VectorI4I` | `scale(VectorReadable4IType v, double r)` Scale the vector `v` by the scalar `r`.
    `static VectorI4I` | `subtract(VectorReadable4IType v0, VectorReadable4IType 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 VectorI4I ZERO

      The zero vector.

  - ### Constructor Detail

    - #### VectorI4I

          public VectorI4I()

      Default constructor, initializing the vector with values `[0, 0, 0, 1]`.

    - #### VectorI4I

          public VectorI4I(int in_x,
                   int in_y,
                   int in_z,
                   int 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

    - #### VectorI4I

          public VectorI4I(VectorReadable4IType 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 VectorI4I absolute(VectorReadable4IType v)
                                          throws ArithmeticException

      Calculate the absolute values of the elements in vector `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
      Since:
        5.0.0

    - #### add

          public static final VectorI4I add(VectorReadable4IType v0,
                      VectorReadable4IType v1)
                                     throws ArithmeticException

      Calculate the element-wise sum of the vectors `v0` and `v1`.
      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 VectorI4I addScaled(VectorReadable4IType v0,
                            VectorReadable4IType v1,
                            double r)
                                           throws ArithmeticException

      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.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 VectorI4I clamp(VectorReadable4IType v,
                        int minimum,
                        int 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`
      Since:
        5.0.0

    - #### clampByVector

          public static final VectorI4I clampByVector(VectorReadable4IType v,
                                VectorReadable4IType minimum,
                                VectorReadable4IType 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.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))`
      Since:
        5.0.0

    - #### clampMaximum

          public static final VectorI4I clampMaximum(VectorReadable4IType v,
                               int 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`
      Since:
        5.0.0

    - #### clampMaximumByVector

          public static final VectorI4I clampMaximumByVector(VectorReadable4IType v,
                                       VectorReadable4IType 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.x, maximum.x), min(v.y, maximum.y), min(v.z, maximum.z), min(v.w, maximum.w))`
      Since:
        5.0.0

    - #### clampMinimum

          public static final VectorI4I clampMinimum(VectorReadable4IType v,
                               int 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`
      Since:
        5.0.0

    - #### clampMinimumByVector

          public static final VectorI4I clampMinimumByVector(VectorReadable4IType v,
                                       VectorReadable4IType 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.x, minimum.x), max(v.y, minimum.y), max(v.z, minimum.z), max(v.w, minimum.w))`
      Since:
        5.0.0

    - #### distance

          public static final int distance(VectorReadable4IType v0,
                     VectorReadable4IType 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
      Since:
        5.0.0

    - #### dotProduct

          public static final int dotProduct(VectorReadable4IType v0,
                       VectorReadable4IType 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
      Since:
        5.0.0

    - #### interpolateLinear

          public static final VectorI4I interpolateLinear(VectorReadable4IType v0,
                                    VectorReadable4IType v1,
                                    double alpha)
                                                   throws ArithmeticException

      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, 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`.
      Returns:
        `(1 - alpha) * v0 + alpha * v1`
      Throws:
        `ArithmeticException` - Iff an internal arithmetic operation causes an integer overflow.
      Since:
        5.0.0

    - #### magnitude

          public static final int magnitude(VectorReadable4IType 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
      Since:
        5.0.0

    - #### magnitudeSquared

          public static final int magnitudeSquared(VectorReadable4IType 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
      Since:
        5.0.0

    - #### projection

          public static final VectorI4I projection(VectorReadable4IType p,
                             VectorReadable4IType q)
                                            throws ArithmeticException

      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`
      Throws:
        `ArithmeticException` - Iff an internal arithmetic operation causes an integer overflow
      Since:
        5.0.0

    - #### scale

          public static final VectorI4I scale(VectorReadable4IType v,
                        double r)
                                       throws ArithmeticException

      Scale the vector `v` by the scalar `r`.
      Parameters:
        `v` - The input vector
        `r` - The scaling value
      Returns:
        `(v.x * r, v.y * r, v.z * r, vw * r)`
      Throws:
        `ArithmeticException` - Iff an internal arithmetic operation causes an integer overflow

    - #### subtract

          public static final VectorI4I subtract(VectorReadable4IType v0,
                           VectorReadable4IType v1)
                                          throws ArithmeticException

      Subtract the vector `v1` from the vector `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

    - #### equals

          public final boolean equals(@Nullable
                       Object obj)

      Overrides:
        `equals` in class `Object`

    - #### getWI

          public final int getWI()

      Specified by:
        `getWI` in interface `VectorReadable4IType`
      Returns:
        The W value of the given vector.

    - #### getXI

          public final int getXI()

      Specified by:
        `getXI` in interface `VectorReadable2IType`
      Returns:
        The X value of the given vector.

    - #### getYI

          public final int getYI()

      Specified by:
        `getYI` in interface `VectorReadable2IType`
      Returns:
        The Y value of the given vector.

    - #### getZI

          public final int getZI()

      Specified by:
        `getZI` in interface `VectorReadable3IType`
      Returns:
        The Z value of the given vector.

    - #### hashCode

          public final int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### toString

          public final String toString()

      Overrides:
        `toString` in class `Object`

Copyright © 2014 <code@io7m.com> http://io7m.com