EuclidCoreRandomTools (euclid-core 0.5.1 API)

java.lang.Object
- us.ihmc.euclid.tools.EuclidCoreRandomTools

```
public abstract class EuclidCoreRandomTools
extends java.lang.Object
```
This class provides random generators to generate random geometry objects.
The main application is for writing JUnit Tests.

Constructor Summary

Constructors
Constructor and Description

EuclidCoreRandomTools()

Constructors
Constructor and Description
`EuclidCoreRandomTools()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static AffineTransform`	`generateRandomAffineTransform(java.util.Random random)` Deprecated. Use `nextAffineTransform(Random)` instead
`static AxisAngle`	`generateRandomAxisAngle(java.util.Random random)` Deprecated. Use `nextAxisAngle(Random)` instead
`static AxisAngle`	`generateRandomAxisAngle(java.util.Random random, double minMaxAngle)` Deprecated. Use `nextAxisAngle(Random,double)` instead
`static AxisAngle32`	`generateRandomAxisAngle32(java.util.Random random)` Deprecated. Use `nextAxisAngle32(Random)` instead
`static AxisAngle32`	`generateRandomAxisAngle32(java.util.Random random, double minMaxAngle)` Deprecated. Use `nextAxisAngle32(Random,double)` instead
`static Matrix3D`	`generateRandomDiagonalMatrix3D(java.util.Random random)` Deprecated. Use `nextDiagonalMatrix3D(Random)` instead
`static Matrix3D`	`generateRandomDiagonalMatrix3D(java.util.Random random, double minMaxValue)` Deprecated. Use `nextDiagonalMatrix3D(Random,double)` instead
`static Matrix3D`	`generateRandomDiagonalMatrix3D(java.util.Random random, double minValue, double maxValue)` Deprecated. Use `nextDiagonalMatrix3D(Random,double,double)` instead
`static double`	`generateRandomDouble(java.util.Random random)` Deprecated. Use `nextDouble(Random)` instead
`static double`	`generateRandomDouble(java.util.Random random, double minMaxValue)` Deprecated. Use `nextDouble(Random,double)` instead
`static double`	`generateRandomDouble(java.util.Random random, double minValue, double maxValue)` Deprecated. Use `nextDouble(Random,double,double)` instead
`static Matrix3D`	`generateRandomMatrix3D(java.util.Random random)` Deprecated. Use `nextMatrix3D(Random)` instead
`static Matrix3D`	`generateRandomMatrix3D(java.util.Random random, double minMaxValue)` Deprecated. Use `nextMatrix3D(Random,double)` instead
`static Matrix3D`	`generateRandomMatrix3D(java.util.Random random, double minValue, double maxValue)` Deprecated. Use `nextMatrix3D(Random,double,double)` instead
`static Vector3D`	`generateRandomOrthogonalVector3D(java.util.Random random, Vector3DReadOnly vectorToBeOrthogonalTo, boolean normalize)` Deprecated. Use `nextOrthogonalVector3D(Random,Vector3DReadOnly,boolean)` instead
`static Point2D`	`generateRandomPoint2D(java.util.Random random)` Deprecated. Use `nextPoint2D(Random)` instead
`static Point2D`	`generateRandomPoint2D(java.util.Random random, double minMax)` Deprecated. Use `nextPoint2D(Random,double)` instead
`static Point2D`	`generateRandomPoint2D(java.util.Random random, double min, double max)` Deprecated. Use `nextPoint2D(Random,double,double)` instead
`static Point2D`	`generateRandomPoint2D(java.util.Random random, double minX, double maxX, double minY, double maxY)` Deprecated. Use `nextPoint2D(Random,double,double,double,double)` instead
`static Point2D32`	`generateRandomPoint2D32(java.util.Random random)` Deprecated. Use `nextPoint2D32(Random)` instead
`static Point3D`	`generateRandomPoint3D(java.util.Random random)` Deprecated. Use `nextPoint3D(Random)` instead
`static Point3D`	`generateRandomPoint3D(java.util.Random random, double minMax)` Deprecated. Use `nextPoint3D(Random,double)` instead
`static Point3D`	`generateRandomPoint3D(java.util.Random random, double min, double max)` Deprecated. Use `nextPoint3D(Random,double,double)` instead
`static Point3D`	`generateRandomPoint3D(java.util.Random random, double maxAbsoluteX, double maxAbsoluteY, double maxAbsoluteZ)` Deprecated. Use `nextPoint3D(Random,double,double,double)` instead
`static Point3D`	`generateRandomPoint3D(java.util.Random random, double minX, double maxX, double minY, double maxY, double minZ, double maxZ)` Deprecated. Use `nextPoint3D(Random,double,double,double,double,double,double)` instead
`static Point3D32`	`generateRandomPoint3D32(java.util.Random random)` Deprecated. Use `nextPoint3D32(Random)` instead
`static Quaternion`	`generateRandomQuaternion(java.util.Random random)` Deprecated. Use `nextQuaternion(Random)` instead
`static Quaternion`	`generateRandomQuaternion(java.util.Random random, double minMaxAngle)` Deprecated. Use `nextQuaternion(Random,double)` instead
`static Quaternion32`	`generateRandomQuaternion32(java.util.Random random)` Deprecated. Use `nextQuaternion32(Random)` instead
`static Quaternion32`	`generateRandomQuaternion32(java.util.Random random, double minMaxAngleRange)` Deprecated. Use `nextQuaternion32(Random,double)` instead
`static QuaternionBasedTransform`	`generateRandomQuaternionBasedTransform(java.util.Random random)` Deprecated. Use `nextQuaternionBasedTransform(Random)` instead
`static RigidBodyTransform`	`generateRandomRigidBodyTransform(java.util.Random random)` Deprecated. Use `nextRigidBodyTransform(Random)` instead
`static RigidBodyTransform`	`generateRandomRigidBodyTransform2D(java.util.Random random)` Deprecated. Use `nextRigidBodyTransform2D(Random)` instead
`static RotationMatrix`	`generateRandomRotationMatrix(java.util.Random random)` Deprecated. Use `nextRotationMatrix(Random)` instead
`static RotationMatrix`	`generateRandomRotationMatrix(java.util.Random random, double minMaxAngle)` Deprecated. Use `nextRotationMatrix(Random,double)` instead
`static RotationScaleMatrix`	`generateRandomRotationScaleMatrix(java.util.Random random, double maxScale)` Deprecated. Use `nextRotationScaleMatrix(Random,double)` instead
`static RotationScaleMatrix`	`generateRandomRotationScaleMatrix(java.util.Random random, double minMaxAngle, double maxScale)` Deprecated. Use `nextRotationScaleMatrix(Random,double,double)` instead
`static Vector3D`	`generateRandomRotationVector(java.util.Random random)` Deprecated. Use `nextRotationVector(Random)` instead
`static Vector3D`	`generateRandomRotationVector(java.util.Random random, double minMaxAngle)` Deprecated. Use `nextRotationVector(Random,double)` instead
`static Vector2D`	`generateRandomVector2D(java.util.Random random)` Deprecated. Use `nextVector2D(Random)` instead
`static Vector2D`	`generateRandomVector2D(java.util.Random random, double min, double max)` Deprecated. Use `nextVector2D(Random,double,double)` instead
`static Vector2D`	`generateRandomVector2D(java.util.Random random, Tuple2DReadOnly minMax)` Deprecated. Use `nextVector2D(Random,Tuple2DReadOnly)` instead
`static Vector2D`	`generateRandomVector2D(java.util.Random random, Tuple2DReadOnly min, Tuple2DReadOnly max)` Deprecated. Use `nextVector2D(Random,Tuple2DReadOnly,Tuple2DReadOnly)` instead
`static Vector2D32`	`generateRandomVector2D32(java.util.Random random)` Deprecated. Use `nextVector2D32(Random)` instead
`static Vector2D`	`generateRandomVector2DWithFixedLength(java.util.Random random, double length)` Deprecated. Use `nextVector2DWithFixedLength(Random,double)` instead
`static Vector3D`	`generateRandomVector3D(java.util.Random random)` Deprecated. Use `nextVector3D(Random)` instead
`static Vector3D`	`generateRandomVector3D(java.util.Random random, double min, double max)` Deprecated. Use `nextVector3D(Random,double,double)` instead
`static Vector3D`	`generateRandomVector3D(java.util.Random random, double minX, double maxX, double minY, double maxY, double minZ, double maxZ)` Deprecated. Use `nextVector3D(Random,double,double,double,double,double,double)` instead
`static Vector3D`	`generateRandomVector3D(java.util.Random random, Tuple3DReadOnly minMax)` Deprecated. Use `nextVector3D(Random,Tuple3DReadOnly)` instead
`static Vector3D`	`generateRandomVector3D(java.util.Random random, Tuple3DReadOnly min, Tuple3DReadOnly max)` Deprecated. Use `nextVector3D(Random,Tuple3DReadOnly,Tuple3DReadOnly)` instead
`static Vector3D32`	`generateRandomVector3D32(java.util.Random random)` Deprecated. Use `nextVector3D32(Random)` instead
`static Vector3D`	`generateRandomVector3DWithFixedLength(java.util.Random random, double length)` Deprecated. Use `nextVector3DWithFixedLength(Random,double)` instead
`static Vector4D`	`generateRandomVector4D(java.util.Random random)` Deprecated. Use `nextVector4D(Random)` instead
`static Vector4D32`	`generateRandomVector4D32(java.util.Random random)` Deprecated. Use `nextVector4D32(Random)` instead
`static double[]`	`generateRandomYawPitchRoll(java.util.Random random)` Deprecated. Use `nextYawPitchRoll(Random)` instead
`static double[]`	`generateRandomYawPitchRoll(java.util.Random random, double minMaxYaw, double minMaxPitch, double minMaxRoll)` Deprecated. Use `nextYawPitchRoll(Random,double,double,double)` instead
`static AffineTransform`	`nextAffineTransform(java.util.Random random)` Generates a random affine transform.
`static AxisAngle`	`nextAxisAngle(java.util.Random random)` Generates a random axis-angle.
`static AxisAngle`	`nextAxisAngle(java.util.Random random, double minMaxAngle)` Generates a random axis-angle.
`static AxisAngle32`	`nextAxisAngle32(java.util.Random random)` Generates a random axis-angle.
`static AxisAngle32`	`nextAxisAngle32(java.util.Random random, double minMaxAngle)` Generates a random axis-angle.
`static Matrix3D`	`nextDiagonalMatrix3D(java.util.Random random)` Generates a random diagonal 3-by-3 matrix.
`static Matrix3D`	`nextDiagonalMatrix3D(java.util.Random random, double minMaxValue)` Generates a random diagonal 3-by-3 matrix.
`static Matrix3D`	`nextDiagonalMatrix3D(java.util.Random random, double minValue, double maxValue)` Generates a random diagonal 3-by-3 matrix.
`static double`	`nextDouble(java.util.Random random)` Generates a random double ∈ [-1.0; 1.0].
`static double`	`nextDouble(java.util.Random random, double minMaxValue)` Generates a random double ∈ [-`minMax`; `minMax`].
`static double`	`nextDouble(java.util.Random random, double minValue, double maxValue)` Generates a random double ∈ [`minValue`; `maxValue`].
`static Matrix3D`	`nextMatrix3D(java.util.Random random)` Generates a random 3-by-3 matrix.
`static Matrix3D`	`nextMatrix3D(java.util.Random random, double minMaxValue)` Generates a random 3-by-3 matrix.
`static Matrix3D`	`nextMatrix3D(java.util.Random random, double minValue, double maxValue)` Generates a random 3-by-3 matrix.
`static Vector3D`	`nextOrthogonalVector3D(java.util.Random random, Vector3DReadOnly vectorToBeOrthogonalTo, boolean normalize)` Generates a random vector that is perpendicular to `vectorToBeOrthogonalTo`.
`static Point2D`	`nextPoint2D(java.util.Random random)` Generates a random 2D point.
`static Point2D`	`nextPoint2D(java.util.Random random, double minMax)` Generates a random 2D point.
`static Point2D`	`nextPoint2D(java.util.Random random, double min, double max)` Generates a random point.
`static Point2D`	`nextPoint2D(java.util.Random random, double minX, double maxX, double minY, double maxY)` Generates a random point.
`static Point2D32`	`nextPoint2D32(java.util.Random random)` Generates a random 2D point.
`static Point3D`	`nextPoint3D(java.util.Random random)` Generates a random point.
`static Point3D`	`nextPoint3D(java.util.Random random, double minMax)` Generates a random point.
`static Point3D`	`nextPoint3D(java.util.Random random, double min, double max)` Generates a random point.
`static Point3D`	`nextPoint3D(java.util.Random random, double maxAbsoluteX, double maxAbsoluteY, double maxAbsoluteZ)` Generates a random point.
`static Point3D`	`nextPoint3D(java.util.Random random, double minX, double maxX, double minY, double maxY, double minZ, double maxZ)` Generates a random point.
`static Point3D32`	`nextPoint3D32(java.util.Random random)` Generates a random point.
`static Quaternion`	`nextQuaternion(java.util.Random random)` Generates a random quaternion uniformly distributed on the unit-sphere.
`static Quaternion`	`nextQuaternion(java.util.Random random, double minMaxAngle)` Generates a random quaternion uniformly distributed on the unit-sphere.
`static Quaternion32`	`nextQuaternion32(java.util.Random random)` Generates a random quaternion uniformly distributed on the unit-sphere.
`static Quaternion32`	`nextQuaternion32(java.util.Random random, double minMaxAngleRange)` Generates a random quaternion uniformly distributed on the unit-sphere.
`static QuaternionBasedTransform`	`nextQuaternionBasedTransform(java.util.Random random)` Generates a random quaternion-based transform.
`static RigidBodyTransform`	`nextRigidBodyTransform(java.util.Random random)` Generates a random rigid-body transform.
`static RigidBodyTransform`	`nextRigidBodyTransform2D(java.util.Random random)` Generates a random rigid-body transform with the rotation part being a transform in the XY plane.
`static RotationMatrix`	`nextRotationMatrix(java.util.Random random)` Generates a random rotation matrix uniformly distributed on the unit sphere and describes an rotation angle in [-pi; pi].
`static RotationMatrix`	`nextRotationMatrix(java.util.Random random, double minMaxAngle)` Generates a random rotation matrix uniformly distributed on the unit sphere and describes an rotation angle in [-`minMaxAngle`; `minMaxAngle`].
`static RotationScaleMatrix`	`nextRotationScaleMatrix(java.util.Random random, double maxScale)` Generates a random rotation-scale matrix.
`static RotationScaleMatrix`	`nextRotationScaleMatrix(java.util.Random random, double minMaxAngle, double maxScale)` Generates a random rotation-scale matrix.
`static Vector3D`	`nextRotationVector(java.util.Random random)` Generates a random rotation vector.
`static Vector3D`	`nextRotationVector(java.util.Random random, double minMaxAngle)` Generates a random rotation vector.
`static Vector2D`	`nextVector2D(java.util.Random random)` Generates a random 2D vector.
`static Vector2D`	`nextVector2D(java.util.Random random, double min, double max)` Generates a random vector.
`static Vector2D`	`nextVector2D(java.util.Random random, Tuple2DReadOnly minMax)` Generates a random 2D vector.
`static Vector2D`	`nextVector2D(java.util.Random random, Tuple2DReadOnly min, Tuple2DReadOnly max)` Generates a random 2D vector.
`static Vector2D32`	`nextVector2D32(java.util.Random random)` Generates a random 2D vector.
`static Vector2D`	`nextVector2DWithFixedLength(java.util.Random random, double length)` Generates a random 2D vector given its length `length`.
`static Vector3D`	`nextVector3D(java.util.Random random)` Generates a random vector.
`static Vector3D`	`nextVector3D(java.util.Random random, double min, double max)` Generates a random vector.
`static Vector3D`	`nextVector3D(java.util.Random random, double minX, double maxX, double minY, double maxY, double minZ, double maxZ)` Generates a random vector.
`static Vector3D`	`nextVector3D(java.util.Random random, Tuple3DReadOnly minMax)` Generates a random vector.
`static Vector3D`	`nextVector3D(java.util.Random random, Tuple3DReadOnly min, Tuple3DReadOnly max)` Generates a random vector.
`static Vector3D32`	`nextVector3D32(java.util.Random random)` Generates a random vector.
`static Vector3D`	`nextVector3DWithFixedLength(java.util.Random random, double length)` Generates a random vector given its length `length`.
`static Vector4D`	`nextVector4D(java.util.Random random)` Generates a random 4D vector.
`static Vector4D32`	`nextVector4D32(java.util.Random random)` Generates a random 4D vector.
`static double[]`	`nextYawPitchRoll(java.util.Random random)` Generates random yaw-pitch-roll angles and returns it in an array.
`static double[]`	`nextYawPitchRoll(java.util.Random random, double minMaxYaw, double minMaxPitch, double minMaxRoll)` Generates random yaw-pitch-roll angles and returns it in an array.
`static void`	`randomizeAxisAngle(java.util.Random random, AxisAngleBasics axisAngleToRandomize)` Randomizes the given axis-angle.
`static void`	`randomizeAxisAngle(java.util.Random random, double minMaxAngle, AxisAngleBasics axisAngleToRandomize)` Randomizes the given axis-angle.
`static void`	`randomizeTuple2D(java.util.Random random, Tuple2DBasics tupleToRandomize)` Randomizes a 2D tuple.
`static void`	`randomizeTuple2D(java.util.Random random, Tuple2DReadOnly minMax, Tuple2DBasics tupleToRandomize)` Randomizes a 2D tuple.
`static void`	`randomizeTuple2D(java.util.Random random, Tuple2DReadOnly min, Tuple2DReadOnly max, Tuple2DBasics tupleToRandomize)` Randomizes a 2D tuple.
`static void`	`randomizeTuple3D(java.util.Random random, Tuple3DBasics tupleToRandomize)` Randomizes a tuple.
`static void`	`randomizeTuple3D(java.util.Random random, Tuple3DReadOnly minMax, Tuple3DBasics tupleToRandomize)` Randomizes a tuple.
`static void`	`randomizeTuple3D(java.util.Random random, Tuple3DReadOnly min, Tuple3DReadOnly max, Tuple3DBasics tupleToRandomize)` Randomizes a tuple.

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

