AngleTools (patrimoine de base SIRIUS 4.13 API)

java.lang.Object
- fr.cnes.sirius.patrius.math.interval.AngleTools

```
public final class AngleTools
extends Object
```
This class provides static methods for angles :

- angles computation,

- comparison,

- arithmetic and trigonometric operations.

Since:

1.0

Version:

$Id: AngleTools.java 18021 2017-09-29 15:56:26Z bignon $

Author:

Julie Anton, Thomas Trapier

Use sample :

- In order to compute the angle between two vectors :

double angle = AngleTools.getAngleBewteen2Vector3D(vector1, vector2);

- To compute the angle 2PI modulo in the given interval : (can throw a MathIllegalArgumentException)

double res = AngleTools.angleInInterval(angle, angleInterval);

- To compare two angles in a given interval : (can throw a MathIllegalArgumentException)

boolean isEqual = AngleTools.equal(angle1, angle2, angleInterval);

- To compute the complementary angle in a given interval : (can throw a MathIllegalArgumentException)

double res = AngleTools.complementaryAngle(angle, angleInterval);
See DV-MATHS_60, 70, 80, 90, 100 .

Concurrency :

unconditionally thread-safe

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`angleInInterval(double angle, AngleInterval interval)` Computes the angle in the given interval modulo 2pi.
`static double`	`complementaryAngle(double angle, AngleInterval interval)` Computes the complementary (PI/2 - angle) of the input angle, and then tries to express it in the input interval.
`static boolean`	`equal(double alpha, double beta, AngleInterval interval)` Tests the equality of two angles after expressing them in the same interval.
`static double`	`getAngleBewteen2Vector3D(Vector3D vector1, Vector3D vector2)` Computes the angle between 2 vectors 3D.
`static double`	`getAngleFromCosineAndSine(double cos, double sin)` Computes an angle from the sine and the cosine
`static double`	`getOrientedAngleBetween2Vector2D(Vector2D vector1, Vector2D vector2)` Computes the oriented angle between 2 vectors 2D.
`static double`	`getOrientedAngleBewteen2Vector3D(Vector3D vector1, Vector3D vector2, Vector3D vector3)` Computes the oriented angle between 2 vectors 3D.
`static boolean`	`greaterOrEqual(double alpha, double beta, AngleInterval interval)` Tests if one angle is greater or equal to another after expressing them in the same interval.
`static boolean`	`greaterStrict(double alpha, double beta, AngleInterval interval)` Tests if one angle is strictly greater than another after expressing them in the same interval.
`static boolean`	`lowerOrEqual(double alpha, double beta, AngleInterval interval)` Tests if one angle is lower or equal to another after expressing them in the same interval.
`static boolean`	`lowerStrict(double alpha, double beta, AngleInterval interval)` Tests if one angle is strictly lower than another after expressing them in the same interval.
`static double`	`meanAngle(double... angles)` Computes the mean of two circular quantities or angles.
`static double`	`modulo(double value, double moduloMax)` Compute the modulo value
`static List<Double>`	`modulo(List<Double> values, double moduloMax)` Compute the modulo for all elements of a list
`static double`	`moduloTwoPi(double value)` Compute the modulo 2PI value
`static double`	`oppositeAngle(double angle, AngleInterval interval)` Computes the opposite of the input angle, and then tries to express it in the input interval.
`static double`	`supplementaryAngle(double angle, AngleInterval interval)` Computes the supplementary (PI - angle) of the input angle, and then tries to express it in the input interval.
`static void`	`unMod(List<Double> y)` Make angular data continuous by removing modulo every time a jump larger than pi is detected
`static void`	`unMod(List<Double> y, double a)` Make angular data continuous by removing modulo every time a jump larger than pi is detected
`static void`	`unMod(List<Double> x, List<Double> y, double a, double slope)` Make angular data continuous by removing modulo every time a jump larger than pi is detected

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

