/// <summary>
/// 取不超过x的最大整数
/// <para>若x的绝对值大于int的最大表示范围，返回0</para>
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public static int floor(SKSpecialDecimal x)
{
if (abs(x).compare_to(SKSpecialDecimal.INT_MAX) > 0)
{
return(0);
}
int ret = 0;
if (x.get_exp() > -1)
{
for (int i = x.get_exp(); i > -1; i--)
{
ret += (int)Math.Round(x[x.get_exp() - i] * Math.Pow(10, i));
}
if (!x.get_positive())
{
ret = ret * -1 - 1;
}
}
else if (!x.get_positive())
{
ret = -1;
}
return(ret);
}
/// <summary>
/// 乘上一个一位数，未考虑精度取舍问题
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
private static SKSpecialDecimal mul_single(SKSpecialDecimal _a, byte b)
{
SKSpecialDecimal a = new SKSpecialDecimal(_a);
if (b > 9)
{
throw new Exception("必须是一位数啊！");
}
if (a.get_digit() == 0 || a.is_zero() || b == 1)
{
return(new SKSpecialDecimal(a));
}
else if (b == 0)
{
return(new SKSpecialDecimal(0));
}
SKSpecialDecimal ret = new SKSpecialDecimal();
byte carry = 0;
for (int i = a.get_digit() - 1; i > -1; i--)
{
byte tmp = (byte)(a[i] * b + carry);
ret[i + 1] = (byte)(tmp % 10);
carry = (byte)(tmp / 10);
}
ret[0] = carry;
ret.fix();
if (!ret.is_zero())
{
ret.exp_10 = (carry == 0) ? a.get_exp() : (a.get_exp() + 1);
}
return(ret);
}
/// <summary>
/// 减法，有效位数与加法类似，取决于绝对误差最大的数
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static SKSpecialDecimal operator -(SKSpecialDecimal a, SKSpecialDecimal b)
{
SKSpecialDecimal b_copy = new SKSpecialDecimal(b);
b_copy.inverse();
return(a + b_copy);
}
/// <summary>
/// 返回幂次值，仅支持整数次幂
/// </summary>
/// <param name="x"></param>
/// <param name="a"></param>
/// <returns></returns>
public static SKSpecialDecimal pow(SKSpecialDecimal x, int a)
{
if (a == 0)
{
return(new SKSpecialDecimal(1, x.get_digit()));
}
else if (a == 1)
{
return(new SKSpecialDecimal(x));
}
else if (a == 2)
{
return(x * x);
}
else if (a < 0)
{
return((new SKSpecialDecimal(1, x.get_digit())) / pow(x, -1 * a));
}
else
{
if (a % 2 == 0)
{
return(pow(x, a / 2) * pow(x, a / 2));
}
else
{
return(pow(x, a / 2) * pow(x, a / 2) * x);
}
}
}
/// <summary>
/// 加法，有效位数取决于绝对误差最大的数
/// <para>例：1.001+100.1=101.1</para>
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static SKSpecialDecimal operator +(SKSpecialDecimal a, SKSpecialDecimal b)
{
if (a.is_zero())
{
return(new SKSpecialDecimal(b));
}
else if (b.is_zero())
{
return(new SKSpecialDecimal(a));
}
SKSpecialDecimal a_copy = new SKSpecialDecimal(a);
SKSpecialDecimal b_copy = new SKSpecialDecimal(b);
//越小越精确，表示末位所在的位置
SKSpecialDecimal ret = add(a_copy, b_copy);
if (CUT_IN_OPERATOR)
{
int a_min_bit = a_copy.exp_10 - a_copy.get_digit() + 1;
int b_min_bit = b_copy.exp_10 - b_copy.get_digit() + 1;
int ret_min_bit = ret.exp_10 - ret.get_digit() + 1;
if (a_min_bit > b_min_bit)//以a的精度为准
{
ret.cut(ret.get_digit() - a_min_bit + ret_min_bit);
}
else//以b的精度为准
{
ret.cut(ret.get_digit() - b_min_bit + ret_min_bit);
}
}
return(ret);
}
/// <summary>
/// 返回绝对值
/// </summary>
/// <param name="a"></param>
/// <returns></returns>
public static SKSpecialDecimal abs(SKSpecialDecimal a)
{
SKSpecialDecimal a_abs = new SKSpecialDecimal(a);
a_abs.positive = true;
return(a_abs);
}
/// <summary>
/// 用指定的高精度数初始化自己
/// </summary>
/// <param name="another"></param>
public void reset(SKSpecialDecimal another)
{
clear();
foreach (byte tmp in another.data)
{
data.Add(tmp);
}
positive = another.positive;
exp_10 = another.exp_10;
}
/// <summary>
/// 返回与另外某数的比较（不考虑精度）
/// <para>若大于该数，返回1，相等则返回0，否则返回-1</para>
/// <para>若某数不存在位数（有效位数为0），返回0</para>
/// <para>当且仅当有效位数、各位数及符号位全部一致时，才判定相等</para>
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public int compare_to(SKSpecialDecimal x)
{
if (get_digit() == 0 || x.get_digit() == 0)
{
return(0);
}
if (positive && (!x.positive))
{
return(1);
}
else if ((!positive) && x.positive)
{
return(-1);
}
if (get_exp() > x.get_exp())
{
return((positive) ? 1 : -1);
}
else if (get_exp() < x.get_exp())
{
return((positive) ? -1 : 1);
}
for (int i = 0; i < Math.Min(get_digit(), x.get_digit()); i++)
{
if (this[i] > x[i])
{
return((positive) ? 1 : -1);
}
else if (this[i] < x[i])
{
return((positive) ? -1 : 1);
}
}
if (get_digit() > x.get_digit())//有效位数较多且不为零
{
for (int i = x.get_digit(); i < get_digit(); i++)
{
if (this[i] != (byte)0)
{
return((positive) ? 1 : -1);
}
}
}
else if (get_digit() < x.get_digit())
{
for (int i = get_digit(); i < x.get_digit(); i++)
{
if (x[i] != (byte)0)
{
return((positive) ? -1 : 1);
}
}
}
return(0);
}
/// <summary>
/// 除法，结果的有效位数与两数有效位数较少的数相同
/// </summary>
/// <param name="a">除数</param>
/// <param name="b">被除数</param>
/// <returns></returns>
public static SKSpecialDecimal operator /(SKSpecialDecimal a, SKSpecialDecimal b)
{
if (a.get_digit() == 0 || b.get_digit() == 0)
{
return(new SKSpecialDecimal());
}
int less = Math.Min(a.get_digit(), b.get_digit());
SKSpecialDecimal ret = div(a, b);
if (CUT_IN_OPERATOR)
{
ret.cut(less);
}
return(ret);
}
/// <summary>
/// 在(x-1)位处发生进位，同时截取x位有效数字
/// </summary>
/// <param name="x"></param>
private void upgrade(int x)
{
if (x < 2)
{
return;
}
data.RemoveRange(x, data.Count - x);
SKSpecialDecimal _tmp = new SKSpecialDecimal(this);
SKSpecialDecimal _add = new SKSpecialDecimal();
_add[x - 1] = 1;
_add.exp_10 = _tmp.get_exp();
_tmp = add(_tmp, _add);
if (_tmp.get_digit() > get_digit()) //进位导致位数增加了
{
_tmp.cut(get_digit()); //本次cut一定不会导致进位了
}
reset(_tmp);
}
/// <summary>
/// 不考虑精度、误差情况下的乘法
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
private static SKSpecialDecimal mul(SKSpecialDecimal _a, SKSpecialDecimal _b)
{
SKSpecialDecimal a = new SKSpecialDecimal(_a);
SKSpecialDecimal b = new SKSpecialDecimal(_b);
if (a.get_digit() == 0)
{
return(new SKSpecialDecimal(b));
}
else if (b.get_digit() == 0)
{
return(new SKSpecialDecimal(a));
}
else if (a.is_zero() || b.is_zero())
{
return(new SKSpecialDecimal(0));
}
SKSpecialDecimal ret = new SKSpecialDecimal(0);
SKSpecialDecimal longer, shorter;
if (a.get_digit() > b.get_digit())
{
longer = a;
shorter = b;
}
else
{
longer = b;
shorter = a;
}
for (int i = 0; i < shorter.get_digit(); i++)
{
SKSpecialDecimal tmp = mul_single(longer, shorter[i]);
tmp.mul_10(shorter.get_exp() - i);
ret = add(ret, tmp);
}
ret.fix();
ret.positive = (a.get_positive() == b.get_positive());
return(ret);
}
/// <summary>
/// 不考虑精度、误差情况下的加法
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
private static SKSpecialDecimal add(SKSpecialDecimal _a, SKSpecialDecimal _b)
{
SKSpecialDecimal a = new SKSpecialDecimal(_a);
SKSpecialDecimal b = new SKSpecialDecimal(_b);
if (a.get_digit() == 0 || a.is_zero())
{
return(new SKSpecialDecimal(b));
}
else if (b.get_digit() == 0 || b.is_zero())
{
return(new SKSpecialDecimal(a));
}
SKSpecialDecimal ans = new SKSpecialDecimal();
int compare_abs = abs(a).compare_to(abs(b));
ans.exp_10 = Math.Max(a.get_exp(), b.get_exp()) + 1;
int up_range = ans.exp_10;
int down_range = Math.Min(a.get_exp() - a.get_digit(), b.get_exp() - b.get_digit()) + 1;
int range = up_range - down_range + 1;
int carry = 0;
if (a.positive == b.positive)
{
ans.positive = a.positive;
for (int i = range - 1; i > -1; i--)
{
byte tmp = (byte)((a[i - ans.get_exp() + a.get_exp()] + b[i - ans.get_exp() + b.get_exp()] + carry));
ans[i] = (byte)(tmp % 10);
if (tmp > 9)
{
carry = 1;
}
else
{
carry = 0;
}
}
}
else if (compare_abs == 0)
{
ans[0] = 0;
}
else
{
SKSpecialDecimal bigger, smaller;
if (compare_abs > 0)
{
ans.positive = a.positive;
bigger = a;
smaller = b;
}
else
{
ans.positive = b.positive;
bigger = b;
smaller = a;
}
for (int i = range - 1; i > -1; i--)
{
sbyte tmp = (sbyte)(((sbyte)bigger[i - ans.get_exp() + bigger.get_exp()] - (sbyte)smaller[i - ans.get_exp() + smaller.get_exp()] - carry));
ans[i] = (byte)((tmp + 10) % 10);
if (tmp < 0)
{
carry = 1;
}
else
{
carry = 0;
}
}
}
ans.fix();
return(ans);
}
/// <summary>
/// 除法，结果的有效位数与两数有效位数较少的数相同
/// </summary>
/// <param name="a">除数</param>
/// <param name="b">被除数</param>
/// <returns></returns>
public static SKSpecialDecimal operator /(int a, SKSpecialDecimal b)
{
SKSpecialDecimal aa = new SKSpecialDecimal(a);
return(aa / b);
}
/// <summary>
/// 除法，结果的有效位数与两数有效位数较少的数相同
/// </summary>
/// <param name="a">除数</param>
/// <param name="b">被除数</param>
/// <returns></returns>
public static SKSpecialDecimal operator /(SKSpecialDecimal a, int b)
{
SKSpecialDecimal bb = new SKSpecialDecimal(b);
return(a / bb);
}
/// <summary>
/// 乘法，结果的有效位数与两数有效位数较少的数相同
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static SKSpecialDecimal operator *(double a, SKSpecialDecimal b)
{
SKSpecialDecimal aa = new SKSpecialDecimal(a);
return(aa * b);
}
/// <summary>
/// 乘法，结果的有效位数与两数有效位数较少的数相同
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static SKSpecialDecimal operator *(SKSpecialDecimal a, double b)
{
SKSpecialDecimal bb = new SKSpecialDecimal(b);
return(a * bb);
}
/// <summary>
/// 用指定的高精度数初始化自己
/// </summary>
/// <param name="origin"></param>
public SKSpecialDecimal(SKSpecialDecimal origin)
{
reset(origin);
}
/// <summary>
/// 不考虑精度、误差情况下的除法，会一直除到两者的有效位数之和
/// <para>a除以b</para>
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
private static SKSpecialDecimal div(SKSpecialDecimal _a, SKSpecialDecimal _b)
{
SKSpecialDecimal a = new SKSpecialDecimal(_a);
SKSpecialDecimal b = new SKSpecialDecimal(_b);
if (a.get_digit() == 0 || b.get_digit() == 0 || b.is_zero())
{
return(new SKSpecialDecimal());
}
else if (a.is_zero())
{
return(new SKSpecialDecimal(0));
}
SKSpecialDecimal ret = new SKSpecialDecimal();
SKSpecialDecimal tmp = new SKSpecialDecimal(b);
tmp.exp_10 = a.get_exp();
bool first_zero = (abs(tmp).compare_to(abs(a)) > 0);
ret.positive = (a.get_positive() == b.get_positive()) ? true : false;
ret.exp_10 = a.get_exp() - b.get_exp();
bool stop = false;
SKSpecialDecimal accumulate = new SKSpecialDecimal(0);
a = abs(a);
b = abs(b);
for (int i = (first_zero) ? 1 : 0; i < a.get_digit() + b.get_digit(); i++)
{
for (int j = 1; j < 10; j++)
{
SKSpecialDecimal mul_tmp2 = mul_single(b, (byte)j);
mul_tmp2.mul_10(ret.get_exp() - i);
SKSpecialDecimal now_acc = add(accumulate, mul_tmp2);
//ret[i] = (byte)j;
int compare_ans = now_acc.compare_to(a);
if (compare_ans == 0)
{
ret[i] = (byte)j;
stop = true;
break;
}
else if (compare_ans > 0)
{
ret[i] = (byte)(j - 1);
mul_tmp2 = mul_single(b, (byte)(j - 1));
mul_tmp2.mul_10(ret.get_exp() - i);
accumulate = add(accumulate, mul_tmp2);
break;
}
else if (j == 9)
{
ret[i] = (byte)j;
accumulate = add(accumulate, mul_tmp2);
}
}
if (stop)
{
for (int j = i + 1; j < a.get_digit() + b.get_digit(); j++)
{
ret[j] = 0;
}
break;
}
}
ret.fix();
return(ret);
}