- Constructor Detail
  - EuclidCoreRandomTools
```
public EuclidCoreRandomTools()
```
- Method Detail
  - generateRandomYawPitchRoll
```
@Deprecated
public static double[] generateRandomYawPitchRoll(java.util.Random random)
```
    Deprecated. Use nextYawPitchRoll(Random) instead
    Generates random yaw-pitch-roll angles and returns it in an array.
    - yaw ∈ [-pi; pi],
    - pitch ∈ [-pi/2.0; pi/2.0],
    - roll ∈ [-pi; pi],
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    an array containing the random yaw-pitch-roll angles.
  - nextYawPitchRoll
```
public static double[] nextYawPitchRoll(java.util.Random random)
```
    Generates random yaw-pitch-roll angles and returns it in an array.
    - yaw ∈ [-pi; pi],
    - pitch ∈ [-pi/2.0; pi/2.0],
    - roll ∈ [-pi; pi],
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    an array containing the random yaw-pitch-roll angles.
  - generateRandomYawPitchRoll
```
@Deprecated
public static double[] generateRandomYawPitchRoll(java.util.Random random,
                                                               double minMaxYaw,
                                                               double minMaxPitch,
                                                               double minMaxRoll)
```
    Deprecated. Use nextYawPitchRoll(Random,double,double,double) instead
    Generates random yaw-pitch-roll angles and returns it in an array.
    - yaw ∈ [-minMaxYaw; minMaxYaw],
    - pitch ∈ [-minMaxPitch; minMaxPitch],
    - roll ∈ [-minMaxRoll; minMaxRoll],
    Parameters:
    
    random - the random generator to use.
    
    minMaxYaw - the maximum absolute angle for the generated yaw angle.
    
    minMaxPitch - the maximum absolute angle for the generated pitch angle.
    
    minMaxRoll - the maximum absolute angle for the generated roll angle.
    
    Returns:
    
    an array containing the random yaw-pitch-roll angles.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxYaw < 0, minMaxPitch < 0, minMaxRoll < 0.
  - nextYawPitchRoll
