Vec

public static final @NonNull ImmutableVec ORIGIN

The origin of the coordinate system, i.e. (0, 0).

public static final @AngleDegreesFloat @FloatRange(from = 0.0, to = 180.0) float absoluteAngleBetweenInDegrees(@NonNull Vec lhs, @NonNull Vec rhs)

Returns the absolute angle between the given vectors. The return value will lie in the interval 0, 180.0.

public static final void add(@NonNull Vec lhs, @NonNull Vec rhs, @NonNull MutableVec output)

Adds the x and y values of both Vec objects and stores the result in output.

public final @FloatRange(from = -180.0, to = 180.0) @AngleDegreesFloat float computeDirectionDegrees()

The angle between the positive x-axis and this vec, in the direction of the positive y-axis. If either component of the vector is NaN, this returns NaN. Otherwise, the returned value will lie in the interval -180, 180, and will have the same sign as the vector's y-component.

Following the behavior of atan2, this will return either ±0 or ±180 for the zero vector, depending on the signs of the zeros.

public final @FloatRange(from = 0.0) float computeMagnitude()

The length of the Vec.

public final @FloatRange(from = 0.0) float computeMagnitudeSquared()

The squared length of the Vec.

public final @NonNull ImmutableVec computeNegation()

Returns a newly allocated vector with the same magnitude, but pointing in the opposite direction. For performance-sensitive code, use computeNegation with a pre-allocated instance of MutableVec.

public final @NonNull MutableVec computeNegation(@NonNull MutableVec outVec)

Modifies outVec into a vector with the same magnitude, but pointing in the opposite direction. Returns outVec.

public final @NonNull ImmutableVec computeOrthogonal()

Returns a newly allocated vector with the same magnitude as this one, but rotated by (positive) 90 degrees. For performance-sensitive code, use computeOrthogonal with a pre-allocated instance of MutableVec.

public final @NonNull MutableVec computeOrthogonal(@NonNull MutableVec outVec)

Modifies outVec into a vector with the same magnitude as this one, but rotated by (positive) 90 degrees. Returns outVec.

public final @NonNull ImmutableVec computeUnitVec()

Returns a newly allocated vector with the same direction as this one, but with a magnitude of 1. This is equivalent to (but faster than) calling ImmutableVec.fromDirectionInDegreesAndMagnitude with computeDirectionDegrees and 1.

In keeping with the above equivalence, this will return <±1, ±0> for the zero vector, depending on the signs of the zeros.

For performance-sensitive code, use computeUnitVec with a pre-allocated instance of MutableVec.

public final @NonNull MutableVec computeUnitVec(@NonNull MutableVec outVec)

Modifies outVec into a vector with the same direction as this one, but with a magnitude of 1. Returns outVec. This is equivalent to (but faster than) calling MutableVec.fromDirectionInDegreesAndMagnitude with computeDirectionDegrees and 1.

In keeping with the above equivalence, this will return <±1, ±0> for the zero vector, depending on the signs of the zeros.

public static final float determinant(@NonNull Vec lhs, @NonNull Vec rhs)

Returns the determinant (×) of the two vectors. The determinant can be thought of as the z-component of the 3D cross product of the two vectors, if they were placed on the xy-plane in 3D space. The determinant has the property that, for vectors a and b: a × b = ‖a‖ * ‖b‖ * sin(θ) where ‖d‖ is the magnitude of the vector, and θ is the signed angle from a to b.

public static final void divide(@NonNull Vec lhs, float rhs, @NonNull MutableVec output)

Divides the x and y values of the Vec by the Float and stores the result in output.

public static final float dotProduct(@NonNull Vec lhs, @NonNull Vec rhs)

Returns the dot product (⋅) of the two vectors. The dot product has the property that, for vectors a and b: a ⋅ b = ‖a‖ * ‖b‖ * cos(θ) where ‖d‖ is the magnitude of the vector, and θ is the angle from a to b.

public abstract float getX()

The Vec's offset in the x-direction

public abstract float getY()

The Vec's offset in the y-direction

public final boolean isAlmostEqual(@NonNull Vec other, @FloatRange(from = 0.0) float tolerance)

Compares this Vec with other, and returns true if the difference between x and other.x is less than tolerance, and likewise for y.

public final boolean isParallelTo(
    @NonNull Vec other,
    @AngleDegreesFloat @FloatRange(from = 0.0) float toleranceDegrees
)

Returns true if the angle formed by this and other is within toleranceDegrees of 0 degrees or 180 degrees.

public final boolean isPerpendicularTo(
    @NonNull Vec other,
    @AngleDegreesFloat @FloatRange(from = 0.0) float toleranceDegrees
)

Returns true if the angle formed by this and other is within toleranceDegrees of ±90 degrees.

public static final void multiply(float lhs, @NonNull Vec rhs, @NonNull MutableVec output)

Multiplies the x and y values of the Vec by the Float and stores the result in output.

public static final void multiply(@NonNull Vec lhs, float rhs, @NonNull MutableVec output)

Multiplies the x and y values of the Vec by the Float and stores the result in output.

public static final @AngleDegreesFloat @FloatRange(from = -180.0, to = 180.0, fromInclusive = false) float signedAngleBetweenInDegrees(@NonNull Vec lhs, @NonNull Vec rhs)

Returns the signed angle between the given vectors. The return value will lie in the interval (-180.0, 180.0]. A positive result indicates the angle between the first vector and the second is in the direction from the positive x-axis towards the positive y-axis.

public static final void subtract(@NonNull Vec lhs, @NonNull Vec rhs, @NonNull MutableVec output)

Subtracts the x and y values of rhs from the x and y values of lhs and stores the result in output.

public final @NonNull PointF AndroidGraphicsConverter.populatePointF(
    @NonNull Vec receiver,
    @NonNull PointF out
)

Writes the values from this Vec to out.

Returns the modified PointF instance to allow chaining calls.

public final @NonNull PointF AndroidGraphicsConverter.toPointF(@NonNull Vec receiver)

Constructs a PointF with the same coordinates as the Vec