/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public double Clamp(double t) { if (IsDecreasing) { return(SlurMath.Clamp(t, B, A)); } else { return(SlurMath.Clamp(t, A, B)); } }
/// <summary> /// /// </summary> /// <param name="color"></param> /// <returns></returns> public static Vec3d LABtoLCH(Vec3d color) { double l = color.X; double a = color.Y; double b = color.Z; double c = Math.Sqrt(a * a + b * b); double h = Math.Atan2(b, a); h = (h > 0.0) ? SlurMath.ToDegrees(h) : SlurMath.ToDegrees(360.0 - Math.Abs(h)); return(new Vec3d(l, c, h)); }
/// <summary> /// Shifts a subset of a list of items in place. /// </summary> public static void Shift <T>(this IList <T> list, int offset, int from, int to) { if (list is T[]) { ArrayExtensions.Shift((T[])list, offset, from, to); return; } offset = SlurMath.Mod2(offset, to - from + 1); Reverse(list, from, from + offset - 1); Reverse(list, from + offset, to); Reverse(list, from, to); }
/// <summary> /// /// </summary> /// <param name="other"></param> /// <param name="tolerance"></param> /// <returns></returns> public bool ApproxEquals(ref Matrix3d other, double tolerance = SlurMath.ZeroTolerance) { return (SlurMath.ApproxEquals(M00, other.M00, tolerance) && SlurMath.ApproxEquals(M01, other.M01, tolerance) && SlurMath.ApproxEquals(M02, other.M02, tolerance) && SlurMath.ApproxEquals(M10, other.M10, tolerance) && SlurMath.ApproxEquals(M11, other.M11, tolerance) && SlurMath.ApproxEquals(M12, other.M12, tolerance) && SlurMath.ApproxEquals(M20, other.M20, tolerance) && SlurMath.ApproxEquals(M21, other.M21, tolerance) && SlurMath.ApproxEquals(M22, other.M22, tolerance)); }
/// <summary> /// /// </summary> public static double Lerp(this double[] vector, double t) { int last = vector.Length - 1; t = SlurMath.Fract(t * last, out int i); if (i < 0) { return(vector[0]); } else if (i >= last) { return(vector[last]); } return(SlurMath.Lerp(vector[i], vector[i + 1], t)); }
/// <summary> /// /// </summary> public static double Lerp(this IReadOnlyList <double> vector, double factor) { int last = vector.Count - 1; factor = SlurMath.Fract(factor * last, out int i); if (i < 0) { return(vector[0]); } else if (i >= last) { return(vector[last]); } return(SlurMath.Lerp(vector[i], vector[i + 1], factor)); }
/// <summary> /// /// </summary> public static void Lerp(this Vec3d[][] vectors, double[] t, int size, Vec3d[] result) { int last = vectors.Length - 1; for (int j = 0; j < size; j++) { double tj = SlurMath.Fract(t[j] * last, out int i); if (i < 0) { result[j] = vectors[0][j]; } else if (i >= last) { result[j] = vectors[last][j]; } else { result[j] = Vec3d.Lerp(vectors[i][j], vectors[i + 1][j], tj); } } }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public double Nearest(double t) { return(SlurMath.Nearest(t, T0, T1)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <exception cref="DivideByZeroException"> /// thrown if the domain is invalid </exception> public double Normalize(double t) { return(SlurMath.Normalize(t, T0, T1)); }
/// <summary> /// /// </summary> /// <param name="t"></param> public float Evaluate(float t) { return(SlurMath.Lerp(A, B, t)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public float SmootherStep(float t) { return(SlurMath.SmootherStep(t, A, B)); }
/// <summary> /// /// </summary> /// <param name="t"></param> public double Evaluate(double t) { return(SlurMath.Lerp(A, B, t)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public double Wrap(double t) { return(SlurMath.Wrap(t, T0, T1)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public float Normalize(float t) { return(SlurMath.Normalize(t, A, B)); }
/// <summary> /// Converts from euclidean to spherical coordiantes. /// (x,y,z) = (radius, azimuth, polar) /// </summary> /// <returns></returns> public Vec3d ToSpherical() { double r = Length; return(new Vec3d(r, Math.Atan(Y / X), SlurMath.AcosSafe(Z / r))); }
/// <summary> /// Returns the minimum angle between two vectors. /// </summary> /// <param name="v0"></param> /// <param name="v1"></param> /// <returns></returns> public static double Angle(Vec3d v0, Vec3d v1) { var d = v0.SquareLength * v1.SquareLength; return(d > 0.0 ? SlurMath.AcosSafe(Dot(v0, v1) / Math.Sqrt(d)) : 0.0); }
/// <summary> /// /// </summary> /// <param name="other"></param> /// <param name="tolerance"></param> /// <returns></returns> public bool ApproxEquals(Vec2d other, Vec2d tolerance) { return (SlurMath.ApproxEquals(X, other.X, tolerance.X) && SlurMath.ApproxEquals(Y, other.Y, tolerance.Y)); }
/// <summary> /// /// </summary> /// <param name="other"></param> /// <param name="tolerance"></param> /// <returns></returns> public bool ApproxEquals(Vec2d other, double tolerance = SlurMath.ZeroTolerance) { return (SlurMath.ApproxEquals(X, other.X, tolerance) && SlurMath.ApproxEquals(Y, other.Y, tolerance)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public float Nearest(float t) { return(SlurMath.Nearest(t, A, B)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public double Ramp(double t) { return(SlurMath.Ramp(t, T0, T1)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public double SmoothStep(double t) { return(SlurMath.SmoothStep(t, T0, T1)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public double Nearest(double t) { return(SlurMath.Nearest(t, A, B)); }
/// <summary> /// /// </summary> public bool IsUnit(double tolerance = SlurMath.ZeroTolerance) { return(SlurMath.ApproxEquals(SquareLength, 1.0, tolerance)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public double SmootherStep(double t) { return(SlurMath.SmootherStep(t, A, B)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public double Normalize(double t) { return(SlurMath.Normalize(t, A, B)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public float Ramp(float t) { return(SlurMath.Ramp(t, A, B)); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public double Ramp(double t) { return(SlurMath.Ramp(t, A, B)); }
/// <summary> /// Returns a random vector which has components within the given interval. /// </summary> /// <param name="random"></param> /// <param name="t0"></param> /// <param name="t1"></param> /// <returns></returns> public static Vec2d NextVec2d(this Random random, double t0, double t1) { return(new Vec2d( SlurMath.Lerp(t0, t1, random.NextDouble()), SlurMath.Lerp(t0, t1, random.NextDouble()))); }
/// <summary> /// /// </summary> /// <param name="t"></param> /// <returns></returns> public double Wrap(double t) { return(SlurMath.Wrap(t, A, B)); }
/// <summary> /// /// </summary> /// <param name="other"></param> /// <param name="tolerance"></param> /// <returns></returns> public bool ApproxEquals(Intervald other, double tolerance = SlurMath.ZeroTolerance) { return (SlurMath.ApproxEquals(A, other.A, tolerance) && SlurMath.ApproxEquals(B, other.B, tolerance)); }