```
public static double[] nextYawPitchRoll(java.util.Random random,
                                        double minMaxYaw,
                                        double minMaxPitch,
                                        double minMaxRoll)
```
    Generates random yaw-pitch-roll angles and returns it in an array.
    - yaw ∈ [-minMaxYaw; minMaxYaw],
    - pitch ∈ [-minMaxPitch; minMaxPitch],
    - roll ∈ [-minMaxRoll; minMaxRoll],
    Parameters:
    
    random - the random generator to use.
    
    minMaxYaw - the maximum absolute angle for the generated yaw angle.
    
    minMaxPitch - the maximum absolute angle for the generated pitch angle.
    
    minMaxRoll - the maximum absolute angle for the generated roll angle.
    
    Returns:
    
    an array containing the random yaw-pitch-roll angles.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxYaw < 0, minMaxPitch < 0, minMaxRoll < 0.
  - generateRandomRotationVector
```
@Deprecated
public static Vector3D generateRandomRotationVector(java.util.Random random)
```
    Deprecated. Use nextRotationVector(Random) instead
    
    Generates a random rotation vector.
    rotationVector.length() ∈ [-pi; pi].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random rotation vector.
  - nextRotationVector
```
public static Vector3D nextRotationVector(java.util.Random random)
```
    Generates a random rotation vector.
    rotationVector.length() ∈ [-pi; pi].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random rotation vector.
  - generateRandomRotationVector
```
@Deprecated
public static Vector3D generateRandomRotationVector(java.util.Random random,
                                                                 double minMaxAngle)
```
    Deprecated. Use nextRotationVector(Random,double) instead
    
    Generates a random rotation vector.
    rotationVector.length() ∈ [-minMaxAngle; minMaxAngle].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum length of the generated rotation vector.
    
    Returns:
    
    the random rotation vector.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
  - nextRotationVector
```
public static Vector3D nextRotationVector(java.util.Random random,
                                          double minMaxAngle)
```
    Generates a random rotation vector.
    rotationVector.length() ∈ [-minMaxAngle; minMaxAngle].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum length of the generated rotation vector.
    
    Returns:
    
    the random rotation vector.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
  - generateRandomAxisAngle
```
@Deprecated
public static AxisAngle generateRandomAxisAngle(java.util.Random random)
```
    Deprecated. Use nextAxisAngle(Random) instead
    
    Generates a random axis-angle.
    axisAngle.getAngle() ∈ [-pi; pi].
    
    The approach used here generates uniformly a point on a sphere to create uniformly distributed random axes, see link. The angle is then generated as a normal bounded random double.
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random axis-angle.
  - nextAxisAngle
```
public static AxisAngle nextAxisAngle(java.util.Random random)
```
    Generates a random axis-angle.
    axisAngle.getAngle() ∈ [-pi; pi].
    
    The approach used here generates uniformly a point on a sphere to create uniformly distributed random axes, see link. The angle is then generated as a normal bounded random double.
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random axis-angle.
  - generateRandomAxisAngle
```
@Deprecated
public static AxisAngle generateRandomAxisAngle(java.util.Random random,
                                                             double minMaxAngle)
```
    Deprecated. Use nextAxisAngle(Random,double) instead
    
    Generates a random axis-angle.
    axisAngle.getAngle() ∈ [-minMaxAngle; minMaxAngle].
    
    The approach used here generates uniformly a point on a sphere to create uniformly distributed random axes, see link. The angle is then generated as a normal bounded random double.
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum absolute angle value.
    
    Returns:
    
    the random axis-angle.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
  - nextAxisAngle
```
public static AxisAngle nextAxisAngle(java.util.Random random,
                                      double minMaxAngle)
```
    Generates a random axis-angle.
    axisAngle.getAngle() ∈ [-minMaxAngle; minMaxAngle].
    
    The approach used here generates uniformly a point on a sphere to create uniformly distributed random axes, see link. The angle is then generated as a normal bounded random double.
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum absolute angle value.
    
    Returns:
    
    the random axis-angle.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
  - generateRandomAxisAngle32
```
@Deprecated
public static AxisAngle32 generateRandomAxisAngle32(java.util.Random random)
```
    Deprecated. Use nextAxisAngle32(Random) instead
    
    Generates a random axis-angle.
    axisAngle.getAngle() ∈ [-pi; pi].
    
    The approach used here generates uniformly a point on a sphere to create uniformly distributed random axes, see link. The angle is then generated as a normal bounded random double.
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random axis-angle.
  - nextAxisAngle32
```
public static AxisAngle32 nextAxisAngle32(java.util.Random random)
```
    Generates a random axis-angle.
    axisAngle.getAngle() ∈ [-pi; pi].
    
    The approach used here generates uniformly a point on a sphere to create uniformly distributed random axes, see link. The angle is then generated as a normal bounded random double.
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random axis-angle.
  - generateRandomAxisAngle32
```
@Deprecated
public static AxisAngle32 generateRandomAxisAngle32(java.util.Random random,
                                                                 double minMaxAngle)
```
    Deprecated. Use nextAxisAngle32(Random,double) instead
    
    Generates a random axis-angle.
    axisAngle.getAngle() ∈ [-minMaxAngle; minMaxAngle].
    
    The approach used here generates uniformly a point on a sphere to create uniformly distributed random axes, see link. The angle is then generated as a normal bounded random double.
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum absolute angle value.
    
    Returns:
    
    the random axis-angle.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
  - nextAxisAngle32
```
public static AxisAngle32 nextAxisAngle32(java.util.Random random,
                                          double minMaxAngle)
```
    Generates a random axis-angle.
    axisAngle.getAngle() ∈ [-minMaxAngle; minMaxAngle].
    
    The approach used here generates uniformly a point on a sphere to create uniformly distributed random axes, see link. The angle is then generated as a normal bounded random double.
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum absolute angle value.
    
    Returns:
    
    the random axis-angle.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
  - generateRandomDiagonalMatrix3D
```
@Deprecated
public static Matrix3D generateRandomDiagonalMatrix3D(java.util.Random random)
```
    Deprecated. Use nextDiagonalMatrix3D(Random) instead
    Generates a random diagonal 3-by-3 matrix.
    - matrix.getM00() ∈ [-1.0; 1.0].
    - matrix.getM11() ∈ [-1.0; 1.0].
    - matrix.getM22() ∈ [-1.0; 1.0].
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random diagonal matrix.
  - nextDiagonalMatrix3D
```
public static Matrix3D nextDiagonalMatrix3D(java.util.Random random)
```
    Generates a random diagonal 3-by-3 matrix.
    - matrix.getM00() ∈ [-1.0; 1.0].
    - matrix.getM11() ∈ [-1.0; 1.0].
    - matrix.getM22() ∈ [-1.0; 1.0].
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random diagonal matrix.
  - generateRandomDiagonalMatrix3D
```
@Deprecated
public static Matrix3D generateRandomDiagonalMatrix3D(java.util.Random random,
                                                                   double minMaxValue)
```
    Deprecated. Use nextDiagonalMatrix3D(Random,double) instead
    Generates a random diagonal 3-by-3 matrix.
    - matrix.getM00() ∈ [-minMaxValue; minMaxValue].
    - matrix.getM11() ∈ [-minMaxValue; minMaxValue].
    - matrix.getM22() ∈ [-minMaxValue; minMaxValue].
    Parameters:
    
    random - the random generator to use.
    
    minMaxValue - the maximum absolute value for each diagonal element.
    
    Returns:
    
    the random diagonal matrix.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxValue < 0.
  - nextDiagonalMatrix3D