- Method Detail
  - getAngleBewteen2Vector3D
```
public static double getAngleBewteen2Vector3D(Vector3D vector1,
                                              Vector3D vector2)
```
    Computes the angle between 2 vectors 3D. To do so, we use the method angle(Vector3D, Vector3D) of Vector3D .
    
    Parameters:
    
    vector1 - the first vector
    
    vector2 - the second vector
    
    Returns:
    
    double angle = the positive value of the angle between the two vectors, the angle is defined between 0 and PI. See DV-MATHS_100
    
    Since:
    
    1.0
    
    See Also:
    
    Vector3D.angle(Vector3D, Vector3D)
    
    Preconditions :
    
    either the first vector or the second one should have non zero norm.
  - getOrientedAngleBetween2Vector2D
```
public static double getOrientedAngleBetween2Vector2D(Vector2D vector1,
                                                      Vector2D vector2)
```
    Computes the oriented angle between 2 vectors 2D.
    
    Parameters:
    
    vector1 - the first vector
    
    vector2 - the second vector
    
    Returns:
    
    double angle = the value of the oriented angle between the two vectors, the angle is defined between -2 PI and 2 PI. See DV-MATHS_100 .
    
    Throws:
    
    MathIllegalArgumentException - if at least one norm is zero
    
    MathIllegalArgumentException - if at least one norm is infinity
    
    Since:
    
    1.0
    
    Preconditions :
    
    either the first vector or the second one should have finite coordinate values and non zero norm.
  - getOrientedAngleBewteen2Vector3D
```
public static double getOrientedAngleBewteen2Vector3D(Vector3D vector1,
                                                      Vector3D vector2,
                                                      Vector3D vector3)
```
    Computes the oriented angle between 2 vectors 3D.
    
    Parameters:
    
    vector1 - the first vector
    
    vector2 - the second vector
    
    vector3 - the third vector which defines the orientation
    
    Returns:
    
    double angle = the value of the oriented angle between the two vectors, the angle is defined between -PI and PI. See DV-MATHS_100 .
    
    Throws:
    
    IllegalArgumentException - if the cross product is wrong
    
    Since:
    
    1.0
    
    Preconditions :
    
    either the first vector or the second one or the third one should have non zero norm. The third vector should be perpendicular to the plane formed by the formers.
  - getAngleFromCosineAndSine
```
public static double getAngleFromCosineAndSine(double cos,
                                               double sin)
```
    Computes an angle from the sine and the cosine
    
    Parameters:
    
    cos - : the cosine of the angle we want to know the value
    
    sin - : the sine of the angle we want to know the value
    
    Returns:
    
    double angle = the angle given by sine and cosine between -PI and PI See DV-MATHS_100 .
    
    Since:
    
    1.0
    
    Preconditions :
    
    the sine and the cosine should be of the same angle ie cos²+sin² is lower than 1.
  - angleInInterval
