/// <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); }