```
public static Matrix3D nextDiagonalMatrix3D(java.util.Random random,
                                            double minMaxValue)
```
    Generates a random diagonal 3-by-3 matrix.
    - matrix.getM00() ∈ [-minMaxValue; minMaxValue].
    - matrix.getM11() ∈ [-minMaxValue; minMaxValue].
    - matrix.getM22() ∈ [-minMaxValue; minMaxValue].
    Parameters:
    
    random - the random generator to use.
    
    minMaxValue - the maximum absolute value for each diagonal element.
    
    Returns:
    
    the random diagonal matrix.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxValue < 0.
  - generateRandomDiagonalMatrix3D
```
@Deprecated
public static Matrix3D generateRandomDiagonalMatrix3D(java.util.Random random,
                                                                   double minValue,
                                                                   double maxValue)
```
    Deprecated. Use nextDiagonalMatrix3D(Random,double,double) instead
    Generates a random diagonal 3-by-3 matrix.
    - matrix.getM00() ∈ [minValue; maxValue].
    - matrix.getM11() ∈ [minValue; maxValue].
    - matrix.getM22() ∈ [minValue; maxValue].
    Parameters:
    
    random - the random generator to use.
    
    minValue - the minimum value of each diagonal element.
    
    maxValue - the maximum value of each diagonal element.
    
    Returns:
    
    the random diagonal matrix.
    
    Throws:
    
    java.lang.RuntimeException - if minValue > maxValue.
  - nextDiagonalMatrix3D
```
public static Matrix3D nextDiagonalMatrix3D(java.util.Random random,
                                            double minValue,
                                            double maxValue)
```
    Generates a random diagonal 3-by-3 matrix.
    - matrix.getM00() ∈ [minValue; maxValue].
    - matrix.getM11() ∈ [minValue; maxValue].
    - matrix.getM22() ∈ [minValue; maxValue].
    Parameters:
    
    random - the random generator to use.
    
    minValue - the minimum value of each diagonal element.
    
    maxValue - the maximum value of each diagonal element.
    
    Returns:
    
    the random diagonal matrix.
    
    Throws:
    
    java.lang.RuntimeException - if minValue > maxValue.
  - generateRandomDouble
```
@Deprecated
public static double generateRandomDouble(java.util.Random random)
```
    Deprecated. Use nextDouble(Random) instead
    
    Generates a random double ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random double.
  - nextDouble
```
public static double nextDouble(java.util.Random random)
```
    Generates a random double ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random double.
  - generateRandomDouble
```
@Deprecated
public static double generateRandomDouble(java.util.Random random,
                                                       double minMaxValue)
```
    Deprecated. Use nextDouble(Random,double) instead
    
    Generates a random double ∈ [-minMax; minMax].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxValue - the maximum absolute value of the generated double.
    
    Returns:
    
    the random double.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxValue < 0.
  - nextDouble
```
public static double nextDouble(java.util.Random random,
                                double minMaxValue)
```
    Generates a random double ∈ [-minMax; minMax].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxValue - the maximum absolute value of the generated double.
    
    Returns:
    
    the random double.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxValue < 0.
  - generateRandomDouble
```
@Deprecated
public static double generateRandomDouble(java.util.Random random,
                                                       double minValue,
                                                       double maxValue)
```
    Deprecated. Use nextDouble(Random,double,double) instead
    
    Generates a random double ∈ [minValue; maxValue].
    
    Parameters:
    
    random - the random generator to use.
    
    minValue - the minimum value of the generated double.
    
    maxValue - the maximum value of the generated double.
    
    Returns:
    
    the random double.
    
    Throws:
    
    java.lang.RuntimeException - if minValue > maxValue.
  - nextDouble
```
public static double nextDouble(java.util.Random random,
                                double minValue,
                                double maxValue)
```
    Generates a random double ∈ [minValue; maxValue].
    
    Parameters:
    
    random - the random generator to use.
    
    minValue - the minimum value of the generated double.
    
    maxValue - the maximum value of the generated double.
    
    Returns:
    
    the random double.
    
    Throws:
    
    java.lang.RuntimeException - if minValue > maxValue.
  - generateRandomMatrix3D
```
@Deprecated
public static Matrix3D generateRandomMatrix3D(java.util.Random random)
```
    Deprecated. Use nextMatrix3D(Random) instead
    
    Generates a random 3-by-3 matrix.
    matrix_ij ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random matrix.
  - nextMatrix3D
```
public static Matrix3D nextMatrix3D(java.util.Random random)
```
    Generates a random 3-by-3 matrix.
    matrix_ij ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random matrix.
  - generateRandomMatrix3D
```
@Deprecated
public static Matrix3D generateRandomMatrix3D(java.util.Random random,
                                                           double minMaxValue)
```
    Deprecated. Use nextMatrix3D(Random,double) instead
    
    Generates a random 3-by-3 matrix.
    matrix_ij ∈ [-minMaxValue; minMaxValue].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxValue - the maximum absolute value for each element.
    
    Returns:
    
    the random matrix.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxValue < 0.
  - nextMatrix3D
```
public static Matrix3D nextMatrix3D(java.util.Random random,
                                    double minMaxValue)
```
    Generates a random 3-by-3 matrix.
    matrix_ij ∈ [-minMaxValue; minMaxValue].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxValue - the maximum absolute value for each element.
    
    Returns:
    
    the random matrix.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxValue < 0.
  - generateRandomMatrix3D
```
@Deprecated
public static Matrix3D generateRandomMatrix3D(java.util.Random random,
                                                           double minValue,
                                                           double maxValue)
```
    Deprecated. Use nextMatrix3D(Random,double,double) instead
    
    Generates a random 3-by-3 matrix.
    matrix_ij ∈ [minValue; maxValue].
    
    Parameters:
    
    random - the random generator to use.
    
    minValue - the minimum value for each element.
    
    maxValue - the maximum value for each element.
    
    Returns:
    
    the random matrix.
    
    Throws:
    
    java.lang.RuntimeException - if minValue > maxValue.
  - nextMatrix3D
```
public static Matrix3D nextMatrix3D(java.util.Random random,
                                    double minValue,
                                    double maxValue)
```
    Generates a random 3-by-3 matrix.
    matrix_ij ∈ [minValue; maxValue].
    
    Parameters:
    
    random - the random generator to use.
    
    minValue - the minimum value for each element.
    
    maxValue - the maximum value for each element.
    
    Returns:
    
    the random matrix.
    
    Throws:
    
    java.lang.RuntimeException - if minValue > maxValue.
  - generateRandomQuaternion
```
@Deprecated
public static Quaternion generateRandomQuaternion(java.util.Random random)
```
    Deprecated. Use nextQuaternion(Random) instead
    
    Generates a random quaternion uniformly distributed on the unit-sphere.
    The rotation magnitude described by the generated quaternion is in [-pi; pi].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random quaternion.
  - nextQuaternion
```
public static Quaternion nextQuaternion(java.util.Random random)
```
    Generates a random quaternion uniformly distributed on the unit-sphere.
    The rotation magnitude described by the generated quaternion is in [-pi; pi].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random quaternion.
  - generateRandomQuaternion
```
@Deprecated
public static Quaternion generateRandomQuaternion(java.util.Random random,
                                                               double minMaxAngle)
```
    Deprecated. Use nextQuaternion(Random,double) instead
    
    Generates a random quaternion uniformly distributed on the unit-sphere.
    The rotation magnitude described by the generated quaternion is in [-minMaxAngle; minMaxAngle].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum absolute angle described by the generated quaternion.
    
    Returns:
    
    the random quaternion.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
  - nextQuaternion
```
public static Quaternion nextQuaternion(java.util.Random random,
                                        double minMaxAngle)
```
    Generates a random quaternion uniformly distributed on the unit-sphere.
    The rotation magnitude described by the generated quaternion is in [-minMaxAngle; minMaxAngle].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum absolute angle described by the generated quaternion.
    
    Returns:
    
    the random quaternion.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
  - generateRandomQuaternion32
```
@Deprecated
public static Quaternion32 generateRandomQuaternion32(java.util.Random random)
```
    Deprecated. Use nextQuaternion32(Random) instead
    
    Generates a random quaternion uniformly distributed on the unit-sphere.
    The rotation magnitude described by the generated quaternion is in [-pi; pi].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random quaternion.
  - nextQuaternion32
```
public static Quaternion32 nextQuaternion32(java.util.Random random)
```
    Generates a random quaternion uniformly distributed on the unit-sphere.
    The rotation magnitude described by the generated quaternion is in [-pi; pi].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random quaternion.
  - generateRandomQuaternion32
```
@Deprecated
public static Quaternion32 generateRandomQuaternion32(java.util.Random random,
                                                                   double minMaxAngleRange)
```
    Deprecated. Use nextQuaternion32(Random,double) instead
    
    Generates a random quaternion uniformly distributed on the unit-sphere.
    The rotation magnitude described by the generated quaternion is in [-minMaxAngle; minMaxAngle].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngleRange - the maximum absolute angle described by the generated quaternion.
    
    Returns:
    
    the random quaternion.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
  - nextQuaternion32
```
public static Quaternion32 nextQuaternion32(java.util.Random random,
                                            double minMaxAngleRange)
```
    Generates a random quaternion uniformly distributed on the unit-sphere.
    The rotation magnitude described by the generated quaternion is in [-minMaxAngle; minMaxAngle].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngleRange - the maximum absolute angle described by the generated quaternion.
    
    Returns:
    
    the random quaternion.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
  - generateRandomRigidBodyTransform
