VonaMath

java.lang.Object
- vona.math.VonaMath

```
public class VonaMath
extends java.lang.Object
```
Vona's utils: math misc.

Copyright (C) 2004 Marsette A. Vona, III

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Author:

Marsette (Marty) A. Vona, III

Field Summary

Fields
Modifier and Type	Field and Description
`private static java.lang.String`	`cvsid` CVS id.
`static double`	`DP` similar to `FP`
`static double`	`DP2R` square root of `DP`
`static double`	`DP3R` cube root of `DP`
`static double`	`DP4R` 4th root of `DP`
`static double`	`EPSILON` A default epsilon.
`static double`	`EPSILON2` Default epsilon squared.
`static float`	`FP` 32-bit IEEE floating point precision, defined as the largest value for which `(1.0f+FP)-1.0f == 0.0f`.
`static float`	`FP2R` square root of `FP`
`static float`	`FP3R` cube root of `FP`
`static float`	`FP4R` 4th root of `FP`
`static float`	`FTWO_PI` `TWO_PI` as a float
`static double`	`SQRT_2` `sqrt(2.0).`
`static double`	`TWO_PI` 2*pi

Constructor Summary

Constructors
Constructor and Description

VonaMath()

Constructors
Constructor and Description
`VonaMath()`

Method Summary

