/// <summary>
/// 将本数和另一个数取绝对值进行比较，大于输出1，小于输出-1，等于输出0
/// </summary>
/// <param name="num"></param>
/// <returns></returns>
public override int CompareAbsolute(Digitable num)
{
IntegerNum a = this, b = num as IntegerNum;
if (ReferenceEquals(a, b))
{
return(0);
}
if (a == null || b == null)
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.IllegalValue);
}
//统一计算空间
if (a.Space != b.Space)
{
if (a.Space == OperationSpace.DefaultSpace)
{
a = (IntegerNum)a.ChangeOperationSpace(b.Space);
}
else if (b.Space == OperationSpace.DefaultSpace)
{
b = (IntegerNum)b.ChangeOperationSpace(a.Space);
}
else
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.NotSameOperationSpace);
}
}
return(a.numerator.CompareAbsolute(b.numerator));
}
/// <summary>
/// 按位取模运算（不考虑正负号）
/// </summary>
/// <param name="num">模数</param>
/// <param name="maxDecimalPlaces">答案保留小数位数</param>
/// <returns>包含余数和商的元组</returns>
protected override (Digitable, Digitable) Mod_unsigned(Digitable num, int maxDecimalPlaces)
{
RationalNum a = this, b = num as RationalNum;
if (a == null || b == null)
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.IllegalValue);
}
//统一计算空间
if (a.Space != b.Space)
{
if (a.Space == OperationSpace.DefaultSpace)
{
a = (RationalNum)a.ChangeOperationSpace(b.Space);
}
else if (b.Space == OperationSpace.DefaultSpace)
{
b = (RationalNum)b.ChangeOperationSpace(a.Space);
}
else
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.NotSameOperationSpace);
}
}
var ans = new RationalNum(a, b, 1, a.Space);
ans.GetMixedNumber(out var i, out var n);
return(new RationalNum(n * b.numerator, ans.denominator * b.denominator, 1, a.Space, maxDecimalPlaces),
i);
}
/// <summary>
/// 乘方运算
/// </summary>
/// <param name="a">底数</param>
/// <param name="b">指数</param>
/// <param name="maxDecimalPlaces">答案保留小数位数</param>
/// <returns>幂</returns>
public static Digitable Power(Digitable a, Digitable b, int?maxDecimalPlaces = null)
{
if (a == null || b == null)
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.IllegalValue);
}
var maxDP = maxDecimalPlaces ?? (a.Space == OperationSpace.DefaultSpace ? b.Space.DefaultMaxDecimalPlaces : a.Space.DefaultMaxDecimalPlaces);
var ans = a.Power_unsigned(b, maxDP);
if (a.PositiveOrNegative > 0)
{
ans.PositiveOrNegative = 1;
}
else if (a.PositiveOrNegative < 0)
{
if (b.IsInteger)
{
ans.PositiveOrNegative = b.IsOdd ? -1 : 1;
}
else
{
throw new IllegalOperationException();
}
}
else
{
ans.PositiveOrNegative = 0;
}
return(ans);
}
/// <summary>
/// 按位乘法运算（不考虑正负号）
/// </summary>
/// <param name="num">乘数</param>
/// <param name="maxDecimalPlaces">答案保留小数位数</param>
/// <returns></returns>
protected override Digitable Multiply_unsigned(Digitable num, int maxDecimalPlaces)
{
IntegerNum a = this, b = num as IntegerNum;
if (a == null || b == null)
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.IllegalValue);
}
//统一计算空间
if (a.Space != b.Space)
{
if (a.Space == OperationSpace.DefaultSpace)
{
a = (IntegerNum)a.ChangeOperationSpace(b.Space);
}
else if (b.Space == OperationSpace.DefaultSpace)
{
b = (IntegerNum)b.ChangeOperationSpace(a.Space);
}
else
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.NotSameOperationSpace);
}
}
return(new IntegerNum(a.numerator * b.numerator, 1, a.Space));
}
/// <summary>
/// 将本数和另一个数取绝对值进行比较，大于输出1，小于输出-1，等于输出0
/// </summary>
/// <param name="num"></param>
/// <returns></returns>
public override int CompareAbsolute(Digitable num)
{
RationalNum a = this, b = num as RationalNum;
if (ReferenceEquals(a, b))
{
return(0);
}
if (a == null || b == null)
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.IllegalValue);
}
//统一计算空间
if (a.Space != b.Space)
{
if (a.Space == OperationSpace.DefaultSpace)
{
a = (RationalNum)a.ChangeOperationSpace(b.Space);
}
else if (b.Space == OperationSpace.DefaultSpace)
{
b = (RationalNum)b.ChangeOperationSpace(a.Space);
}
else
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.NotSameOperationSpace);
}
}
//通分
ReductionToACommonDenominator(out var d, out var nums, a, b);
return(nums[0].CompareAbsolute(nums[1]));
}
public override NumStr GetValue()
{
if (valueChanged)
{
value = Digitable.Divide(numerator, denominator, MaxDecimalPlaces) as NumStr;
valueChanged = false;
}
return(value);
}
/// <summary>
/// 自然对数运算
/// </summary>
/// <param name="a">真数</param>
/// <param name="maxDecimalPlaces">答案保留小数位数</param>
/// <returns>幂</returns>
public static Digitable Ln(Digitable a, int?maxDecimalPlaces = null)
{
if (a == null)
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.IllegalValue);
}
var maxDP = maxDecimalPlaces ?? a.Space.DefaultMaxDecimalPlaces;
var ans = a.Ln(maxDP);
return(ans);
}
/// <summary>
/// 除法运算
/// </summary>
/// <param name="a">被除数</param>
/// <param name="b">除数</param>
/// <param name="maxDecimalPlaces">答案保留小数位数</param>
/// <returns>商</returns>
public static Digitable Divide(Digitable a, Digitable b, int?maxDecimalPlaces = null)
{
if (a == null || b == null)
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.IllegalValue);
}
var maxDP = maxDecimalPlaces ?? (a.Space == OperationSpace.DefaultSpace ? b.Space.DefaultMaxDecimalPlaces : a.Space.DefaultMaxDecimalPlaces);
var ans = a.Divide_unsigned(b, maxDP);
ans.PositiveOrNegative = a.PositiveOrNegative / b.PositiveOrNegative;
return(ans);
}
/// <summary>
/// 减法运算
/// </summary>
/// <param name="a">被减数</param>
/// <param name="b">减数</param>
/// <param name="maxDecimalPlaces">答案保留小数位数</param>
/// <returns>差</returns>
public static Digitable Minus(Digitable a, Digitable b, int?maxDecimalPlaces = null)
{
if (a == null || b == null)
{
throw new ProgramInterruptException(ProgramInterruptExceptionType.IllegalValue);
}
var maxDP = maxDecimalPlaces ?? (a.Space == OperationSpace.DefaultSpace ? b.Space.DefaultMaxDecimalPlaces : a.Space.DefaultMaxDecimalPlaces);
//根据正负性来重定向
if (a.IsPositive && b.IsNegative)
{
return(a.Plus_unsigned(b, maxDP));
}
else if (a.IsNegative && b.IsPositive)
{
var ans = a.Plus_unsigned(b, maxDP);
ans.PositiveOrNegative = -1;
return(ans);
}
else if (a.IsNegative && b.IsNegative)
{
var ans = b.Minus_unsigned(a, maxDP, out bool hasSwaped);
ans.PositiveOrNegative = hasSwaped ? -1 : (ans.IsEmpty() ? 0 : 1);
return(ans);
}
else if (a.IsZero)
{
var ans = b.Copy();
ans.PositiveOrNegative = -b.PositiveOrNegative;
ans.MaxDecimalPlaces = maxDP;
return(ans);
}
else if (b.IsZero)
{
var ans = a.Copy();
ans.MaxDecimalPlaces = maxDP;
return(ans);
}
else
{
var ans = a.Minus_unsigned(b, maxDP, out bool hasSwaped);
ans.PositiveOrNegative = hasSwaped ? -1 : (ans.IsEmpty() ? 0 : 1);
return(ans);
}
}
/// <summary>
/// 按位减法运算（不考虑正负号）
/// </summary>
/// <param name="num">减数</param>
/// <param name="maxDecimalPlaces">答案保留小数位数</param>
/// <param name="hasSwaped">是否发生参数交换</param>
/// <returns></returns>
protected virtual Digitable Minus_unsigned(Digitable num, int maxDecimalPlaces, out bool hasSwaped)
{
throw new NotImplementedException();
}
/// <summary>
/// 按位除法运算（不考虑正负号）
/// </summary>
/// <param name="num">除数</param>
/// <param name="maxDecimalPlaces">答案保留小数位数</param>
/// <returns></returns>
protected virtual Digitable Divide_unsigned(Digitable num, int maxDecimalPlaces)
{
throw new NotImplementedException();
}
/// <summary>
/// 取模运算
/// </summary>
/// <param name="a">被模数</param>
/// <param name="b">模数</param>
/// <param name="maxDecimalPlaces">答案保留小数位数</param>
/// <returns>包含余数和商的元组</returns>
public static (RationalNum, IntegerNum) Mod(RationalNum a, RationalNum b, int?maxDecimalPlaces = null)
{
var ans = Digitable.Mod(a, b, maxDecimalPlaces);
return(ans.Item1 as RationalNum, ans.Item2 as IntegerNum);
}