```
@Deprecated
public static RigidBodyTransform generateRandomRigidBodyTransform(java.util.Random random)
```
    Deprecated. Use nextRigidBodyTransform(Random) instead
    Generates a random rigid-body transform.
    - The rotation part is uniformly distributed on the unit sphere and describes an rotation angle in [-pi; pi].
    - Each component of the translation part is in [-1.0; 1.0].
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random rigid-body transform.
  - nextRigidBodyTransform
```
public static RigidBodyTransform nextRigidBodyTransform(java.util.Random random)
```
    Generates a random rigid-body transform.
    - The rotation part is uniformly distributed on the unit sphere and describes an rotation angle in [-pi; pi].
    - Each component of the translation part is in [-1.0; 1.0].
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random rigid-body transform.
  - generateRandomRigidBodyTransform2D
```
@Deprecated
public static RigidBodyTransform generateRandomRigidBodyTransform2D(java.util.Random random)
```
    Deprecated. Use nextRigidBodyTransform2D(Random) instead
    
    Generates a random rigid-body transform with the rotation part being a transform in the XY plane.
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random rigid-body transform.
  - nextRigidBodyTransform2D
```
public static RigidBodyTransform nextRigidBodyTransform2D(java.util.Random random)
```
    Generates a random rigid-body transform with the rotation part being a transform in the XY plane.
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random rigid-body transform.
  - generateRandomQuaternionBasedTransform
```
@Deprecated
public static QuaternionBasedTransform generateRandomQuaternionBasedTransform(java.util.Random random)
```
    Deprecated. Use nextQuaternionBasedTransform(Random) instead
    Generates a random quaternion-based transform.
    - The rotation part is uniformly distributed on the unit sphere and describes an rotation angle in [-pi; pi].
    - Each component of the translation part is in [-1.0; 1.0].
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random quaternion-based transform.
  - nextQuaternionBasedTransform
```
public static QuaternionBasedTransform nextQuaternionBasedTransform(java.util.Random random)
```
    Generates a random quaternion-based transform.
    - The rotation part is uniformly distributed on the unit sphere and describes an rotation angle in [-pi; pi].
    - Each component of the translation part is in [-1.0; 1.0].
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random quaternion-based transform.
  - generateRandomAffineTransform
```
@Deprecated
public static AffineTransform generateRandomAffineTransform(java.util.Random random)
```
    Deprecated. Use nextAffineTransform(Random) instead
    Generates a random affine transform.
    - The rotation part is uniformly distributed on the unit sphere and describes an rotation angle in [-pi; pi].
    - Each scale factor is in ]0.0; 10.0].
    - Each component of the translation part is in [-1.0; 1.0].
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random affine transform.
  - nextAffineTransform
```
public static AffineTransform nextAffineTransform(java.util.Random random)
```
    Generates a random affine transform.
    - The rotation part is uniformly distributed on the unit sphere and describes an rotation angle in [-pi; pi].
    - Each scale factor is in ]0.0; 10.0].
    - Each component of the translation part is in [-1.0; 1.0].
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random affine transform.
  - generateRandomRotationMatrix
```
@Deprecated
public static RotationMatrix generateRandomRotationMatrix(java.util.Random random)
```
    Deprecated. Use nextRotationMatrix(Random) instead
    
    Generates a random rotation matrix uniformly distributed on the unit sphere and describes an rotation angle in [-pi; pi].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random rotation matrix.
  - nextRotationMatrix
```
public static RotationMatrix nextRotationMatrix(java.util.Random random)
```
    Generates a random rotation matrix uniformly distributed on the unit sphere and describes an rotation angle in [-pi; pi].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random rotation matrix.
  - generateRandomRotationMatrix
```
@Deprecated
public static RotationMatrix generateRandomRotationMatrix(java.util.Random random,
                                                                       double minMaxAngle)
```
    Deprecated. Use nextRotationMatrix(Random,double) instead
    
    Generates a random rotation matrix uniformly distributed on the unit sphere and describes an rotation angle in [-minMaxAngle; minMaxAngle].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum absolute angle described by the generated rotation matrix.
    
    Returns:
    
    the random rotation matrix.
  - nextRotationMatrix
```
public static RotationMatrix nextRotationMatrix(java.util.Random random,
                                                double minMaxAngle)
```
    Generates a random rotation matrix uniformly distributed on the unit sphere and describes an rotation angle in [-minMaxAngle; minMaxAngle].
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum absolute angle described by the generated rotation matrix.
    
    Returns:
    
    the random rotation matrix.
  - generateRandomRotationScaleMatrix
```
@Deprecated
public static RotationScaleMatrix generateRandomRotationScaleMatrix(java.util.Random random,
                                                                                 double maxScale)
```
    Deprecated. Use nextRotationScaleMatrix(Random,double) instead
    Generates a random rotation-scale matrix.
    - The rotation part is uniformly distributed on the unit sphere and describes an rotation angle in [-pi; pi].
    - Each scale factor is in ]0.0; maxScale].
    Parameters:
    
    random - the random generator to use.
    
    maxScale - the maximum scale value used for each scale factor.
    
    Returns:
    
    the random rotation-scale matrix.
    
    Throws:
    
    java.lang.RuntimeException - if maxScale < 0.
  - nextRotationScaleMatrix
```
public static RotationScaleMatrix nextRotationScaleMatrix(java.util.Random random,
                                                          double maxScale)
```
    Generates a random rotation-scale matrix.
    - The rotation part is uniformly distributed on the unit sphere and describes an rotation angle in [-pi; pi].
    - Each scale factor is in ]0.0; maxScale].
    Parameters:
    
    random - the random generator to use.
    
    maxScale - the maximum scale value used for each scale factor.
    
    Returns:
    
    the random rotation-scale matrix.
    
    Throws:
    
    java.lang.RuntimeException - if maxScale < 0.
  - generateRandomRotationScaleMatrix
```
@Deprecated
public static RotationScaleMatrix generateRandomRotationScaleMatrix(java.util.Random random,
                                                                                 double minMaxAngle,
                                                                                 double maxScale)
```
    Deprecated. Use nextRotationScaleMatrix(Random,double,double) instead
    Generates a random rotation-scale matrix.
    - The rotation part is uniformly distributed on the unit sphere and describes an rotation angle in [-minMaxAngle; minMaxAngle].
    - Each scale factor is in ]0.0; maxScale].
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum absolute angle value that describes the generated rotation-scale matrix.
    
    maxScale - the maximum scale value used for each scale factor.
    
    Returns:
    
    the random rotation-scale matrix.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
    
    java.lang.RuntimeException - if maxScale < 0.
  - nextRotationScaleMatrix
```
public static RotationScaleMatrix nextRotationScaleMatrix(java.util.Random random,
                                                          double minMaxAngle,
                                                          double maxScale)
```
    Generates a random rotation-scale matrix.
    - The rotation part is uniformly distributed on the unit sphere and describes an rotation angle in [-minMaxAngle; minMaxAngle].
    - Each scale factor is in ]0.0; maxScale].
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum absolute angle value that describes the generated rotation-scale matrix.
    
    maxScale - the maximum scale value used for each scale factor.
    
    Returns:
    
    the random rotation-scale matrix.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
    
    java.lang.RuntimeException - if maxScale < 0.
  - generateRandomPoint3D
```
@Deprecated
public static Point3D generateRandomPoint3D(java.util.Random random)
```
    Deprecated. Use nextPoint3D(Random) instead
    
    Generates a random point.
    point_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random point.
  - nextPoint3D
```
public static Point3D nextPoint3D(java.util.Random random)
```
    Generates a random point.
    point_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random point.
  - generateRandomPoint3D
```
@Deprecated
public static Point3D generateRandomPoint3D(java.util.Random random,
                                                         double minMax)
```
    Deprecated. Use nextPoint3D(Random,double) instead
    
    Generates a random point.
    point.x ∈ [-minMax; minMax].
    point.y ∈ [-minMax; minMax].
    point.z ∈ [-minMax; minMax].
    
    Parameters:
    
    random - the random generator to use.
    
    minMax - the maximum absolute value for each coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if minMax < 0.
  - nextPoint3D
```
public static Point3D nextPoint3D(java.util.Random random,
                                  double minMax)
```
    Generates a random point.
    point.x ∈ [-minMax; minMax].
    point.y ∈ [-minMax; minMax].
    point.z ∈ [-minMax; minMax].
    
    Parameters:
    
    random - the random generator to use.
    
    minMax - the maximum absolute value for each coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if minMax < 0.
  - generateRandomPoint3D
```
@Deprecated
public static Point3D generateRandomPoint3D(java.util.Random random,
                                                         double min,
                                                         double max)
```
    Deprecated. Use nextPoint3D(Random,double,double) instead
    
    Generates a random point.
    point.x ∈ [min; max].
    point.y ∈ [min; max].
    point.z ∈ [min; max].
    
    Parameters:
    
    random - the random generator to use.
    
    min - the minimum value for each coordinate.
    
    max - the maximum value for each coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if min > max.
  - nextPoint3D
```
public static Point3D nextPoint3D(java.util.Random random,
                                  double min,
                                  double max)
```
    Generates a random point.
    point.x ∈ [min; max].
    point.y ∈ [min; max].
    point.z ∈ [min; max].
    
    Parameters:
    
    random - the random generator to use.
    
    min - the minimum value for each coordinate.
    
    max - the maximum value for each coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if min > max.
  - generateRandomPoint3D