Methods
Modifier and Type	Method and Description
`static double[]`	`add2(double[] v1, double[] v2)` Compute the sum of two two-dimensional vectors.
`static int`	`addMod(int a0, int a1, int m)` Compute `(a0 + a1) mod m`.
`static double`	`angle(double[] v)` Return the CCW angle from the positive X axis to the 2D vector `v`.
`static double`	`angle(double x, double y)` Return the CCW angle from the positive X axis to the vector `(x, y)`, in the range [0, 2*PI).
`static double`	`canonicalizeAngle(double t)` Return the canonical angle in the range (-PI, PI] corresponding to any angle `t`.
`static double`	`canonicalizeAngle180(double t)` Same as `canonicalizeAngle(double)` but operates on degrees.
`static double`	`canonicalizeAngle360(double t)` Same as `canonicalizeAngle180(double)` but returns an angle in the range (0, 360].
`static double`	`clamp(double value, double min, double max)` Clamp `value` to the range [`min`, `max`].
`static boolean`	`closeToZero(double d)` Check whether `d` `epsilonEquals(double, double)` 0.0.
`static boolean`	`closeToZero(double x, double y)` Check whether the 2D vector `(x, y)` is nearly (0.0, 0.0).
`static boolean`	`closeToZero2(double[] v)` Check whether the 2D vector `v` is nearly (0.0, 0.0).
`static double[]`	`copy2(double[] dest, double[] v)` Copy a two-dimensional vector.
`static double[]`	`cross3(double[] ret, double[] v1, double[] v2)` Compute the cross product of two 3D vectors.
`static double`	`crossMagnitudeSquared3(double[] v1, double[] v2)` Compute the square of the magnitude of the cross product of two 3D vectors.
`static double`	`crossZ(double[] v1, double[] v2)` Compute the Z component of the cross product of the two 2D vectors `v1` and `v2`.
`static double`	`crossZ(double[] s1, double[] e1, double[] s2, double[] e2)` Compute the Z component of the cross product of the two 2D vectors `s1->e1` and `s2->e2`.
`static double`	`crossZ(double v1x, double v1y, double v2x, double v2y)` Compute the Z component of the cross product of the two 2D vectors `v1` and `v2`.
`static double`	`crossZ(double s1x, double s1y, double e1x, double e1y, double s2x, double s2y, double e2x, double e2y)` Compute the Z component of the cross product of the two 2D vectors `s1->e1` and `s2->e2`.
`static int`	`crossZSign(double v1x, double v1y, double v2x, double v2y)` Compute the sign of the cross product of two 2D vectors.
`static double`	`distance(double p1x, double p1y, double p2x, double p2y)` Compute the distance between the 2D points `(p1x, p1y)` and `(p2x, p2y)`.
`static double`	`distance2(double[] start, double[] end)` Compute the distance between the 2D points `start` and `end`.
`static double`	`distanceSquared(double p1x, double p1y, double p2x, double p2y)` Compute the square of the distance between the 2D points `(p1x, p1y)` and `(p2x, p2y)`.
`static double`	`distanceSquared2(double[] start, double[] end)` Compute the square of the distance between the 2D points `start` and `end`.
`static double`	`dot(double v1x, double v1y, double v2x, double v2y)` Compute the dot product of the 2D vectors `v1` and `v2`.
`static double`	`dot2(double[] v1, double[] v2)` Compute the dot product of the 2D vectors `v1` and `v2`.
`static double`	`dotAny(double[] v1, double[] v2)` Compute the dot product of two arbitrary-dimensional vectors `v1` and `v2`.
`static double[]`	`dup2(double[] v)` Duplicate a two-dimensional vector.
`static boolean`	`epsilonEquals(double a, double b)` Same as `epsilonEquals(double, double, double)` but always uses `EPSILON`.
`static boolean`	`epsilonEquals(double a, double b, double eps)` Check whether the difference between `a` and `b` is at most `eps`.
`static boolean`	`epsilonEquals(double v1x, double v1y, double v2x, double v2y)` Check whether the the 2D vectors `v1` and `v2` are approximately equal.
`static boolean`	`epsilonEquals2(double[] v1, double[] v2)` Check whether the the 2D vectors `v1` and `v2` are approximately equal.
`static int`	`findClosest(double theta, double[] angle)` Find the closest angle to `theta` in an array of angles.
`static double`	`getPolyWidth(float[] x, float[] y, double[] angle, double theta)` Compute the parallel-jaws calipers width of a convex polygon.
`static boolean`	`inAngleRange(double from, double to, double where)` Check whether angle `where` is in the angle range `[from, to]`.
`static double[]`	`interpolateAny(double[] result, double[] v1, double[] v2, double r)` Interpolate between two arbitrary-dimensional vectors.
`static double[]`	`intersect(double[] where, double sx, double sy, double dx, double dy, double cx, double cy, double r)` 2D segment intersect circle.
`static float`	`intersect(float[] s, float[] d, float[] v0, float[] v1, float[] v2, boolean cullBackface, boolean cullFrontFace)` Intersect the 3D segment from s extending by vector d with the 3D triangle v0, v1, v2.
`static double[]`	`intersect2(double[] where, double[] s, double[] d, double extent, double[] corner, double[] diag)` 2D segment intersect rectangle.
`static double[]`	`intersect2(double[] where, double[] s0, double[] d0, double extent0, double[] s1, double[] d1, double extent1)` 2D segment intersection.
`static float`	`intersect3(float[] where, float[] s, float[] d, float[] c, float r, boolean checkOnly)` 3D segment intersect sphere.
`static double`	`magnitude(double x, double y)` Compute the magnitude of the 2D vector `(x, y)`.
`static double`	`magnitude2(double[] v)` Compute the magnitude of the 2D vector `v`.
`static double`	`magnitudeAny(double[] v)` Compute the magnitude of the arbitrary-dimensional vector `v`.
`static double`	`magnitudeSquared(double x, double y)` Compute the square of the magnitude of the 2D vector `(x, y)`.
`static double`	`magnitudeSquared2(double[] v)` Compute the square of the magnitude of the 2D vector `v`.
`static double`	`magnitudeSquaredAny(double[] v)` Compute the square of the magnitude of the arbitrary-dimensional vector `v`.
`static double[]`	`minvert44rht(double[] mi, double[] m)` mi = (m)^{-1} for m 4x4 rigid homogenous transform, mi != m
`static float[]`	`minvert44rht(float[] mi, float[] m)` mi = (m)^{-1} for m 4x4 rigid homogenous transform, mi != m
`static double[]`	`mmult44(double[] m, double[] mb, double[] ma)` 4x4 m = (mb)(ma) for m != mb and m != ma
`static float[]`	`mmult44(float[] m, float[] mb, float[] ma)` 4x4 m = (mb)(ma) for m != mb and m != ma
`static double[]`	`mscale44ht(double[] m, double s)` append a scaling matrix to 4x4 row-major homogenous transform m
`static float[]`	`mscale44ht(float[] m, float s)` append a scaling matrix to 4x4 row-major homogenous transform m
`static float[]`	`mutualPerp(float[] sa, float[] a, float[] sb, float[] b, float[] u)` Covers `mutualPerp(float[], float[], float[], float[], float[], float)`, uses Float.NaN when parallel.
`static float[]`	`mutualPerp(float[] sa, float[] a, float[] sb, float[] b, float[] u, float parallel)` Find the mutual perpendicular between two line segments in 3D.
`static double[]`	`normalizeAny(double[] v)` Normalize an arbitrary-dimensional vector.
`static int`	`percent(double value)` Convert a double value in the range [0.0, 1.0] to an integer percent in the range [0, 100].
`static double`	`project(double sx, double sy, double dx, double dy, double px, double py)` Project 2D point `(px, py)` onto the segment starting at `(sx, sy)` and extending by the vector `(dx, dy)`.
`static double`	`project(double sx, double sy, double sz, double dx, double dy, double dz, double px, double py, double pz)` Same as `project(double, double, double, double, double, double)` but in 3D.
`static float`	`project(float sx, float sy, float sz, float dx, float dy, float dz, float px, float py, float pz)` Same as `project(double, double, double, double, double, double, double, double, double)`.
`static float`	`project3(float[] s, float[] d, float[] p)` Same as `project(float, float, float, float, float, float, float, float, float)`.
`static double`	`random(double from, double to)` Return a random double in the range `[from, to)` if from \leq to, else `(to, from]`.
`static float[]`	`randomDirection(float[] v, float length)` make v a random direction vector with the given length
`static double[]`	`reflectAny(double[] r, double[] i, double[] n)` Arbitrary-dimensional mirror reflection.
`static boolean`	`relativeEquals(double a, double b)` Covers `relativeEquals(double, double, double)`, uses `EPSILON`.
`static boolean`	`relativeEquals(double a, double b, double precision)` Check whether the relative difference between a and b is less than precision.
`static double[]`	`rotY(double[] r, double[] v, double angle)` Rotate 3D vector `v` CCW by `angle` about the Y axis, return in `r`.
`static double[]`	`scale2(double[] v, double s)` Scale a two-dimensional vector.
`static double`	`signum(double value)` Mathematical signum.
`static double[]`	`sub2(double[] v1, double[] v2)` Compute the difference of two two-dimensional vectors.

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

