/// <summary>
/// Returns a vector with near-zero vector components clamped to 0.
/// </summary>
/// <param name="vector">The vector.</param>
/// <param name="epsilon">The tolerance value.</param>
/// <returns>The vector with small components clamped to zero.</returns>
/// <remarks>
/// Each vector component (X, Y and Z) is compared to zero. If the component is in the interval
/// [-<paramref name="epsilon"/>, +<paramref name="epsilon"/>] it is set to zero, otherwise it
/// remains unchanged.
/// </remarks>
public static Vector3 ClampToZero(Vector3 vector, float epsilon)
{
vector.X = Numeric.ClampToZero(vector.X, epsilon);
vector.Y = Numeric.ClampToZero(vector.Y, epsilon);
vector.Z = Numeric.ClampToZero(vector.Z, epsilon);
return(vector);
}
/// <summary>
/// Returns a vector with near-zero vector components clamped to 0.
/// </summary>
/// <param name="vector">The vector.</param>
/// <returns>The vector with small components clamped to zero.</returns>
/// <remarks>
/// Each vector component (X, Y and Z) is compared to zero. If the component is in the interval
/// [-<see cref="Numeric.EpsilonF"/>, +<see cref="Numeric.EpsilonF"/>] it is set to zero,
/// otherwise it remains unchanged.
/// </remarks>
public static Vector3 ClampToZero(Vector3 vector)
{
vector.X = Numeric.ClampToZero(vector.X);
vector.Y = Numeric.ClampToZero(vector.Y);
vector.Z = Numeric.ClampToZero(vector.Z);
return(vector);
}
/// <summary>
/// Returns a matrix with the matrix elements clamped to the range [min, max].
/// </summary>
/// <param name="matrix">The matrix.</param>
/// <param name="epsilon">The tolerance value.</param>
/// <returns>The matrix with small elements clamped to zero.</returns>
/// <remarks>
/// Each matrix element is compared to zero. If it is in the interval
/// [-<paramref name="epsilon"/>, +<paramref name="epsilon"/>] it is set to zero, otherwise it
/// remains unchanged.
/// </remarks>
public static Matrix22F ClampToZero(Matrix22F matrix, float epsilon)
{
matrix.M00 = Numeric.ClampToZero(matrix.M00, epsilon);
matrix.M01 = Numeric.ClampToZero(matrix.M01, epsilon);
matrix.M10 = Numeric.ClampToZero(matrix.M10, epsilon);
matrix.M11 = Numeric.ClampToZero(matrix.M11, epsilon);
return(matrix);
}
/// <summary>
/// Returns a matrix with the matrix elements clamped to the range [min, max].
/// </summary>
/// <param name="matrix">The matrix.</param>
/// <returns>The matrix with small elements clamped to zero.</returns>
/// <remarks>
/// Each matrix element is compared to zero. If it is in the interval
/// [-<see cref="Numeric.EpsilonF"/>, +<see cref="Numeric.EpsilonF"/>] it is set to zero,
/// otherwise it remains unchanged.
/// </remarks>
public static Matrix22F ClampToZero(Matrix22F matrix)
{
matrix.M00 = Numeric.ClampToZero(matrix.M00);
matrix.M01 = Numeric.ClampToZero(matrix.M01);
matrix.M10 = Numeric.ClampToZero(matrix.M10);
matrix.M11 = Numeric.ClampToZero(matrix.M11);
return(matrix);
}
/// <summary>
/// Returns a matrix with the matrix elements clamped to the range [min, max].
/// </summary>
/// <param name="matrix">The matrix.</param>
/// <param name="epsilon">The tolerance value.</param>
/// <returns>The matrix with small elements clamped to zero.</returns>
/// <remarks>
/// Each matrix element is compared to zero. If it is in the interval
/// [-<paramref name="epsilon"/>, +<paramref name="epsilon"/>] it is set to zero, otherwise it
/// remains unchanged.
/// </remarks>
public static Matrix22D ClampToZero(Matrix22D matrix, double epsilon)
{
matrix.M00 = Numeric.ClampToZero(matrix.M00, epsilon);
matrix.M01 = Numeric.ClampToZero(matrix.M01, epsilon);
matrix.M10 = Numeric.ClampToZero(matrix.M10, epsilon);
matrix.M11 = Numeric.ClampToZero(matrix.M11, epsilon);
return(matrix);
}
public void ClampToZeroD()
{
Assert.AreEqual(1d, Numeric.ClampToZero(1d));
Assert.AreEqual(-1d, Numeric.ClampToZero(-1d));
Assert.AreEqual(0d, Numeric.ClampToZero(0d));
Assert.AreEqual(Numeric.EpsilonD + 0.0001d, Numeric.ClampToZero(Numeric.EpsilonD + 0.0001d));
Assert.AreEqual(-Numeric.EpsilonD - 0.0001d, Numeric.ClampToZero(-Numeric.EpsilonD - 0.0001d));
Assert.AreEqual(0, Numeric.ClampToZero(Numeric.EpsilonD - 0.000000000001d));
Assert.AreEqual(0, Numeric.ClampToZero(-Numeric.EpsilonD + 0.000000000001d));
Assert.AreEqual(1d, Numeric.ClampToZero(1d, 0.1d));
Assert.AreEqual(-1d, Numeric.ClampToZero(-1d, 0.1d));
Assert.AreEqual(0d, Numeric.ClampToZero(0d, 0.1d));
Assert.AreEqual(0.11d, Numeric.ClampToZero(0.11d, 0.1d));
Assert.AreEqual(-0.11d, Numeric.ClampToZero(-0.11d, 0.1d));
Assert.AreEqual(0, Numeric.ClampToZero(0.09d, 0.1d));
Assert.AreEqual(0, Numeric.ClampToZero(-0.09d, 0.1d));
}
public void ClampToZeroF()
{
Assert.AreEqual(1f, Numeric.ClampToZero(1f));
Assert.AreEqual(-1f, Numeric.ClampToZero(-1f));
Assert.AreEqual(0f, Numeric.ClampToZero(0f));
Assert.AreEqual(Numeric.EpsilonF + 0.0001f, Numeric.ClampToZero(Numeric.EpsilonF + 0.0001f));
Assert.AreEqual(-Numeric.EpsilonF - 0.0001f, Numeric.ClampToZero(-Numeric.EpsilonF - 0.0001f));
Assert.AreEqual(0, Numeric.ClampToZero(Numeric.EpsilonF - 0.000000001f));
Assert.AreEqual(0, Numeric.ClampToZero(-Numeric.EpsilonF + 0.000000001f));
Assert.AreEqual(1f, Numeric.ClampToZero(1f, 0.1f));
Assert.AreEqual(-1f, Numeric.ClampToZero(-1f, 0.1f));
Assert.AreEqual(0f, Numeric.ClampToZero(0f, 0.1f));
Assert.AreEqual(0.11f, Numeric.ClampToZero(0.11f, 0.1f));
Assert.AreEqual(-0.11f, Numeric.ClampToZero(-0.11f, 0.1f));
Assert.AreEqual(0, Numeric.ClampToZero(0.09f, 0.1f));
Assert.AreEqual(0, Numeric.ClampToZero(-0.09f, 0.1f));
}
/// <summary>
/// Clamps near-zero matrix elements to zero.
/// </summary>
/// <param name="epsilon">The tolerance value.</param>
/// <remarks>
/// Each matrix element is compared to zero. If the element is in the interval
/// [-<paramref name="epsilon"/>, +<paramref name="epsilon"/>] it is set to zero, otherwise it
/// remains unchanged.
/// </remarks>
public void ClampToZero(float epsilon)
{
M00 = Numeric.ClampToZero(M00, epsilon); M01 = Numeric.ClampToZero(M01, epsilon);
M10 = Numeric.ClampToZero(M10, epsilon); M11 = Numeric.ClampToZero(M11, epsilon);
}
/// <overloads>
/// <summary>
/// Clamps near-zero matrix elements to zero.
/// </summary>
/// </overloads>
///
/// <summary>
/// Clamps near-zero matrix elements to zero.
/// </summary>
/// <remarks>
/// Each matrix element is compared to zero. If the element is in the interval
/// [-<see cref="Numeric.EpsilonF"/>, +<see cref="Numeric.EpsilonF"/>] it is set to zero,
/// otherwise it remains unchanged.
/// </remarks>
public void ClampToZero()
{
M00 = Numeric.ClampToZero(M00); M01 = Numeric.ClampToZero(M01);
M10 = Numeric.ClampToZero(M10); M11 = Numeric.ClampToZero(M11);
}
/// <summary>
/// Clamps near-zero vector components to zero.
/// </summary>
/// <param name="epsilon">The tolerance value.</param>
/// <remarks>
/// Each vector component (X and Y) is compared to zero. If the component is in the interval
/// [-<paramref name="epsilon"/>, +<paramref name="epsilon"/>] it is set to zero, otherwise it
/// remains unchanged.
/// </remarks>
public void ClampToZero(float epsilon)
{
X = Numeric.ClampToZero(X, epsilon);
Y = Numeric.ClampToZero(Y, epsilon);
}
/// <overloads>
/// <summary>
/// Clamps near-zero vector components to zero.
/// </summary>
/// </overloads>
///
/// <summary>
/// Clamps near-zero vector components to zero.
/// </summary>
/// <remarks>
/// Each vector component (X and Y) is compared to zero. If the component is in the interval
/// [-<see cref="Numeric.EpsilonF"/>, +<see cref="Numeric.EpsilonF"/>] it is set to zero,
/// otherwise it remains unchanged.
/// </remarks>
public void ClampToZero()
{
X = Numeric.ClampToZero(X);
Y = Numeric.ClampToZero(Y);
}
/// <summary>
/// Returns a vector with near-zero vector components clamped to 0.
/// </summary>
/// <param name="vector">The vector.</param>
/// <param name="epsilon">The tolerance value.</param>
/// <returns>The vector with small components clamped to zero.</returns>
/// <remarks>
/// Each vector component (X and Y) is compared to zero. If the component is in the interval
/// [-<paramref name="epsilon"/>, +<paramref name="epsilon"/>] it is set to zero, otherwise it
/// remains unchanged.
/// </remarks>
public static Vector2D ClampToZero(Vector2D vector, double epsilon)
{
vector.X = Numeric.ClampToZero(vector.X, epsilon);
vector.Y = Numeric.ClampToZero(vector.Y, epsilon);
return(vector);
}
/// <summary>
/// Clamps near-zero vector components to zero.
/// </summary>
/// <param name="epsilon">The tolerance value.</param>
/// <remarks>
/// Each vector component (X and Y) is compared to zero. If the component is in the interval
/// [-<paramref name="epsilon"/>, +<paramref name="epsilon"/>] it is set to zero, otherwise it
/// remains unchanged.
/// </remarks>
public void ClampToZero(double epsilon)
{
X = Numeric.ClampToZero(X, epsilon);
Y = Numeric.ClampToZero(Y, epsilon);
}