```
@Deprecated
public static Point3D generateRandomPoint3D(java.util.Random random,
                                                         double maxAbsoluteX,
                                                         double maxAbsoluteY,
                                                         double maxAbsoluteZ)
```
    Deprecated. Use nextPoint3D(Random,double,double,double) instead
    
    Generates a random point.
    point.x ∈ [-maxAbsoluteX; maxAbsoluteX].
    point.y ∈ [-maxAbsoluteY; maxAbsoluteY].
    point.z ∈ [-maxAbsoluteZ; maxAbsoluteZ].
    
    Parameters:
    
    random - the random generator to use.
    
    maxAbsoluteX - the maximum absolute value for the x-coordinate.
    
    maxAbsoluteY - the maximum absolute value for the y-coordinate.
    
    maxAbsoluteZ - the maximum absolute value for the z-coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if maxAbsoluteX < 0, maxAbsoluteY < 0, maxAbsoluteZ < 0.
  - nextPoint3D
```
public static Point3D nextPoint3D(java.util.Random random,
                                  double maxAbsoluteX,
                                  double maxAbsoluteY,
                                  double maxAbsoluteZ)
```
    Generates a random point.
    point.x ∈ [-maxAbsoluteX; maxAbsoluteX].
    point.y ∈ [-maxAbsoluteY; maxAbsoluteY].
    point.z ∈ [-maxAbsoluteZ; maxAbsoluteZ].
    
    Parameters:
    
    random - the random generator to use.
    
    maxAbsoluteX - the maximum absolute value for the x-coordinate.
    
    maxAbsoluteY - the maximum absolute value for the y-coordinate.
    
    maxAbsoluteZ - the maximum absolute value for the z-coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if maxAbsoluteX < 0, maxAbsoluteY < 0, maxAbsoluteZ < 0.
  - generateRandomPoint3D
```
@Deprecated
public static Point3D generateRandomPoint3D(java.util.Random random,
                                                         double minX,
                                                         double maxX,
                                                         double minY,
                                                         double maxY,
                                                         double minZ,
                                                         double maxZ)
```
    Deprecated. Use nextPoint3D(Random,double,double,double,double,double,double) instead
    
    Generates a random point.
    point.x ∈ [minX; maxX].
    point.y ∈ [minY; maxY].
    point.z ∈ [minZ; maxZ].
    
    Parameters:
    
    random - the random generator to use.
    
    minX - the minimum value for the x-coordinate.
    
    maxX - the maximum value for the x-coordinate.
    
    minY - the minimum value for the y-coordinate.
    
    maxY - the maximum value for the y-coordinate.
    
    minZ - the minimum value for the z-coordinate.
    
    maxZ - the maximum value for the z-coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if maxX < minX, maxY < minY, maxZ < minZ.
  - nextPoint3D
```
public static Point3D nextPoint3D(java.util.Random random,
                                  double minX,
                                  double maxX,
                                  double minY,
                                  double maxY,
                                  double minZ,
                                  double maxZ)
```
    Generates a random point.
    point.x ∈ [minX; maxX].
    point.y ∈ [minY; maxY].
    point.z ∈ [minZ; maxZ].
    
    Parameters:
    
    random - the random generator to use.
    
    minX - the minimum value for the x-coordinate.
    
    maxX - the maximum value for the x-coordinate.
    
    minY - the minimum value for the y-coordinate.
    
    maxY - the maximum value for the y-coordinate.
    
    minZ - the minimum value for the z-coordinate.
    
    maxZ - the maximum value for the z-coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if maxX < minX, maxY < minY, maxZ < minZ.
  - generateRandomVector3D
```
@Deprecated
public static Vector3D generateRandomVector3D(java.util.Random random)
```
    Deprecated. Use nextVector3D(Random) instead
    
    Generates a random vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random vector.
  - nextVector3D
```
public static Vector3D nextVector3D(java.util.Random random)
```
    Generates a random vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random vector.
  - generateRandomVector3D
```
@Deprecated
public static Vector3D generateRandomVector3D(java.util.Random random,
                                                           Tuple3DReadOnly minMax)
```
    Deprecated. Use nextVector3D(Random,Tuple3DReadOnly) instead
    
    Generates a random vector.
    vector_i ∈ [-minMax_i; minMax_i].
    
    Parameters:
    
    random - the random generator to use.
    
    minMax - tuple used to bound the maximum absolute value of each component of the generated vector. Not modified.
    
    Returns:
    
    the random vector.
    
    Throws:
    
    java.lang.RuntimeException - if any component of minMax is negative.
  - nextVector3D
```
public static Vector3D nextVector3D(java.util.Random random,
                                    Tuple3DReadOnly minMax)
```
    Generates a random vector.
    vector_i ∈ [-minMax_i; minMax_i].
    
    Parameters:
    
    random - the random generator to use.
    
    minMax - tuple used to bound the maximum absolute value of each component of the generated vector. Not modified.
    
    Returns:
    
    the random vector.
    
    Throws:
    
    java.lang.RuntimeException - if any component of minMax is negative.
  - generateRandomVector3D
```
@Deprecated
public static Vector3D generateRandomVector3D(java.util.Random random,
                                                           Tuple3DReadOnly min,
                                                           Tuple3DReadOnly max)
```
    Deprecated. Use nextVector3D(Random,Tuple3DReadOnly,Tuple3DReadOnly) instead
    
    Generates a random vector.
    vector_i ∈ [min_i; max_i].
    
    Parameters:
    
    random - the random generator to use.
    
    min - tuple used as upper-bound for each component of the generated vector. Not modified.
    
    max - tuple used as lower-bound for each component of the generated vector. Not modified.
    
    Returns:
    
    the random vector.
    
    Throws:
    
    java.lang.RuntimeException - if min_i > max_i.
  - nextVector3D
```
public static Vector3D nextVector3D(java.util.Random random,
                                    Tuple3DReadOnly min,
                                    Tuple3DReadOnly max)
```
    Generates a random vector.
    vector_i ∈ [min_i; max_i].
    
    Parameters:
    
    random - the random generator to use.
    
    min - tuple used as upper-bound for each component of the generated vector. Not modified.
    
    max - tuple used as lower-bound for each component of the generated vector. Not modified.
    
    Returns:
    
    the random vector.
    
    Throws:
    
    java.lang.RuntimeException - if min_i > max_i.
  - generateRandomVector3D
```
@Deprecated
public static Vector3D generateRandomVector3D(java.util.Random random,
                                                           double min,
                                                           double max)
```
    Deprecated. Use nextVector3D(Random,double,double) instead
    
    Generates a random vector.
    vector_i ∈ [min; max].
    
    Parameters:
    
    random - the random generator to use.
    
    min - upper-bound for each component of the generated vector. Not modified.
    
    max - lower-bound for each component of the generated vector. Not modified.
    
    Returns:
    
    the random vector.
    
    Throws:
    
    java.lang.RuntimeException - if min > max.
  - nextVector3D
```
public static Vector3D nextVector3D(java.util.Random random,
                                    double min,
                                    double max)
```
    Generates a random vector.
    vector_i ∈ [min; max].
    
    Parameters:
    
    random - the random generator to use.
    
    min - upper-bound for each component of the generated vector. Not modified.
    
    max - lower-bound for each component of the generated vector. Not modified.
    
    Returns:
    
    the random vector.
    
    Throws:
    
    java.lang.RuntimeException - if min > max.
  - generateRandomVector3D
```
@Deprecated
public static Vector3D generateRandomVector3D(java.util.Random random,
                                                           double minX,
                                                           double maxX,
                                                           double minY,
                                                           double maxY,
                                                           double minZ,
                                                           double maxZ)
```
    Deprecated. Use nextVector3D(Random,double,double,double,double,double,double) instead
    
    Generates a random vector.
    vector.x ∈ [minX; maxX].
    vector.y ∈ [minY; maxY].
    vector.z ∈ [minZ; maxZ].
    
    Parameters:
    
    random - the random generator to use.
    
    minX - the minimum value for the x-component.
    
    maxX - the maximum value for the x-component.
    
    minY - the minimum value for the y-component.
    
    maxY - the maximum value for the y-component.
    
    minZ - the minimum value for the z-component.
    
    maxZ - the maximum value for the z-component.
    
    Returns:
    
    the random vector.
    
    Throws:
    
    java.lang.RuntimeException - if maxX < minX, maxY < minY, maxZ < minZ.
  - nextVector3D
```
public static Vector3D nextVector3D(java.util.Random random,
                                    double minX,
                                    double maxX,
                                    double minY,
                                    double maxY,
                                    double minZ,
                                    double maxZ)
```
    Generates a random vector.
    vector.x ∈ [minX; maxX].
    vector.y ∈ [minY; maxY].
    vector.z ∈ [minZ; maxZ].
    
    Parameters:
    
    random - the random generator to use.
    
    minX - the minimum value for the x-component.
    
    maxX - the maximum value for the x-component.
    
    minY - the minimum value for the y-component.
    
    maxY - the maximum value for the y-component.
    
    minZ - the minimum value for the z-component.
    
    maxZ - the maximum value for the z-component.
    
    Returns:
    
    the random vector.
    
    Throws:
    
    java.lang.RuntimeException - if maxX < minX, maxY < minY, maxZ < minZ.
  - generateRandomVector3DWithFixedLength
