/// <summary>
/// Divides rotation by scalar value.
/// </summary>
public static Rot2d operator /(Rot2d rot, double val)
{
return(Rot2d.Divide(rot, val));
}
/// <summary>
/// Transforms a position vector.
/// </summary>
public V2d InvTransformPos(V2d v)
{
return(Rot2d.InvTransformPos(this, v));
}
/// <summary>
/// </summary>
public static M34d operator *(Rot2d rot, Shift3d shift)
{
return(Rot2d.Multiply(rot, shift));
}
/// <summary>
/// Subtracts rotation from a scalar.
/// </summary>
public static Rot2d Subtract(double angle, Rot2d rot)
{
return(new Rot2d(angle - rot.Angle));
}
public static M22d Multiply(Rot2d rot, M22d mat)
{
return((M22d)rot * mat);
}
/// <summary>
/// Adds 2 rotations.
/// </summary>
public static Rot2d Add(Rot2d r0, Rot2d r1)
{
return(new Rot2d(r0.Angle + r1.Angle));
}
/// <summary>
/// Subtracts 2 rotations.
/// </summary>
public static Rot2d Subtract(Rot2d r0, Rot2d r1)
{
return(new Rot2d(r0.Angle - r1.Angle));
}
/// <summary>
/// Subtracts a rotation from a scalar value.
/// </summary>
public static Rot2d operator -(double angle, Rot2d rot)
{
return(Rot2d.Subtract(angle, rot));
}
/// <summary>
/// Multiplies rotation with scalar value.
/// </summary>
public static Rot2d operator *(double val, Rot2d rot)
{
return(Rot2d.Multiply(rot, val));
}
/// <summary>
/// Subtracts 2 rotations.
/// </summary>
public static Rot2d operator -(Rot2d r0, Rot2d r1)
{
return(Rot2d.Subtract(r0, r1));
}
/// <summary>
/// Subtracts a rotation from a scalar value.
/// </summary>
public static Rot2d operator -(Rot2d rot, double angle)
{
return(Rot2d.Subtract(rot, angle));
}
/// <summary>
/// Adds a rotation and a scalar value.
/// </summary>
public static Rot2d operator +(double angle, Rot2d rot)
{
return(Rot2d.Add(rot, angle));
}
/// <summary>
/// Adds 2 rotations.
/// </summary>
public static Rot2d operator +(Rot2d r0, Rot2d r1)
{
return(Rot2d.Add(r0, r1));
}
/// <summary>
/// Negates the rotation.
/// </summary>
public static Rot2d operator -(Rot2d rot)
{
return(Rot2d.Negate(rot));
}
public static bool ApproxEqual(Rot2d r0, Rot2d r1)
{
return(ApproxEqual(r0, r1, Constant <double> .PositiveTinyValue));
}
/// <summary>
/// </summary>
public static V4d operator *(Rot2d rot, V4d vec)
{
return(Rot2d.Multiply(rot, vec));
}
// [todo ISSUE 20090225 andi : andi] Wir sollten auch folgendes ber�cksichtigen -q == q, weil es die selbe rotation definiert.
// [todo ISSUE 20090427 andi : andi] use an angle-tolerance
// [todo ISSUE 20090427 andi : andi] add Rot3d.ApproxEqual(Rot3d other);
public static bool ApproxEqual(Rot2d r0, Rot2d r1, double tolerance)
{
return((r0.Angle - r1.Angle).Abs() <= tolerance);
}
/// <summary>
/// </summary>
public static M44d operator *(Rot2d rot, M44d mat)
{
return(Rot2d.Multiply(rot, mat));
}
/// <summary>
/// Adds scalar to a rotation.
/// </summary>
public static Rot2d Add(Rot2d rot, double val)
{
return(new Rot2d(rot.Angle + val));
}
/// <summary>
/// </summary>
public static M33d operator *(Rot2d rot2, Rot3d rot3)
{
return(Rot2d.Multiply(rot2, rot3));
}
/// <summary>
/// Subtracts scalar from a rotation.
/// </summary>
public static Rot2d Subtract(Rot2d rot, double angle)
{
return(new Rot2d(rot.Angle - angle));
}
/// <summary>
/// </summary>
public static Rot2d operator *(Rot2d r0, Rot2d r1)
{
return(Rot2d.Multiply(r0, r1));
}
/// <summary>
/// Multiplies scalar with a rotation.
/// </summary>
public static Rot2d Multiply(Rot2d rot, double val)
{
return(new Rot2d(rot.Angle * val));
}
/// <summary>
/// </summary>
public static M33d operator *(Rot2d rot, Scale3d scale)
{
return(Rot2d.Multiply(rot, scale));
}
public static M33d Multiply(Rot2d rot2, Rot3d rot3)
{
return(Rot2d.Multiply(rot2, (M33d)rot3));
}
/// <summary>
/// Transforms a direction vector.
/// </summary>
public V2d InvTransformDir(V2d v)
{
return(Rot2d.InvTransformDir(this, v));
}
