/// <summary>
/// Returns a Quaterniond from component-wise application of Lerp (min * (1-a) + max * a).
/// </summary>
public static Quaterniond Lerp(double min, double max, Quaterniond a)
{
return(new Quaterniond(min * (1 - a.x) + max * a.x, min * (1 - a.y) + max * a.y, min * (1 - a.z) + max * a.z, min * (1 - a.w) + max * a.w));
}
/// <summary>
/// Returns a Quaterniond from component-wise application of Lerp (min * (1-a) + max * a).
/// </summary>
public static Quaterniond Lerp(Quaterniond min, double max, double a)
{
return(new Quaterniond(min.x * (1 - a) + max * a, min.y * (1 - a) + max * a, min.z * (1 - a) + max * a, min.w * (1 - a) + max * a));
}
/// <summary>
/// Returns a Quaterniond from component-wise application of Lerp (min * (1-a) + max * a).
/// </summary>
public static Quaterniond Lerp(double min, Quaterniond max, double a)
{
return(new Quaterniond(min * (1 - a) + max.x * a, min * (1 - a) + max.y * a, min * (1 - a) + max.z * a, min * (1 - a) + max.w * a));
}
/// <summary>
/// Applies squad interpolation of these quaternions
/// </summary>
public static Quaterniond Squad(Quaterniond q1, Quaterniond q2, Quaterniond s1, Quaterniond s2, double h)
{
return(Mix(Mix(q1, q2, h), Mix(s1, s2, h), 2 * (1 - h) * h));
}
/// <summary>
/// Returns a Quaterniond from component-wise application of Lerp (min * (1-a) + max * a).
/// </summary>
public static Quaterniond Lerp(Quaterniond min, Quaterniond max, Quaterniond a)
{
return(new Quaterniond(min.x * (1 - a.x) + max.x * a.x, min.y * (1 - a.y) + max.y * a.y, min.z * (1 - a.z) + max.z * a.z, min.w * (1 - a.w) + max.w * a.w));
}
/// <summary>
/// Returns the cross product between two quaternions.
/// </summary>
public static Quaterniond Cross(Quaterniond q1, Quaterniond q2)
{
return(new Quaterniond(q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y, q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z, q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x, q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z));
}
/// <summary>
/// Returns the inner product (dot product, scalar product) of the two quaternions.
/// </summary>
public static double Dot(Quaterniond lhs, Quaterniond rhs)
{
return((lhs.x * rhs.x + lhs.y * rhs.y) + (lhs.z * rhs.z + lhs.w * rhs.w));
}
/// <summary>
/// Tries to convert the string representation of the quaternion into a quaternion representation (using a designated separator and a number style and a format provider), returns false if string was invalid.
/// </summary>
public static bool TryParse(string s, string sep, NumberStyles style, IFormatProvider provider, out Quaterniond result)
{
result = Zero;
if (string.IsNullOrEmpty(s))
{
return(false);
}
var kvp = s.Split(new[] { sep }, StringSplitOptions.None);
if (kvp.Length != 4)
{
return(false);
}
double x = 0.0, y = 0.0, z = 0.0, w = 0.0;
var ok = ((double.TryParse(kvp[0].Trim(), style, provider, out x) && double.TryParse(kvp[1].Trim(), style, provider, out y)) && (double.TryParse(kvp[2].Trim(), style, provider, out z) && double.TryParse(kvp[3].Trim(), style, provider, out w)));
result = ok ? new Quaterniond(x, y, z, w) : Zero;
return(ok);
}
/// <summary>
/// Tries to convert the string representation of the quaternion into a quaternion representation (using ', ' as a separator), returns false if string was invalid.
/// </summary>
public static bool TryParse(string s, out Quaterniond result)
{
return(TryParse(s, ", ", out result));
}
/// <summary>
/// Returns true iff this equals rhs component-wise.
/// </summary>
public bool Equals(Quaterniond rhs)
{
return((x.Equals(rhs.x) && y.Equals(rhs.y)) && (z.Equals(rhs.z) && w.Equals(rhs.w)));
}