```
@Deprecated
public static Vector3D generateRandomVector3DWithFixedLength(java.util.Random random,
                                                                          double length)
```
    Deprecated. Use nextVector3DWithFixedLength(Random,double) instead
    
    Generates a random vector given its length length.
    
    Parameters:
    
    random - the random generator to use.
    
    length - the length of the generated vector.
    
    Returns:
    
    the random vector.
  - nextVector3DWithFixedLength
```
public static Vector3D nextVector3DWithFixedLength(java.util.Random random,
                                                   double length)
```
    Generates a random vector given its length length.
    
    Parameters:
    
    random - the random generator to use.
    
    length - the length of the generated vector.
    
    Returns:
    
    the random vector.
  - generateRandomOrthogonalVector3D
```
@Deprecated
public static Vector3D generateRandomOrthogonalVector3D(java.util.Random random,
                                                                     Vector3DReadOnly vectorToBeOrthogonalTo,
                                                                     boolean normalize)
```
    Deprecated. Use nextOrthogonalVector3D(Random,Vector3DReadOnly,boolean) instead
    
    Generates a random vector that is perpendicular to vectorToBeOrthogonalTo.
    
    Parameters:
    
    random - the random generator to use.
    
    vectorToBeOrthogonalTo - the vector to be orthogonal to. Not modified.
    
    normalize - whether to normalize the generated vector or not.
    
    Returns:
    
    the random vector.
  - nextOrthogonalVector3D
```
public static Vector3D nextOrthogonalVector3D(java.util.Random random,
                                              Vector3DReadOnly vectorToBeOrthogonalTo,
                                              boolean normalize)
```
    Generates a random vector that is perpendicular to vectorToBeOrthogonalTo.
    
    Parameters:
    
    random - the random generator to use.
    
    vectorToBeOrthogonalTo - the vector to be orthogonal to. Not modified.
    
    normalize - whether to normalize the generated vector or not.
    
    Returns:
    
    the random vector.
  - generateRandomPoint2D
```
@Deprecated
public static Point2D generateRandomPoint2D(java.util.Random random)
```
    Deprecated. Use nextPoint2D(Random) instead
    
    Generates a random 2D point.
    point_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 2D point.
  - nextPoint2D
```
public static Point2D nextPoint2D(java.util.Random random)
```
    Generates a random 2D point.
    point_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 2D point.
  - generateRandomPoint2D
```
@Deprecated
public static Point2D generateRandomPoint2D(java.util.Random random,
                                                         double minMax)
```
    Deprecated. Use nextPoint2D(Random,double) instead
    
    Generates a random 2D point.
    point_i ∈ [-minMax; minMax].
    
    Parameters:
    
    random - the random generator to use.
    
    minMax - the maximum absolute value for each coordinate.
    
    Returns:
    
    the random 2D point.
    
    Throws:
    
    java.lang.RuntimeException - if minMax < 0.
  - nextPoint2D
```
public static Point2D nextPoint2D(java.util.Random random,
                                  double minMax)
```
    Generates a random 2D point.
    point_i ∈ [-minMax; minMax].
    
    Parameters:
    
    random - the random generator to use.
    
    minMax - the maximum absolute value for each coordinate.
    
    Returns:
    
    the random 2D point.
    
    Throws:
    
    java.lang.RuntimeException - if minMax < 0.
  - generateRandomPoint2D
```
@Deprecated
public static Point2D generateRandomPoint2D(java.util.Random random,
                                                         double min,
                                                         double max)
```
    Deprecated. Use nextPoint2D(Random,double,double) instead
    
    Generates a random point.
    point.x ∈ [min; max].
    point.y ∈ [min; max].
    
    Parameters:
    
    random - the random generator to use.
    
    min - the minimum value for each coordinate.
    
    max - the maximum value for each coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if min > max.
  - nextPoint2D
```
public static Point2D nextPoint2D(java.util.Random random,
                                  double min,
                                  double max)
```
    Generates a random point.
    point.x ∈ [min; max].
    point.y ∈ [min; max].
    
    Parameters:
    
    random - the random generator to use.
    
    min - the minimum value for each coordinate.
    
    max - the maximum value for each coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if min > max.
  - generateRandomPoint2D
```
@Deprecated
public static Point2D generateRandomPoint2D(java.util.Random random,
                                                         double minX,
                                                         double maxX,
                                                         double minY,
                                                         double maxY)
```
    Deprecated. Use nextPoint2D(Random,double,double,double,double) instead
    
    Generates a random point.
    point.x ∈ [minX; maxX].
    point.y ∈ [minY; maxY].
    
    Parameters:
    
    random - the random generator to use.
    
    minX - the minimum value for the x-coordinate.
    
    maxX - the maximum value for the x-coordinate.
    
    minY - the minimum value for the y-coordinate.
    
    maxY - the maximum value for the y-coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if minX > maxX or minY > maxY.
  - nextPoint2D
```
public static Point2D nextPoint2D(java.util.Random random,
                                  double minX,
                                  double maxX,
                                  double minY,
                                  double maxY)
```
    Generates a random point.
    point.x ∈ [minX; maxX].
    point.y ∈ [minY; maxY].
    
    Parameters:
    
    random - the random generator to use.
    
    minX - the minimum value for the x-coordinate.
    
    maxX - the maximum value for the x-coordinate.
    
    minY - the minimum value for the y-coordinate.
    
    maxY - the maximum value for the y-coordinate.
    
    Returns:
    
    the random point.
    
    Throws:
    
    java.lang.RuntimeException - if minX > maxX or minY > maxY.
  - generateRandomVector2D
```
@Deprecated
public static Vector2D generateRandomVector2D(java.util.Random random)
```
    Deprecated. Use nextVector2D(Random) instead
    
    Generates a random 2D vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 2D vector.
  - nextVector2D
```
public static Vector2D nextVector2D(java.util.Random random)
```
    Generates a random 2D vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 2D vector.
  - generateRandomVector2D
```
@Deprecated
public static Vector2D generateRandomVector2D(java.util.Random random,
                                                           double min,
                                                           double max)
```
    Deprecated. Use nextVector2D(Random,double,double) instead
    
    Generates a random vector.
    vector_i ∈ [min; max].
    
    Parameters:
    
    random - the random generator to use.
    
    min - upper-bound for each component of the generated vector. Not modified.
    
    max - lower-bound for each component of the generated vector. Not modified.
    
    Returns:
    
    the random vector.
    
    Throws:
    
    java.lang.RuntimeException - if min > max.
  - nextVector2D
```
public static Vector2D nextVector2D(java.util.Random random,
                                    double min,
                                    double max)
```
    Generates a random vector.
    vector_i ∈ [min; max].
    
    Parameters:
    
    random - the random generator to use.
    
    min - upper-bound for each component of the generated vector. Not modified.
    
    max - lower-bound for each component of the generated vector. Not modified.
    
    Returns:
    
    the random vector.
    
    Throws:
    
    java.lang.RuntimeException - if min > max.
  - generateRandomVector2DWithFixedLength
```
@Deprecated
public static Vector2D generateRandomVector2DWithFixedLength(java.util.Random random,
                                                                          double length)
```
    Deprecated. Use nextVector2DWithFixedLength(Random,double) instead
    
    Generates a random 2D vector given its length length.
    
    Parameters:
    
    random - the random generator to use.
    
    length - the length of the generated 2D vector.
    
    Returns:
    
    the random 2D vector.
  - nextVector2DWithFixedLength
```
public static Vector2D nextVector2DWithFixedLength(java.util.Random random,
                                                   double length)
```
    Generates a random 2D vector given its length length.
    
    Parameters:
    
    random - the random generator to use.
    
    length - the length of the generated 2D vector.
    
    Returns:
    
    the random 2D vector.
  - generateRandomVector2D
```
@Deprecated
public static Vector2D generateRandomVector2D(java.util.Random random,
                                                           Tuple2DReadOnly minMax)
```
    Deprecated. Use nextVector2D(Random,Tuple2DReadOnly) instead
    
    Generates a random 2D vector.
    vector_i ∈ [-minMax_i; minMax_i].
    
    Parameters:
    
    random - the random generator to use.
    
    minMax - tuple used to bound the maximum absolute value of each component of the generated 2D vector. Not modified.
    
    Returns:
    
    the random 2D vector.
    
    Throws:
    
    java.lang.RuntimeException - if any component of minMax is negative.
  - nextVector2D
```
public static Vector2D nextVector2D(java.util.Random random,
                                    Tuple2DReadOnly minMax)
```
    Generates a random 2D vector.
    vector_i ∈ [-minMax_i; minMax_i].
    
    Parameters:
    
    random - the random generator to use.
    
    minMax - tuple used to bound the maximum absolute value of each component of the generated 2D vector. Not modified.
    
    Returns:
    
    the random 2D vector.
    
    Throws:
    
    java.lang.RuntimeException - if any component of minMax is negative.
  - generateRandomVector2D
```
@Deprecated
public static Vector2D generateRandomVector2D(java.util.Random random,
                                                           Tuple2DReadOnly min,
                                                           Tuple2DReadOnly max)
```
    Deprecated. Use nextVector2D(Random,Tuple2DReadOnly,Tuple2DReadOnly) instead
    
    Generates a random 2D vector.
    vector_i ∈ [min_i; max_i].
    
    Parameters:
    
    random - the random generator to use.
    
    min - tuple used as upper-bound for each component of the generated 2D vector. Not modified.
    
    max - tuple used as lower-bound for each component of the generated 2D vector. Not modified.
    
    Returns:
    
    the random 2D vector.
    
    Throws:
    
    java.lang.RuntimeException - if min_i > max_i.
  - nextVector2D
