public static DeterministicFloat PIOver180F = PI / (DeterministicFloat)180; //PI / 180
#endregion
#region Sqrt
public static DeterministicFloat Sqrt(DeterministicFloat f, int NumberOfIterations)
{
if (f.RawValue < 0) //NaN in Math.Sqrt
{
throw new ArithmeticException("Input Error");
}
if (f.RawValue == 0)
{
return((DeterministicFloat)0);
}
DeterministicFloat k = f + DeterministicFloat.OneF >> 1;
for (int i = 0; i < NumberOfIterations; i++)
{
k = (k + (f / k)) >> 1;
}
if (k.RawValue < 0)
{
throw new ArithmeticException("Overflow");
}
else
{
return(k);
}
}
public static DeterministicFloat Atan2(DeterministicFloat F1, DeterministicFloat F2)
{
if (F2.RawValue == 0 && F1.RawValue == 0)
{
return((DeterministicFloat)0);
}
DeterministicFloat result = (DeterministicFloat)0;
if (F2 > 0)
{
result = Atan(F1 / F2);
}
else if (F2 < 0)
{
if (F1 >= 0)
{
result = (PI - Atan(Abs(F1 / F2)));
}
else
{
result = (PI - Atan(Abs(F1 / F2))).Inverse;
}
}
else
{
result = (F1 >= 0 ? PI : PI.Inverse) / new DeterministicFloat(2, true);
}
return(result);
}
public static DeterministicFloat Min(DeterministicFloat x1, DeterministicFloat x2)
{
if (x2 < x1)
{
return(x2);
}
return(x1);
}
public static DeterministicFloat Max(DeterministicFloat x1, DeterministicFloat x2)
{
if (x1 < x2)
{
return(x2);
}
return(x1);
}
public static DeterministicFloat Abs(DeterministicFloat F)
{
if (F < 0)
{
return(F.Inverse);
}
return(F);
}
/// <summary>
/// Create a fixed-int number from parts. For example, to create 1.5 pass in 1 and 500.
/// </summary>
/// <param name="PreDecimal">The number above the decimal. For 1.5, this would be 1.</param>
/// <param name="PostDecimal">The number below the decimal, to three digits.
/// For 1.5, this would be 500. For 1.005, this would be 5.</param>
/// <returns>A fixed-int representation of the number parts</returns>
public static DeterministicFloat FromParts(int PreDecimal, int PostDecimal)
{
DeterministicFloat f = new DeterministicFloat(PreDecimal);
if (PostDecimal != 0)
{
f.RawValue += (new DeterministicFloat(PostDecimal) / 1000).RawValue;
}
return(f);
}
private static DeterministicFloat sin_lookup(DeterministicFloat i, DeterministicFloat j)
{
if (j > 0 && j < new DeterministicFloat(10, false) && i < new DeterministicFloat(90, false))
{
return(new DeterministicFloat(SIN_TABLE[i.RawValue], false) +
((new DeterministicFloat(SIN_TABLE[i.RawValue + 1], false) - new DeterministicFloat(SIN_TABLE[i.RawValue], false)) /
new DeterministicFloat(10, false)) * j);
}
else
{
return(new DeterministicFloat(SIN_TABLE[i.RawValue], false));
}
}
public static DeterministicFloat Sqrt(DeterministicFloat f)
{
byte numberOfIterations = 8;
if (f.RawValue > 0x64000)
{
numberOfIterations = 12;
}
if (f.RawValue > 0x3e8000)
{
numberOfIterations = 16;
}
return(Sqrt(f, numberOfIterations));
}
public static DeterministicFloat Asin(DeterministicFloat f)
{
bool isNegative = f < 0;
f = Abs(f);
if (f > DeterministicFloat.OneF)
{
throw new ArithmeticException("Bad Asin Input:" + f.ToDouble());
}
DeterministicFloat f1 = mul(mul(mul(mul(new DeterministicFloat(145103 >> DeterministicFloat.SHIFT_AMOUNT, false), f) -
new DeterministicFloat(599880 >> DeterministicFloat.SHIFT_AMOUNT, false), f) +
new DeterministicFloat(1420468 >> DeterministicFloat.SHIFT_AMOUNT, false), f) -
new DeterministicFloat(3592413 >> DeterministicFloat.SHIFT_AMOUNT, false), f) +
new DeterministicFloat(26353447 >> DeterministicFloat.SHIFT_AMOUNT, false);
DeterministicFloat f2 = PI / new DeterministicFloat(2, true) - (Sqrt(DeterministicFloat.OneF - f) * f1);
return(isNegative ? f2.Inverse : f2);
}
public static DeterministicFloat Sin(DeterministicFloat i)
{
DeterministicFloat j = (DeterministicFloat)0;
for (; i < 0; i += new DeterministicFloat(25736, false))
{
;
}
if (i > new DeterministicFloat(25736, false))
{
i %= new DeterministicFloat(25736, false);
}
DeterministicFloat k = (i * new DeterministicFloat(10, false)) / new DeterministicFloat(714, false);
if (i != 0 && i != new DeterministicFloat(6434, false) && i != new DeterministicFloat(12868, false) &&
i != new DeterministicFloat(19302, false) && i != new DeterministicFloat(25736, false))
{
j = (i * new DeterministicFloat(100, false)) / new DeterministicFloat(714, false) - k * new DeterministicFloat(10, false);
}
if (k <= new DeterministicFloat(90, false))
{
return(sin_lookup(k, j));
}
if (k <= new DeterministicFloat(180, false))
{
return(sin_lookup(new DeterministicFloat(180, false) - k, j));
}
if (k <= new DeterministicFloat(270, false))
{
return(sin_lookup(k - new DeterministicFloat(180, false), j).Inverse);
}
else
{
return(sin_lookup(new DeterministicFloat(360, false) - k, j).Inverse);
}
}
public static DeterministicFloat Atan(DeterministicFloat F)
{
return(Asin(F / Sqrt(DeterministicFloat.OneF + (F * F))));
}
public static DeterministicFloat Acos(DeterministicFloat f)
{
return(Asin(f) * -1 + HalfPIF);
}
public static DeterministicFloat Tan(DeterministicFloat i)
{
return(Sin(i) / Cos(i));
}
public static DeterministicFloat Cos(DeterministicFloat i)
{
return(Sin(i + new DeterministicFloat(6435, false)));
}
private static DeterministicFloat mul(DeterministicFloat F1, DeterministicFloat F2)
{
return(F1 * F2);
}