- Field Detail
  - cvsid
```
private static final java.lang.String cvsid
```
    CVS id.
    
    See Also:
    Constant Field Values
  - FP
```
public static float FP
```
    32-bit IEEE floating point precision, defined as the largest value for which (1.0f+FP)-1.0f == 0.0f.
    
    See TimeMath for how this is computed.
  - FP2R
```
public static float FP2R
```
    square root of FP
  - FP3R
```
public static float FP3R
```
    cube root of FP
  - FP4R
```
public static float FP4R
```
    4th root of FP
  - DP
```
public static double DP
```
    similar to FP
  - DP2R
```
public static double DP2R
```
    square root of DP
  - DP3R
```
public static double DP3R
```
    cube root of DP
  - DP4R
```
public static double DP4R
```
    4th root of DP
  - EPSILON
```
public static double EPSILON
```
    A default epsilon.
  - EPSILON2
```
public static double EPSILON2
```
    Default epsilon squared.
  - SQRT_2
```
public static double SQRT_2
```
    sqrt(2.0).
  TWO_PI public static double TWO_PI 2*pi FTWO_PI public static float FTWO_PI TWO_PI as a float
Constructor Detail VonaMath public VonaMath() Method Detail epsilonEquals public static boolean epsilonEquals(double a, double b, double eps) Check whether the difference between a and b is at most eps. Parameters: a - one number to check b - the other number to check eps - the epsilon Returns: true iff the difference between a and b is at most eps epsilonEquals public static boolean epsilonEquals(double a, double b) Same as epsilonEquals(double, double, double) but always uses EPSILON. closeToZero public static boolean closeToZero(double d) Check whether d epsilonEquals(double, double) 0.0. Parameters: d - the double value to check Returns: true iff d epsilonEquals(double, double) 0.0 relativeEquals public static boolean relativeEquals(double a, double b, double precision) Check whether the relative difference between a and b is less than precision. This compares floating point values for equality in a way which respects their diminishing precision with respect to magnitude. References: comp.lang.c FAQ list Question 14.5 Knuth Sec. 4.2.2 pp. 217-8 Didier H. Besset. Object-Oriented Implementation of Numerical Methods. relativeEquals public static boolean relativeEquals(double a, double b) Covers relativeEquals(double, double, double), uses EPSILON. random public static double random(double from, double to) Return a random double in the range [from, to) if from \leq to, else (to, from]. Parameters: from - the start of the range to - the end of the range Returns: a random double in the range [from, to) if from \leq to, else (to, from] randomDirection public static float[] randomDirection(float[] v, float length) make v a random direction vector with the given length addMod public static int addMod(int a0, int a1, int m) Compute (a0 + a1) mod m. Parameters: a0 - the first addend a1 - the second addend m - the modulus Returns: (a0 + a1) mod m percent public static int percent(double value) Convert a double value in the range [0.0, 1.0] to an integer percent in the range [0, 100]. Parameters: value - the value to convert Returns: the corresponding percent signum public static double signum(double value) Mathematical signum. Parameters: value - the value for which to compute the sign Returns: -1.0 if value < 0.0, 1.0 if value > 0.0, 0.0 if value == 0.0 clamp public static double clamp(double value, double min, double max) Clamp value to the range [min, max]. Parameters: value - the value to clamp min - the bottom of the range max - the top of the range Returns: value clamped to the range [min, max] distance public static double distance(double p1x, double p1y, double p2x, double p2y) Compute the distance between the 2D points (p1x, p1y) and (p2x, p2y). Parameters: p1x - the first point x coordinate p1y - the first point y coordinate p2x - the second point x coordinate p2y - the second point y coordinate Returns: the distance from start to end distance2 public static double distance2(double[] start, double[] end) Compute the distance between the 2D points start and end. Parameters: start - the first point, not null end - the second point, not null Returns: the distance from start to end distanceSquared public static double distanceSquared(double p1x, double p1y, double p2x, double p2y) Compute the square of the distance between the 2D points (p1x, p1y) and (p2x, p2y). Parameters: p1x - the first point x coordinate p1y - the first point y coordinate p2x - the second point x coordinate p2y - the second point y coordinate Returns: the square of the distance from start to end distanceSquared2 public static double distanceSquared2(double[] start, double[] end) Compute the square of the distance between the 2D points start and end. Parameters: start - the first point, not null end - the second point, not null Returns: the square of the distance from start to end epsilonEquals public static boolean epsilonEquals(double v1x, double v1y, double v2x, double v2y) Check whether the the 2D vectors v1 and v2 are approximately equal. Parameters: v1x - the first vector x coord v1y - the first vector y coord v2x - the second vector x coord v2y - the second vector y coord Returns: true iff v1 and v2 are epsilonEquals(double, double) coordinate-wise epsilonEquals2 public static boolean epsilonEquals2(double[] v1, double[] v2) Check whether the the 2D vectors v1 and v2 are approximately equal. Parameters: v1 - the first point, not null v2 - the second point, not null Returns: true iff v1 and v2 are epsilonEquals(double, double) coordinate-wise closeToZero public static boolean closeToZero(double x, double y) Check whether the 2D vector (x, y) is nearly (0.0, 0.0). Parameters: x - the x-coord of the vector to check y - the y-coord of the vector to check Returns: true iff (x, y) is epsilonEquals(double, double) (0.0, 0.0) coordinate-wise closeToZero2 public static boolean closeToZero2(double[] v) Check whether the 2D vector v is nearly (0.0, 0.0). Parameters: v - the vector to check, not null Returns: true iff v is epsilonEquals(double, double) (0.0, 0.0) coordinate-wise magnitudeSquared public static double magnitudeSquared(double x, double y) Compute the square of the magnitude of the 2D vector (x, y). Parameters: x - the x-coord of the vector y - the y-coord of the vector Returns: the square of the magnitude of the 2D vector (x, y) magnitudeSquared2 public static double magnitudeSquared2(double[] v) Compute the square of the magnitude of the 2D vector v. Parameters: v - the vector, not null Returns: the square of the magnitude of the 2D vector v magnitudeSquaredAny public static double magnitudeSquaredAny(double[] v) Compute the square of the magnitude of the arbitrary-dimensional vector v. Parameters: v - the vector, not null Returns: the square of the magnitude of the arbitrary-dimensional vector v magnitude public static double magnitude(double x, double y) Compute the magnitude of the 2D vector (x, y). Parameters: x - the x-coord of the vector y - the y-coord of the vector Returns: the magnitude of the 2D vector (x, y) magnitude2 public static double magnitude2(double[] v) Compute the magnitude of the 2D vector v. Parameters: v - the vector Returns: the magnitude of the 2D vector v magnitudeAny public static double magnitudeAny(double[] v) Compute the magnitude of the arbitrary-dimensional vector v. Parameters: v - the vector, not null Returns: the magnitude of the arbitrary-dimensional vector v dot public static double dot(double v1x, double v1y, double v2x, double v2y) Compute the dot product of the 2D vectors v1 and v2. Parameters: v1x - the first vector x coord v1y - the first vector y coord v2x - the second vector x coord v2y - the second vector y coord Returns: the dot product of v1 and v2 dot2 public static double dot2(double[] v1, double[] v2) Compute the dot product of the 2D vectors v1 and v2. Parameters: v1 - the first vector v2 - the second vector Returns: the dot product of v1 and v2 dotAny public static double dotAny(double[] v1, double[] v2) Compute the dot product of two arbitrary-dimensional vectors v1 and v2. If v1 and v2 are not the same length then the shorter length is used. Parameters: v1 - the first vector v2 - the second vector Returns: the dot product of v1 and v2 crossZ public static double crossZ(double v1x, double v1y, double v2x, double v2y) Compute the Z component of the cross product of the two 2D vectors v1 and v2. Parameters: v1x - the first vector x coord v1y - the first vector y coord v2x - the second vector x coord v2y - the second vector y coord Returns: the Z component of the cross product of v1 and v2 crossZ public static double crossZ(double[] v1, double[] v2) Compute the Z component of the cross product of the two 2D vectors v1 and v2. Parameters: v1 - the first vector v2 - the second vector Returns: the Z component of the cross product of v1 and v2 crossZ public static double crossZ(double[] s1, double[] e1, double[] s2, double[] e2) Compute the Z component of the cross product of the two 2D vectors s1->e1 and s2->e2. Parameters: s1 - the first vector start point e1 - the first vector end point s2 - the second vector start point e2 - the second vector end point Returns: the Z component of the cross product of s1->e1 and s2->e2 crossZ public static double crossZ(double s1x, double s1y, double e1x, double e1y, double s2x, double s2y, double e2x, double e2y) Compute the Z component of the cross product of the two 2D vectors s1->e1 and s2->e2. Parameters: s1x - the first vector start point x coord s1y - the first vector start point y coord e1x - the first vector end point x coord e1y - the first vector end point y coord s2x - the second vector start point x coord s2y - the second vector start point y coord e2x - the second vector end point x coord e2y - the second vector end point y coord Returns: the Z component of the cross product of s1->e1 and s2->e2 cross3 public static double[] cross3(double[] ret, double[] v1, double[] v2) Compute the cross product of two 3D vectors. Parameters: v1 - the first vector, not null v2 - the second vector, not null ret - the return vector, not null. On return ret = v1 x v2. Returns: a reference to ret crossMagnitudeSquared3 public static double crossMagnitudeSquared3(double[] v1, double[] v2) Compute the square of the magnitude of the cross product of two 3D vectors. Parameters: v1 - the first vector, not null v2 - the second vector, not null Returns: the magnitude of v1 x v2 crossZSign public static int crossZSign(double v1x, double v1y, double v2x, double v2y) Compute the sign of the cross product of two 2D vectors. Parameters: v1x - the first vector x coord v1y - the first vector y coord v2x - the second vector x coord v2y - the second vector y coord Returns: the sign of v1 x v2 normalizeAny public static double[] normalizeAny(double[] v) Normalize an arbitrary-dimensional vector. Parameters: v - the vector to normalize, not null, normalized in-place Returns: a reference to v add2 public static double[] add2(double[] v1, double[] v2) Compute the sum of two two-dimensional vectors. Parameters: v1 - the first addend, not null, sum is written here on return v2 - the second addend, not null Returns: a reference to v1, which is overwritten with the sum sub2 public static double[] sub2(double[] v1, double[] v2) Compute the difference of two two-dimensional vectors. Parameters: v1 - the minuend, not null, v1-v2 is written here on return v2 - the subtrahend, not null Returns: a reference to v1, which is overwritten with the difference dup2 public static double[] dup2(double[] v) Duplicate a two-dimensional vector. Parameters: v - the vector to duplicate, not null Returns: a copy of v copy2 public static double[] copy2(double[] dest, double[] v) Copy a two-dimensional vector. Parameters: dest - the destination of the copy, not null v - the vector to copy, not null Returns: a reference to dest scale2 public static double[] scale2(double[] v, double s) Scale a two-dimensional vector. Parameters: v - the vector to scale, not null, scaled in-place s - the scale factor Returns: a reference to v, as scaled by s project public static double project(double sx, double sy, double dx, double dy, double px, double py) Project 2D point (px, py) onto the segment starting at (sx, sy) and extending by the vector (dx, dy). Parameters: sx - the segment start point x coordinate sy - the segment start point y coordinate dx - the segment extent x dy - the segment extent y px - the x coordinate of the point to project py - the y coordinate of the point to project Returns: the location of the projection of (px, py) on the segment given relative to the length of the segment. If the return value is where then the projection point is (sx, sy) + where*(dx, dy). If the segment length is 0.0 then the return value is 0.0. project public static double project(double sx, double sy, double sz, double dx, double dy, double dz, double px, double py, double pz) Same as project(double, double, double, double, double, double) but in 3D. project public static float project(float sx, float sy, float sz, float dx, float dy, float dz, float px, float py, float pz) Same as project(double, double, double, double, double, double, double, double, double). project3 public static float project3(float[] s, float[] d, float[] p) Same as project(float, float, float, float, float, float, float, float, float). mutualPerp public static float[] mutualPerp(float[] sa, float[] a, float[] sb, float[] b, float[] u, float parallel) Find the mutual perpendicular between two line segments in 3D. Let d be the sb-sa vector, and t be the vector from the intersection of the perpendicular on segment a to the intersection point on segment b. Then solve the following two-equation linear system for ua and ub: t*a=0, t*b=0. Handles both the case that either or both segments are degenerate and the case that the segments are parallel. Parameters: sa - the start coordinates of segment a a - the extent of segment a sb - the start coordinates of segment b b - the extent of segment b u - if non-null then this must be of length at least two and the return values are filled in here, null to cons parallel - this value is returned when the lines are parallel Returns: the signed coordinates along segment a and b, normalized to segment length, respectively, of the intersection points along the segments with the mutual perpendicular mutualPerp public static float[] mutualPerp(float[] sa, float[] a, float[] sb, float[] b, float[] u) Covers mutualPerp(float[], float[], float[], float[], float[], float), uses Float.NaN when parallel. intersect public static float intersect(float[] s, float[] d, float[] v0, float[] v1, float[] v2, boolean cullBackface, boolean cullFrontFace) Intersect the 3D segment from s extending by vector d with the 3D triangle v0, v1, v2. The triangle vertices are taken in CCW order when viewing the front face. The implementation follows [Moller, Trumbore, 1997. Fast, Minimum Storage Ray/Triangle Intersection]. See also [Moller, Haines 2002. Real-Time Rendering]. Parameters: s - the segment start point d - the segment extent v0 - triangle vertex 0 v1 - triangle vertex 1 v2 - triangle vertex 2 cullBackface - whether to always fail intersect for back-facing triangles cullFrontFace - whether to always fail intersect for front-facing triangles Returns: the signed coordinate of the intersection point along the segment, normalized to the length of the segment, or NaN if no intersection intersect3 public static float intersect3(float[] where, float[] s, float[] d, float[] c, float r, boolean checkOnly) 3D segment intersect sphere. Intersects the line through the segment starting at s and extending by d with the radius r circle centered at c. There are three possible cases: either there is no intrersection and the return where values are NaN; the line is tangent to the circle and both return where values are equal; or there are two intersections and the return where values are symmetric about the projection of the circle center onto the line. The implementation follows that of intersect(double[], double, double, double, double, double, double, double). Parameters: where - if non-null, the intersection points will be written here on return, as "where" values relative to the length of the segment. If there was no intersection the where values will be NaN. Otherwise the coordinates of the intersection points are given by s+where[i]*d. Note that the intersections are computed between the circle and the line through the segment, so it is possible that the return where values are less than 0.0 or greater than 1.0. If you are only interested in intersections within the segment then just disregard where values outside this range. s - the segment start point d - the segment extent c - the circle center r - the circle radius checkOnly - if set then the return where will be NaN if no intersection or non-NaN, but otherwise unspecified, if intersecting Returns: the where value of the intersection point nearest s angle public static double angle(double x, double y) Return the CCW angle from the positive X axis to the vector (x, y), in the range [0, 2*PI). Parameters: x - the x coordinate of the vector y - the y coordinate of the vector Returns: Return the CCW angle from the positive X axis to the vector (x, y), in the range [0, 2*PI), unless (x, y) is closeToZero(double, double), in which case 0.0 is returned angle public static double angle(double[] v) Return the CCW angle from the positive X axis to the 2D vector v. Parameters: v - the vector, not null Returns: Return the CCW angle from the positive X axis to v, unless v is closeToZero2(double[]), in which case 0.0 is returned canonicalizeAngle public static double canonicalizeAngle(double t) Return the canonical angle in the range (-PI, PI] corresponding to any angle t. Parameters: t - the angle to canonicalize, in radians Returns: the canonical angle in the range (-PI, PI] corresponding to t canonicalizeAngle180 public static double canonicalizeAngle180(double t) Same as canonicalizeAngle(double) but operates on degrees. canonicalizeAngle360 public static double canonicalizeAngle360(double t) Same as canonicalizeAngle180(double) but returns an angle in the range (0, 360]. inAngleRange public static boolean inAngleRange(double from, double to, double where) Check whether angle where is in the angle range [from, to]. Parameters: from - the start angle, radians, need not be normalized to - the end angle, radians, need not be normalized where - the angle to check, radians, need not be normalized Returns: true iff where is in the angle range [from, to] findClosest public static int findClosest(double theta, double[] angle) Find the closest angle to theta in an array of angles. Parameters: theta - the angle to look for, radians, must be canonicalized (see canonicalizeAngle(double)) angle - the array of angles in which to look, not null, must all be canonicalized and must be sorted smallest to largest Returns: the index of the closest angle to theta intersect public static double[] intersect(double[] where, double sx, double sy, double dx, double dy, double cx, double cy, double r) 2D segment intersect circle. Intersects the line through the segment starting at (sx, sy) and extending by the vector (dx, dy) with the radius r circle centered at (cx, cy). There are three possible cases: either there is no intrersection and the return where values are NaN; the line is tangent to the circle and both return where values are equal; or there are two intersections and the return where values are symmetric about the projection of the circle center onto the line. Parameters: where - the intersection points will be written here on return, as "where" values relative to the length of the segment. If there was no intersection the where values will be NaN. Otherwise the coordinates of the intersection points are given by (sx, sy) + where[i]*(dx, dy). Note that the intersections are computed between the circle and the line through the segment, so it is possible that the return where values are less than 0.0 or greater than 1.0. If you are only interested in intersections within the segment then just disregard where values outside this range. sx - the segment start point x coordinate sy - the segment start point y coordinate dx - the segment extent x coordinate dy - the segment extent y coordinate cx - circle center x coordinate cy - circle center y coordinate r - the circle radius Returns: a reference to where intersect2 public static double[] intersect2(double[] where, double[] s0, double[] d0, double extent0, double[] s1, double[] d1, double extent1) 2D segment intersection. EPSILON is used for degeneracy tests. Parameters: where - the locations of the intersection on each segment, as multiples of the respective d vectors, are written here on return. If the segments were parallel then Double.POSITIVE_INFINITY is returned, unless they are coincident, in which case the location of the first shared point (in either direction) is returned. Note that the segments do not actually intersect unless the components of this return vector are in the range [0.0, extent]. s0 - the start point of the first segment d0 - the direction of the first segment (need not be normalized) extent0 - the extent of the first segment in multiples of d0. Must be non-negative, may be Double.POSITIVE_INFINITY. s1 - the start point of the second segment d1 - the direction of the second segment (need not be normalized) extent1 - the extent of the second segment in multiples of d1. Must be non-negative, may be Double.POSITIVE_INFINITY. Returns: a reference to where intersect2 public static double[] intersect2(double[] where, double[] s, double[] d, double extent, double[] corner, double[] diag) 2D segment intersect rectangle. Intersects the segment s->extent*d with the rectangle from corner to corner+diag. There are fivew possible cases: the segment is completely outside the rectangle, and the return where values are NaN the segment is completely inside the rectangle and the return where values are 0.0 and extent the segment touches only a rectangle corner and both return where values are equal exactly one endpoint of the segment is inside or on the rectangle and the other is outside the intersection of the segment and the rectangle is a proper subset of the segment. Parameters: where - the endpoints of the intersected segment are written here on return, as "where" values relative to the magnitude of d. If there was no intersection the where values will be NaN. Otherwise the coordinates of the intersection points are given by (s[0]+d[0]*where[0], s[1]+d[1]*where[0]), (s[0]+d[0]*where[1], s[1]+d[1]*where[1]). s - the segment start point d - the segment direction vector, need not be normalized extent - the segment extent in multiples of d corner - a corner of the rectangle diag - the diagonal from corner to the opposite corner Returns: a reference to where interpolateAny public static double[] interpolateAny(double[] result, double[] v1, double[] v2, double r) Interpolate between two arbitrary-dimensional vectors. If result, v1, and v2 are not the same length then the shortest length is used. Parameters: result - not null, on return result = (1-r)*v1 + r*v2 v1 - the first vector v2 - the second vector r - the interpolation factor Returns: a reference to result reflectAny public static double[] reflectAny(double[] r, double[] i, double[] n) Arbitrary-dimensional mirror reflection. If r, i, and n are not the same length then the shortest length is used. Parameters: r - the reflection direction is written here on return, not null i - the incident direction, not null n - the surface normal direction, not null Returns: a reference to r rotY public static double[] rotY(double[] r, double[] v, double angle) Rotate 3D vector v CCW by angle about the Y axis, return in r. Parameters: r - the return vector, not null v - the vector to rotate, not null angle - the CCW angle to rotate v about the Y axis Returns: a reference to r getPolyWidth public static double getPolyWidth(float[] x, float[] y, double[] angle, double theta) Compute the parallel-jaws calipers width of a convex polygon. Parameters: x - the polygon vertex x coords in CCW order, not null y - the polygon vertex y coords in CCW order, not null, same length as x angle - the canonical (see canonicalizeAngle(double)) polygon vertex angles in CCW order, same length as the coordinate vectors. If the first element is NaN then the angles are computed and written here. If this parameter is null then the angles are computed internally. theta - the angle at which to compute the width Returns: the parallel-jaws calipers width of the polygon in direction theta mmult44 public static double[] mmult44(double[] m, double[] mb, double[] ma) 4x4 m = (mb)(ma) for m != mb and m != ma mmult44 public static float[] mmult44(float[] m, float[] mb, float[] ma) 4x4 m = (mb)(ma) for m != mb and m != ma minvert44rht public static double[] minvert44rht(double[] mi, double[] m) mi = (m)^{-1} for m 4x4 rigid homogenous transform, mi != m minvert44rht public static float[] minvert44rht(float[] mi, float[] m) mi = (m)^{-1} for m 4x4 rigid homogenous transform, mi != m mscale44ht public static double[] mscale44ht(double[] m, double s) append a scaling matrix to 4x4 row-major homogenous transform m mscale44ht public static float[] mscale44ht(float[] m, float s) append a scaling matrix to 4x4 row-major homogenous transform m

Class VonaMath

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

cvsid

FP

FP2R

FP3R

FP4R

DP

DP2R

DP3R

DP4R

EPSILON

EPSILON2

SQRT_2

TWO_PI

FTWO_PI

Constructor Detail

VonaMath

Method Detail

epsilonEquals

epsilonEquals

closeToZero

relativeEquals

relativeEquals

random

randomDirection

addMod

percent

signum

clamp

distance

distance2

distanceSquared

distanceSquared2

epsilonEquals

epsilonEquals2

closeToZero

closeToZero2

magnitudeSquared

magnitudeSquared2

magnitudeSquaredAny

magnitude

magnitude2

magnitudeAny

dot

dot2

dotAny

crossZ

crossZ

crossZ

crossZ

cross3

crossMagnitudeSquared3

crossZSign

normalizeAny

add2

sub2

dup2

copy2

scale2

project

project

project

project3

mutualPerp

mutualPerp

intersect

intersect3

angle

angle

canonicalizeAngle

canonicalizeAngle180

canonicalizeAngle360

inAngleRange

findClosest

intersect