```
public static double angleInInterval(double angle,
                                     AngleInterval interval)
```
    Computes the angle in the given interval modulo 2pi. There are particular cases : numerical quality issue solving in the following cases : - the interval is of the form [a, a + 2PI[ If angle is lower than lower bound and angle + 2Pi larger than higher bound : lower bound is returned - the interval is of the form ]a, a + 2PI] If angle is larger than larger bound and angle - 2Pi lower than lower bound : larger bound is returned These cases occur because of the non-identical repartition of doubles around the two interval boundaries.
    
    Parameters:
    
    angle - angle to be expressed inside the given interval
    
    interval - interval of expression
    
    Returns:
    
    the angle expressed in the interval
    
    Throws:
    
    MathIllegalArgumentException - the angle is'nt in the interval modulo 2PI
    
    Since:
    
    1.0
    
    Preconditions :
    
    the interval can represent the given angle ([0, pi[ doesn't contain -pi/2 modulo 2pi)
  - equal
```
public static boolean equal(double alpha,
                            double beta,
                            AngleInterval interval)
```
    Tests the equality of two angles after expressing them in the same interval.
    
    Parameters:
    
    alpha - one angle
    
    beta - one angle
    
    interval - the interval to express the angles
    
    Returns:
    
    boolean : true if equal
    
    Throws:
    
    MathIllegalArgumentException - if one angle is'nt in the interval, modulo 2PI
    
    Since:
    
    1.0
    
    Preconditions :
    
    both angles must be in the given interval modulo 2PI
  - lowerOrEqual
```
public static boolean lowerOrEqual(double alpha,
                                   double beta,
                                   AngleInterval interval)
```
    Tests if one angle is lower or equal to another after expressing them in the same interval.
    
    Parameters:
    
    alpha - one angle
    
    beta - one angle
    
    interval - the interval to express the angles
    
    Returns:
    
    boolean : true if lower or equal
    
    Throws:
    
    MathIllegalArgumentException - if one angle is'nt in the interval, modulo 2PI
    
    Since:
    
    1.0
    
    Preconditions :
    
    both angles must be in the given interval modulo 2PI
  - lowerStrict
```
public static boolean lowerStrict(double alpha,
                                  double beta,
                                  AngleInterval interval)
```
    Tests if one angle is strictly lower than another after expressing them in the same interval.
    
    Parameters:
    
    alpha - : one angle
    
    beta - : one angle
    
    interval - the interval to express the angles
    
    Returns:
    
    boolean : true if lower
    
    Throws:
    
    MathIllegalArgumentException - if one angle is'nt in the interval, modulo 2PI
    
    Since:
    
    1.0
    
    Preconditions :
    
    both angles must be in the given interval modulo 2PI
  - greaterOrEqual
```
public static boolean greaterOrEqual(double alpha,
                                     double beta,
                                     AngleInterval interval)
```
    Tests if one angle is greater or equal to another after expressing them in the same interval.
    
    Parameters:
    
    alpha - : one angle
    
    beta - : one angle
    
    interval - the interval to express the angles
    
    Returns:
    
    boolean : true is greater or equal
    
    Throws:
    
    MathIllegalArgumentException - if one angle is'nt in the interval, modulo 2PI
    
    Since:
    
    1.0
    
    Preconditions :
    
    both angles must be in the given interval modulo 2PI
  - greaterStrict
```
public static boolean greaterStrict(double alpha,
                                    double beta,
                                    AngleInterval interval)
```
    Tests if one angle is strictly greater than another after expressing them in the same interval.
    
    Parameters:
    
    alpha - : one angle
    
    beta - : one angle
    
    interval - the interval to express the angles
    
    Returns:
    
    boolean : true is greater
    
    Throws:
    
    MathIllegalArgumentException - if one angle is'nt in the interval, modulo 2PI
    
    Since:
    
    1.0
    
    Preconditions :
    
    both angles must be in the given interval modulo 2PI
  - supplementaryAngle
```
public static double supplementaryAngle(double angle,
                                        AngleInterval interval)
```
    Computes the supplementary (PI - angle) of the input angle, and then tries to express it in the input interval.
    
    Parameters:
    
    angle - the angle to get the supplementary
    
    interval - the interval to express the result
    
    Returns:
    
    double : supplementary angle
    
    Throws:
    
    MathIllegalArgumentException - if the resulting angle is'nt in the interval, modulo 2PI See DV-MATHS_80 .
    
    Since:
    
    1.0
  - complementaryAngle
```
public static double complementaryAngle(double angle,
                                        AngleInterval interval)
```
    Computes the complementary (PI/2 - angle) of the input angle, and then tries to express it in the input interval.
    
    Parameters:
    
    angle - the angle to get the complementary
    
    interval - the interval to express the result
    
    Returns:
    
    double : complementary angle
    
    Throws:
    
    MathIllegalArgumentException - if the resulting angle is'nt in the interval, modulo 2PI See DV-MATHS_80 .
    
    Since:
    
    1.0
  - oppositeAngle
```
public static double oppositeAngle(double angle,
                                   AngleInterval interval)
```
    Computes the opposite of the input angle, and then tries to express it in the input interval.
    
    Parameters:
    
    angle - the angle to get the complementary
    
    interval - the interval to express the result
    
    Returns:
    
    double : opposite angle
    
    Throws:
    
    MathIllegalArgumentException - if the resulting angle is'nt in the interval, modulo 2PI See DV-MATHS_80 .
    
    Since:
    
    1.0
  - meanAngle
```
public static double meanAngle(double... angles)
```
    Computes the mean of two circular quantities or angles. Returned value is in [0 ; 2*PI[.
    For the case of more than two input angles, since the arithmetic mean is not appropriate for circular quantities due to angular wrapping, the angles are converted to their corresponding points on the unit circle, i.e. converting its polar coordinates to cartesian, and then computing the arithmetic mean of those two points.
    Note: Results produced by this computation may seem counterintuitive since they are different from what would be obtained using a standard arithmetic mean of the values, with this difference being greater when the angles are widely distributed.
    
    Parameters:
    
    angles - set of input angles [rad]
    
    Returns:
    
    mean angular value
  - modulo
```
public static double modulo(double value,
                            double moduloMax)
```
    Compute the modulo value
    
    Parameters:
    
    value - input value
    
    moduloMax - maximum value
    
    Returns:
    
    the modulo value in [0 ; moduloMax[
  - moduloTwoPi
```
public static double moduloTwoPi(double value)
```
    Compute the modulo 2PI value
    
    Parameters:
    
    value - input value
    
    Returns:
    
    the modulo value in [0 ; 2PI[
  - modulo
```
public static List<Double> modulo(List<Double> values,
                                  double moduloMax)
```
    Compute the modulo for all elements of a list
    
    Parameters:
    
    values - input list
    
    moduloMax - maximum value
    
    Returns:
    
    the list of modulo values in [0 ; moduloMax[
  - unMod
```
public static void unMod(List<Double> y,
                         double a)
```
    Make angular data continuous by removing modulo every time a jump larger than pi is detected
    A user-input shift is added when necessary when a jump is detected. Warning: This function is not valid if the "distance" between 2 points is larger than a/2, in which case function #unMod(double[], double[], double, double) shall be used.
    
    Parameters:
    
    y - Array of data to be unmod
    
    a - Size of jump to be corrected (the absolute value will be always used)
  - unMod
```
public static void unMod(List<Double> y)
```
    Make angular data continuous by removing modulo every time a jump larger than pi is detected
    A two-pi shift is added when necessary when a jump is detected. Warning: This function is not valid if the "distance" between 2 points is larger than pi, in which case function #unMod(double[], double[], double, double) shall be used.
    
    Parameters:
    
    y - Array of data to be unmod
  - unMod
```
public static void unMod(List<Double> x,
                         List<Double> y,
                         double a,
                         double slope)
```
    Make angular data continuous by removing modulo every time a jump larger than pi is detected
    A user-input shift is added when necessary when a jump is detected. This function is valid even if the "distance" between two point is larger than a/2. In that case the approximate slope shall be provided to enable reconstruction by the algorithm.
    
    Parameters:
    
    x - Array of abscissas
    
    y - Array of ordinates
    
    a - Size of jump to be corrected (the absolute value will be always used)
    
    slope - Approximate value of dy/dx

Class AngleTools

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getAngleBewteen2Vector3D

getOrientedAngleBetween2Vector2D

getOrientedAngleBewteen2Vector3D

getAngleFromCosineAndSine

angleInInterval

equal

lowerOrEqual

lowerStrict

greaterOrEqual

greaterStrict

supplementaryAngle

complementaryAngle

oppositeAngle

meanAngle

modulo

moduloTwoPi

modulo

unMod

unMod

unMod