```
public static Vector2D nextVector2D(java.util.Random random,
                                    Tuple2DReadOnly min,
                                    Tuple2DReadOnly max)
```
    Generates a random 2D vector.
    vector_i ∈ [min_i; max_i].
    
    Parameters:
    
    random - the random generator to use.
    
    min - tuple used as upper-bound for each component of the generated 2D vector. Not modified.
    
    max - tuple used as lower-bound for each component of the generated 2D vector. Not modified.
    
    Returns:
    
    the random 2D vector.
    
    Throws:
    
    java.lang.RuntimeException - if min_i > max_i.
  - generateRandomVector4D
```
@Deprecated
public static Vector4D generateRandomVector4D(java.util.Random random)
```
    Deprecated. Use nextVector4D(Random) instead
    
    Generates a random 4D vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 4D vector.
  - nextVector4D
```
public static Vector4D nextVector4D(java.util.Random random)
```
    Generates a random 4D vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 4D vector.
  - generateRandomVector3D32
```
@Deprecated
public static Vector3D32 generateRandomVector3D32(java.util.Random random)
```
    Deprecated. Use nextVector3D32(Random) instead
    
    Generates a random vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random vector.
  - nextVector3D32
```
public static Vector3D32 nextVector3D32(java.util.Random random)
```
    Generates a random vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random vector.
  - generateRandomPoint3D32
```
@Deprecated
public static Point3D32 generateRandomPoint3D32(java.util.Random random)
```
    Deprecated. Use nextPoint3D32(Random) instead
    
    Generates a random point.
    point_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random point.
  - nextPoint3D32
```
public static Point3D32 nextPoint3D32(java.util.Random random)
```
    Generates a random point.
    point_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random point.
  - generateRandomVector2D32
```
@Deprecated
public static Vector2D32 generateRandomVector2D32(java.util.Random random)
```
    Deprecated. Use nextVector2D32(Random) instead
    
    Generates a random 2D vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 2D vector.
  - nextVector2D32
```
public static Vector2D32 nextVector2D32(java.util.Random random)
```
    Generates a random 2D vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 2D vector.
  - generateRandomPoint2D32
```
@Deprecated
public static Point2D32 generateRandomPoint2D32(java.util.Random random)
```
    Deprecated. Use nextPoint2D32(Random) instead
    
    Generates a random 2D point.
    point_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 2D point.
  - nextPoint2D32
```
public static Point2D32 nextPoint2D32(java.util.Random random)
```
    Generates a random 2D point.
    point_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 2D point.
  - generateRandomVector4D32
```
@Deprecated
public static Vector4D32 generateRandomVector4D32(java.util.Random random)
```
    Deprecated. Use nextVector4D32(Random) instead
    
    Generates a random 4D vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 4D vector.
  - nextVector4D32
```
public static Vector4D32 nextVector4D32(java.util.Random random)
```
    Generates a random 4D vector.
    vector_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    Returns:
    
    the random 4D vector.
  - randomizeAxisAngle
```
public static void randomizeAxisAngle(java.util.Random random,
                                      AxisAngleBasics axisAngleToRandomize)
```
    Randomizes the given axis-angle.
    axisAngle.getAngle() ∈ [-pi; pi].
    
    The approach used here generates uniformly a point on a sphere to create uniformly distributed random axes, see link. The angle is then generated as a normal bounded random double.
    
    Parameters:
    
    random - the random generator to use.
    
    axisAngleToRandomize - the axis-angle to randomize. Modified.
  - randomizeAxisAngle
```
public static void randomizeAxisAngle(java.util.Random random,
                                      double minMaxAngle,
                                      AxisAngleBasics axisAngleToRandomize)
```
    Randomizes the given axis-angle.
    axisAngle.getAngle() ∈ [-minMaxAngle; minMaxAngle].
    
    The approach used here generates uniformly a point on a sphere to create uniformly distributed random axes, see link. The angle is then generated as a normal bounded random double.
    
    Parameters:
    
    random - the random generator to use.
    
    minMaxAngle - the maximum absolute angle value.
    
    axisAngleToRandomize - the axis-angle to randomize. Modified.
    
    Throws:
    
    java.lang.RuntimeException - if minMaxAngle < 0.
  - randomizeTuple3D
```
public static void randomizeTuple3D(java.util.Random random,
                                    Tuple3DBasics tupleToRandomize)
```
    Randomizes a tuple.
    tuple_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    tupleToRandomize - the tuple to randomize. Modified.
  - randomizeTuple3D
```
public static void randomizeTuple3D(java.util.Random random,
                                    Tuple3DReadOnly minMax,
                                    Tuple3DBasics tupleToRandomize)
```
    Randomizes a tuple.
    tuple_i ∈ [-minMax_i; minMax_i].
    
    Parameters:
    
    random - the random generator to use.
    
    minMax - tuple used to bound the maximum absolute value of each component of the generated vector. Not modified.
    
    tupleToRandomize - the tuple to randomize. Modified.
    
    Throws:
    
    java.lang.RuntimeException - if any component of minMax is negative.
  - randomizeTuple3D
```
public static void randomizeTuple3D(java.util.Random random,
                                    Tuple3DReadOnly min,
                                    Tuple3DReadOnly max,
                                    Tuple3DBasics tupleToRandomize)
```
    Randomizes a tuple.
    vector_i ∈ [min_i; max_i].
    
    Parameters:
    
    random - the random generator to use.
    
    min - tuple used as upper-bound for each component of the generated vector. Not modified.
    
    max - tuple used as lower-bound for each component of the generated vector. Not modified.
    
    tupleToRandomize - the tuple to randomize. Modified.
    
    Throws:
    
    java.lang.RuntimeException - if min_i > max_i.
  - randomizeTuple2D
```
public static void randomizeTuple2D(java.util.Random random,
                                    Tuple2DBasics tupleToRandomize)
```
    Randomizes a 2D tuple.
    tuple_i ∈ [-1.0; 1.0].
    
    Parameters:
    
    random - the random generator to use.
    
    tupleToRandomize - the 2D tuple to randomize. Modified.
  - randomizeTuple2D
```
public static void randomizeTuple2D(java.util.Random random,
                                    Tuple2DReadOnly minMax,
                                    Tuple2DBasics tupleToRandomize)
```
    Randomizes a 2D tuple.
    tuple_i ∈ [-minMax_i; minMax_i].
    
    Parameters:
    
    random - the random generator to use.
    
    minMax - tuple used to bound the maximum absolute value of each component of the generated vector. Not modified.
    
    tupleToRandomize - the 2D tuple to randomize. Modified.
    
    Throws:
    
    java.lang.RuntimeException - if any component of minMax is negative.
  - randomizeTuple2D
```
public static void randomizeTuple2D(java.util.Random random,
                                    Tuple2DReadOnly min,
                                    Tuple2DReadOnly max,
                                    Tuple2DBasics tupleToRandomize)
```
    Randomizes a 2D tuple.
    vector_i ∈ [min_i; max_i].
    
    Parameters:
    
    random - the random generator to use.
    
    min - tuple used as upper-bound for each component of the generated vector. Not modified.
    
    max - tuple used as lower-bound for each component of the generated vector. Not modified.
    
    tupleToRandomize - the 2D tuple to randomize. Modified.
    
    Throws:
    
    java.lang.RuntimeException - if min_i > max_i.

Class EuclidCoreRandomTools

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

EuclidCoreRandomTools

Method Detail

generateRandomYawPitchRoll

nextYawPitchRoll

generateRandomYawPitchRoll

nextYawPitchRoll

generateRandomRotationVector

nextRotationVector

generateRandomRotationVector

nextRotationVector

generateRandomAxisAngle

nextAxisAngle

generateRandomAxisAngle

nextAxisAngle

generateRandomAxisAngle32

nextAxisAngle32

generateRandomAxisAngle32

nextAxisAngle32

generateRandomDiagonalMatrix3D

nextDiagonalMatrix3D

generateRandomDiagonalMatrix3D

nextDiagonalMatrix3D

generateRandomDiagonalMatrix3D

nextDiagonalMatrix3D

generateRandomDouble

nextDouble

generateRandomDouble

nextDouble

generateRandomDouble

nextDouble

generateRandomMatrix3D

nextMatrix3D

generateRandomMatrix3D

nextMatrix3D

generateRandomMatrix3D

nextMatrix3D

generateRandomQuaternion

nextQuaternion

generateRandomQuaternion

nextQuaternion

generateRandomQuaternion32

nextQuaternion32

generateRandomQuaternion32

nextQuaternion32

generateRandomRigidBodyTransform

nextRigidBodyTransform

generateRandomRigidBodyTransform2D

nextRigidBodyTransform2D

generateRandomQuaternionBasedTransform

nextQuaternionBasedTransform

generateRandomAffineTransform

nextAffineTransform

generateRandomRotationMatrix

nextRotationMatrix

generateRandomRotationMatrix

nextRotationMatrix

generateRandomRotationScaleMatrix

nextRotationScaleMatrix

generateRandomRotationScaleMatrix

nextRotationScaleMatrix

generateRandomPoint3D

nextPoint3D

generateRandomPoint3D

nextPoint3D

generateRandomPoint3D

nextPoint3D

generateRandomPoint3D

nextPoint3D

generateRandomPoint3D

nextPoint3D

generateRandomVector3D

nextVector3D

generateRandomVector3D

nextVector3D

generateRandomVector3D