コード例 #1
0
        public static MplbLongArithm operator -(MplbLongArithm left, MplbLongArithm right) // перегрузка оператора вычитания; реализация вычитания длинных чисел
        {
            if ((left.Value != "NaN" && right.Value != "NaN") || (left.Length >= 0 && right.Length >= 0))
            {
                if (left == right)
                {
                    return(new MplbLongArithm("0"));
                }

                string         delta = "";
                MplbLongArithm result,
                               left_mod  = new MplbLongArithm(left.Module),
                               right_mod = new MplbLongArithm(right.Module);

                if ((left.Sign && right.Sign) ||
                    (!left.Sign && !right.Sign))
                {
                    string greater_mod = (left > right) ? left.Module : right.Module,
                           less_mod    = (left > right) ? right.Module : left.Module;
                    SetWithZeroes(ref greater_mod, ref less_mod);

                    for (int i = greater_mod.Length - 1; i >= 0; i--)
                    {
                        if (greater_mod[i] >= less_mod[i])
                        {
                            delta += (char)((greater_mod[i] - less_mod[i]) + 48);
                        }
                        else
                        {
                            delta += (char)(((greater_mod[i] + 10) - less_mod[i]) + 48);
                            int k = 1;
                            while (greater_mod[i - k] == '0')
                            {
                                greater_mod = greater_mod.Remove(i - k, 1);
                                greater_mod = greater_mod.Insert(i - k, "9");
                                k++;
                            }
                            char temp = (char)(greater_mod[i - k] - 1);
                            greater_mod = greater_mod.Remove(i - k, 1);
                            greater_mod = greater_mod.Insert(i - k, temp.ToString());
                        }
                    }

                    delta = ReverseString(delta);

                    result = new MplbLongArithm(delta);
                    return(((left_mod > right_mod && !left.Sign) ||
                            (left_mod < right_mod && left.Sign)) ? result : !result);
                }

                return((!left.Sign && right.Sign) ? left_mod + right_mod : !(left_mod + right_mod));
            }
            else
            {
                return(new MplbLongArithm("E"));
            }
        }
コード例 #2
0
        public static MplbLongArithm operator *(MplbLongArithm left, MplbLongArithm right) // перегрузка оператора умножениея; реализация умножения длинных чисел
        {
            if ((left.Value != "NaN" && right.Value != "NaN") || (left.Length >= 0 && right.Length >= 0))
            {
                string min = (left > right) ? right.Module : left.Module,
                       max = (left > right) ? left.Module : right.Module;

                string[] terms = new string[min.Length];
                for (int i = 0; i < terms.Length; i++)
                {
                    terms[i] = "";
                }

                for (int i = min.Length - 1; i >= 0; i--)
                {
                    string prod = "00";
                    for (int j = max.Length - 1; j >= 0; j--)
                    {
                        prod = Convert.ToString(((min[i] - 48) * (max[j] - 48)) + (prod[0] - 48));

                        if (prod.Length == 1)
                        {
                            prod = prod.Insert(0, "0");
                        }

                        terms[min.Length - 1 - i] += prod[1];
                    }

                    terms[min.Length - 1 - i] += prod[0];
                    terms[min.Length - 1 - i]  = ReverseString(terms[min.Length - 1 - i]);
                    terms[min.Length - 1 - i] += new string('0', min.Length - 1 - i);
                }

                MplbLongArithm result = new MplbLongArithm(terms[0]);
                for (int i = 1; i < min.Length; i++)
                {
                    result += new MplbLongArithm(terms[i]);
                }

                if (left.Sign && !right.Sign || !left.Sign && right.Sign)
                {
                    return(!result);
                }

                return(result);
            }
            else
            {
                return(new MplbLongArithm("E"));
            }
        }
コード例 #3
0
        public static MplbLongArithm operator !(MplbLongArithm right) // перегрузка оператора !; возвращает длинное число, противоположное данному длинному числу
        {
            MplbLongArithm result = new MplbLongArithm(right);

            if (result[0] == '-')
            {
                result.Value = result.Value.Remove(0, 1);
            }
            else
            {
                result.Value = result.Value.Insert(0, "-");
            }

            return(result);
        }
コード例 #4
0
        public static MplbLongArithm operator +(MplbLongArithm left, MplbLongArithm right) // перегрузка оператора сложения; реализация сложения длинных чисел
        {
            if ((left.Value != "NaN" && right.Value != "NaN") || (left.Length >= 0 && right.Length >= 0))
            {
                MplbLongArithm left_mod  = new MplbLongArithm(left.Module),
                               right_mod = new MplbLongArithm(right.Module);

                if (!left.Sign && !right.Sign)
                {
                    string left_val = left.Value, right_val = right.Value;
                    SetWithZeroes(ref left_val, ref right_val);

                    string result = "";
                    byte   carry = 0, temp = 0;
                    for (int i = left_val.Length - 1; i >= 0; i--)
                    {
                        temp    = (byte)(left_val[i] - 48 + right_val[i] - 48 + carry);
                        carry   = (temp < 10) ? (byte)0 : (byte)1;
                        result += (temp < 10) ? Convert.ToString(temp) : Convert.ToString(temp - 10);
                    }

                    if (carry > 0)
                    {
                        result += 1;
                    }

                    result = ReverseString(result);
                    return(new MplbLongArithm(result));
                }

                if (left.Sign && !right.Sign)
                {
                    return(right_mod - left_mod);
                }

                if (!left.Sign && right.Sign)
                {
                    return(left_mod - right_mod);
                }

                return(!(left_mod + right_mod));
            }
            else
            {
                return(new MplbLongArithm("E"));
            }
        }
コード例 #5
0
        public static MplbLongArithm fact(MplbLongArithm n)
        {
            MplbLongArithm one = new MplbLongArithm("1");

            return((n > one) ? fact(n - one) * n : one);
        }
コード例 #6
0
 public MplbLongArithm(MplbLongArithm number) // конструктор, который принимает дилнное число и делает текущий экземпляр структуры = вх. аргументу
 {
     this = number;
 }