/// <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); }