Example #1
0
 public void Set(BigNum bigNum)
 {
     m1MSBLocation = bigNum.m1MSBLocation;
     //mBinaryNumber = bigNum.mBinaryNumber;
     for (int i = 0; i < GlobalVariables.MAX_NUM; ++i)
     {
         mBinaryNumber[i] = bigNum.mBinaryNumber[i];
     }
 }
Example #2
0
        /// <summary>
        /// I.
        /// Gets BigNum type and substract between the current value of the binary number with the given one.
        /// Let do substraction A = A-B. We know that A-B = A + (-B).
        /// Calculating -B: Doing complement and then add 1.
        /// </summary>
        /// <param name="numberToSubtract"></param>
        public void SubNum(BigNum numberToSubtract)
        {
            // numberToSubstract = B.
            BigNum modifiedNumberToSubtract = new BigNum(numberToSubtract);

            modifiedNumberToSubtract.Complement();                // numberToSubtract = -B - 1.
            modifiedNumberToSubtract.AddNum(GlobalVariables.one); // numberToSubtract = -B.
            AddNum(modifiedNumberToSubtract);                     // Allready updates <mMSB1Location>.
            UpdateMSB1Location();
        }
Example #3
0
        public static void PrintNumberInPowersOfTwo(BigNum num)
        {
            List <int> positionsOf1s = num.WriteNum1sPosition();

            for (int i = 0; i < positionsOf1s.Count - 1; ++i)
            {
                Console.Write($"2^{GlobalVariables.MAX_NUM - positionsOf1s[i] - 1} + ");
            }

            Console.WriteLine($"2^{GlobalVariables.MAX_NUM - positionsOf1s[positionsOf1s.Count - 1] - 1}");
        }
Example #4
0
        public static void F()
        {
            Console.WriteLine("(F) Using ShiftLeft method.");
            Console.WriteLine("Multiply 25 by 2.");
            BigNum bigNumF = new BigNum(25L);

            bigNumF.ShiftLeft();
            Console.WriteLine(bigNumF.WriteNum());

            Console.WriteLine();
        }
Example #5
0
        public BigNum(BigNum bigNum)
        {
            mBinaryNumber = new int[GlobalVariables.MAX_NUM];

            for (int i = 0; i < GlobalVariables.MAX_NUM; ++i)
            {
                mBinaryNumber[i] = bigNum.mBinaryNumber[i];
            }

            m1MSBLocation = bigNum.m1MSBLocation;
        }
Example #6
0
        public static void E()
        {
            Console.WriteLine("(E) Using AddNum method.");
            Console.WriteLine("8 + 13 = 21.");
            BigNum bigNumE1 = new BigNum(8L);
            BigNum bigNumE2 = new BigNum(13L);

            bigNumE1.AddNum(bigNumE2);
            Console.WriteLine(bigNumE1.WriteNum());

            Console.WriteLine();
        }
Example #7
0
        public static void MSB1LocationTest()
        {
            Console.WriteLine("Creating new BigNum type number.");
            BigNum bigNum = new BigNum();

            for (int i = 0; i < GlobalVariables.MAX_NUM; ++i)
            {
                Console.Write(bigNum[i]);
            }

            Console.WriteLine($"The first 1' digit is in position: {bigNum.MSB1Location}");
            Console.WriteLine();
        }
Example #8
0
        public static void C()
        {
            Console.WriteLine("(C) Using LongToBig method.");
            Console.WriteLine("Creating number with long 35.");
            BigNum bigNumC1 = new BigNum(35L);

            Console.WriteLine(bigNumC1.WriteNum());
            Console.WriteLine("Creating number with long 9223372036854775807 (max value of long).");
            BigNum bigNumC2 = new BigNum(9223372036854775807L);

            Console.WriteLine(bigNumC2.WriteNum());

            Console.WriteLine();
        }
Example #9
0
        public static void IIA()
        {
            Console.WriteLine("I.");
            Console.WriteLine("Calculating 1233456897 ^ 8001 mod 1783369431");
            BigNum num    = new BigNum(1233456897);
            BigNum power  = new BigNum(8001);
            BigNum mod    = new BigNum(1783369431);
            BigNum result = new BigNum();

            result = MathOps.Power(num, power, mod);
            Console.WriteLine(result.DecimalValue);

            Console.WriteLine();
        }
Example #10
0
        public static void J()
        {
            Console.WriteLine("(I) Using DivNum method.");
            Console.WriteLine("257 / 13 ==> result = 19, reminder 10.");

            BigNum divided  = new BigNum(257L);
            BigNum divider  = new BigNum(13L);
            BigNum quitient = new BigNum();
            BigNum reminder = new BigNum();

            MathOps.DivNum(divided, divider, quitient, reminder);

            Console.WriteLine($"Quitient is: {quitient.WriteNum()}, Reminder is: {reminder.WriteNum()}.");
            Console.WriteLine();
        }
Example #11
0
        /// <summary>
        /// L.
        /// Gets two BigNums, calculates the opposite number of a in mod m. ([a^-1][mod m]).
        /// Returns null if the a does not have an inverse mode m. (i.e: gcd(a, m) != 1).
        /// </summary>
        /// <param name="a"></param>
        /// <param name="m"></param>
        public static BigNum Inverse(BigNum a, BigNum m)
        {
            BigNum inverse = null;
            BigNum x       = new BigNum();
            BigNum y       = new BigNum();
            BigNum d       = new BigNum(); // d will be gcd(a, m).

            ExtendedGCD(a, m, x, y, d);
            if (d.CompNumWithoutPrint(GlobalVariables.one))
            {
                inverse = y;
            }

            return(inverse);
        }
Example #12
0
        private bool IsBigNumFitsIntoLongType(BigNum num)
        {
            bool isBigNumFitsIntoLongType;

            if (m1MSBLocation.HasValue)
            {
                isBigNumFitsIntoLongType =
                    (GlobalVariables.MAX_NUM - num.m1MSBLocation.Value <= GlobalVariables.MaxNumberOfDigitsInLongType);
            }
            else    // It means that num is zero.
            {
                isBigNumFitsIntoLongType = true;
            }

            return(isBigNumFitsIntoLongType);
        }
Example #13
0
        /// <summary>
        /// G.
        /// Every number can be represented as 2N or 2N+1, when N is even and natural number.
        /// Converts <numberToMult> into long and into representation of 2N or 2N+1.
        /// Then doing N times ShiftLeft() method, If the number is 2N+1, adding one time the initial value
        /// of this instance.
        /// Or
        /// Let the current value of this intance be <value>.
        /// If <numberToMult[i]> == 0 then mult by 2 (ShiftLeft() method).
        /// If <numberToMult[i]> == 1 then mult by 2 (ShiftLeft() method) and adds <value>.
        /// </summary>
        /// <param name="numberToMult"></param>
        public void MultNum(BigNum numberToMult)
        {
            BigNum valueToAdd = new BigNum(this);

            InitializeToZero();
            for (int i = GlobalVariables.MAX_NUM - 1; i >= numberToMult.m1MSBLocation; --i)
            {
                if (numberToMult[i] == 1)
                {
                    AddNum(valueToAdd);
                }

                valueToAdd.ShiftLeft();
            }

            UpdateMSB1Location();
        }
Example #14
0
        /// <summary>
        /// Gets a number m.
        /// Finds p >= 0 and k (k is odd), where m = 2^p * k.
        /// Return p and k by ref.
        ///
        /// p = 0;
        /// if (!IsEven(m))
        /// {
        ///     k = m;
        /// }
        /// else // m is even.
        /// {
        ///     while(IsEven(m))
        ///     {
        ///          m /= 2;
        ///          p++;
        ///     }
        ///     k = m;
        /// }
        /// </summary>
        /// <param name=""></param>
        /// <param name=""></param>
        public static void FindExpressionOfGivenNumberByPowerOfTwoTimesOddNumber(BigNum m, BigNum p, BigNum k)
        {
            if (!m.IsEven())
            {
                k.Set(m);
            }
            else
            {
                while (m.IsEven())
                {
                    DivNum(m, GlobalVariables.two, m, new BigNum());
                    p.AddNum(GlobalVariables.one);
                }

                k.Set(m);
            }
        }
Example #15
0
        public static void N()
        {
            Console.WriteLine("(N) Using IsPrime method.");
            Console.WriteLine("Checking if 7, 513, 9973, 2147483647. We should get: true, false, true, true.");
            BigNum n1 = new BigNum(7);
            BigNum n2 = new BigNum(513);
            BigNum n3 = new BigNum(9973);
            BigNum eightMarsenNumber = new BigNum(2147483647);
            int    k = 20;

            Console.WriteLine(MathOps.IsPrime(n1, k).ToString());
            Console.WriteLine(MathOps.IsPrime(n2, k).ToString());
            Console.WriteLine(MathOps.IsPrime(n3, k).ToString());
            Console.WriteLine(MathOps.IsPrime(eightMarsenNumber, k).ToString());

            Console.WriteLine();
        }
Example #16
0
        /// <summary>
        /// K.
        /// Gets two BigNum type numbers a and m and returns by reference (d, x, y), also BigNum type numbers.
        /// d represents GCD(m,a). (Greatest common divider).
        /// Note: If d = 1, it means that x is the opposite number of m(mod a) and
        ///                               y is the opposite number of a(mod m).
        /// Proofe for Note: 1 = [m*x + a*y](mod m) ==> 1 = a*y.
        /// </summary>
        /// <param name="a"></param>
        /// <param name="m"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="d"></param>
        public static void ExtendedGCD(BigNum a, BigNum m, BigNum x, BigNum y, BigNum d)
        {
            BigNum r0 = new BigNum(m);
            BigNum x0 = new BigNum(GlobalVariables.one);
            BigNum y0 = new BigNum(GlobalVariables.zero);

            BigNum r1 = new BigNum(a);
            BigNum x1 = new BigNum(GlobalVariables.zero);
            BigNum y1 = new BigNum(GlobalVariables.one);

            BigNum r = new BigNum(GlobalVariables.one);    // Just to be able to enter the while loop.
            BigNum q = new BigNum();

            DivNum(r0, r1, q, r);

            while (!r.CompNumWithoutPrint(GlobalVariables.zero))
            {
                // x = x0 - qx1.
                BigNum qx1 = new BigNum(q);
                qx1.MultNum(x1);
                x.Set(x0);
                x.SubNum(qx1);

                // y = y0 - qy1.
                BigNum qy1 = new BigNum(q);
                qy1.MultNum(y1);
                y.Set(y0);
                y.SubNum(qy1);

                r0.Set(r1);
                x0.Set(x1);
                y0.Set(y1);

                r1.Set(r);
                x1.Set(x);
                y1.Set(y);

                DivNum(r0, r1, q, r);
            }

            d.Set(r1);
            x.Set(x1);
            y.Set(y1);
        }
Example #17
0
        /// <summary>
        /// E.
        /// Gets BigNum type and adds it into this instance.
        /// Uses <carry> of type BigNum to implement the binary adding.
        /// Let do summing B = A + B when a[i] is the i'th digit of A. C is the carry.
        /// If a[i] + c[i] == 0, b[i] does not changes.
        /// If a[i] + c[i] == 1, b[i] changes it's value and c[i-1] gets 1.
        /// If a[i] + c[i] == 2, b[i] does not changes and c[i-1] gets 1.
        /// </summary>
        /// <param name="numberToAdd"></param>
        public void AddNum(BigNum numberToAdd)
        {
            BigNum carry = new BigNum();    // <carry> = 00..0.

            for (int i = GlobalVariables.MAX_NUM - 1; i > 0; --i)
            {
                if (numberToAdd[i] + carry[i] == 1)
                {
                    if (mBinaryNumber[i] == 0)
                    {
                        mBinaryNumber[i] = 1;
                    }
                    else
                    {
                        mBinaryNumber[i] = 0;
                        carry[i - 1]     = 1;
                    }
                }
                else if (numberToAdd[i] + carry[i] == 2)
                {
                    carry[i - 1] = 1;
                }
            }

            // Handles i == 0.
            if (numberToAdd[0] + carry[0] == 1)
            {
                if (mBinaryNumber[0] == 0)
                {
                    mBinaryNumber[0] = 1;
                }
                else
                {
                    mBinaryNumber[0] = 0;
                    // Console.WriteLine("There is an overflow. Carry 1 is dropped.");
                }
            }
            else if (numberToAdd[0] + carry[0] == 2)
            {
                // Console.WriteLine("There is an overflow. Carry 1 is dropped.");
            }

            UpdateMSB1Location();
        }
Example #18
0
        public static void G()
        {
            Console.WriteLine("(G) Using MultNum method.");
            Console.WriteLine("Multiply 7 by 3. Equals 21 (10101 in base 2)");
            BigNum bigNumG1 = new BigNum(7L);
            BigNum bigNumG2 = new BigNum(3L);

            bigNumG1.MultNum(bigNumG2);
            Console.WriteLine(bigNumG1.WriteNum());

            Console.WriteLine("Multiply 113 by 73. Equals 8249 (10000000111001 in base 2)");
            BigNum bigNumG3 = new BigNum(113L);
            BigNum bigNumG4 = new BigNum(73L);

            bigNumG3.MultNum(bigNumG4);
            Console.WriteLine(bigNumG3.WriteNum());

            Console.WriteLine();
        }
Example #19
0
        /// <summary>
        /// Gets BigNum type number and an index.
        /// Returns the sub number if the number by the index.
        /// Example: number = 0..001101101 (length of 400 bits), index = 398.
        /// The returned number will be 0..000110110.
        /// </summary>
        /// <param name="divided"></param>
        /// <param name="indexPos"></param>
        /// <returns></returns>
        public static BigNum GetSubBigNumFromLeftToIndex(BigNum divided, int indexPos)
        {
            BigNum     bigNumFromLeftToIndex = new BigNum();
            List <int> positionsOf1s         = new List <int>();
            int        initialIndexPos       = indexPos;

            while (indexPos >= divided.MSB1Location)
            {
                if (divided[indexPos] == 1)
                {
                    positionsOf1s.Add(GlobalVariables.MAX_NUM - (initialIndexPos - indexPos) - 1);
                }

                indexPos--;
            }

            bigNumFromLeftToIndex.ReadNum(positionsOf1s);
            return(bigNumFromLeftToIndex);
        }
Example #20
0
        public static void I()
        {
            Console.WriteLine("(I) Using SubNum method.");
            Console.WriteLine("18 - 5 = 13");
            BigNum bigNumI1 = new BigNum(18L);
            BigNum bigNumI2 = new BigNum(5L);

            bigNumI1.SubNum(bigNumI2);
            Console.WriteLine(bigNumI1.WriteNum());

            Console.WriteLine("375683 - 12345 = 363338 (1011000101101001010 in binary.)");
            BigNum bigNumI3 = new BigNum(375683L);
            BigNum bigNumI4 = new BigNum(12345L);

            bigNumI3.SubNum(bigNumI4);
            Console.WriteLine(bigNumI3.WriteNum());

            Console.WriteLine();
        }
Example #21
0
        public static void M()
        {
            Console.WriteLine("(M) Using Power method.");
            Console.WriteLine("Calculating 30^14 mod 7 = 4.");
            BigNum x     = new BigNum(30);
            BigNum power = new BigNum(14);
            BigNum mod   = new BigNum(7);

            Console.WriteLine(MathOps.Power(x, power, mod).DecimalValue);

            Console.WriteLine("Calculating 130^27 mod 41 = 24.");
            BigNum x2     = new BigNum(130);
            BigNum power2 = new BigNum(27);
            BigNum mod2   = new BigNum(41);

            Console.WriteLine(MathOps.Power(x2, power2, mod2).DecimalValue);

            Console.WriteLine();
        }
Example #22
0
        /// <summary>
        /// H.
        /// Gets another BigNum type number and compare between the two.
        /// </summary>
        /// <returns></returns>
        public bool CompNum(BigNum numberToCompare)
        {
            bool isEqual         = true;
            bool isFinishCompare = false;

            if ((!m1MSBLocation.HasValue) && (!numberToCompare.m1MSBLocation.HasValue))
            {
                // That means that they both equal to zero.
                isFinishCompare = true;
            }
            else if (((m1MSBLocation.HasValue) && (!numberToCompare.m1MSBLocation.HasValue)) ||
                     ((!m1MSBLocation.HasValue) && (numberToCompare.m1MSBLocation.HasValue)))
            {
                // That means that one is zero and other is not.
                isEqual         = false;
                isFinishCompare = true;
            }

            if (!isFinishCompare)
            {
                for (int i = m1MSBLocation.Value; i < GlobalVariables.MAX_NUM; ++i)
                {
                    if (mBinaryNumber[i] != numberToCompare.mBinaryNumber[i])
                    {
                        isEqual = false;
                        break;
                    }
                }
            }

            if (isEqual)
            {
                Console.WriteLine("The numbers are equal.");
            }
            else
            {
                Console.WriteLine("The numbers are NOT equal.");
            }

            return(isEqual);
        }
Example #23
0
        /// <summary>
        /// N.
        /// Runs Miller-Rabin algorithm k times.
        /// </summary>
        /// <param name="n"></param>
        /// <param name="k"></param>
        /// <returns></returns>
        public static bool IsPrime(BigNum n, int k)
        {
            bool   isPrimeNumber = true;
            BigNum t             = new BigNum();
            BigNum u             = new BigNum();
            BigNum nMinusOne     = new BigNum(n);

            nMinusOne.SubNum(GlobalVariables.one);
            FindExpressionOfGivenNumberByPowerOfTwoTimesOddNumber(nMinusOne, t, u);

            for (int i = 0; i < k; ++i)
            {
                if (!MillerRabinAlgorithm(n, new BigNum(t), u))
                {
                    isPrimeNumber = false;
                    break;
                }
            }

            return(isPrimeNumber);
        }
Example #24
0
        public static void A()
        {
            Console.WriteLine("(A) Using ReadNum methods.");
            Console.WriteLine("1. reading 0101");
            BigNum bigNum1a = new BigNum();

            bigNum1a.ReadNum("0101");
            Console.WriteLine(bigNum1a.WriteNum());
            Console.WriteLine($"The first 1' digit is in position: {bigNum1a.MSB1Location}");

            Console.WriteLine("2. reading positions of 1s. Getting a the list {399, 385}.");
            BigNum bigNum2a = new BigNum();

            bigNum2a.ReadNum(new List <int> {
                399, 385
            });
            Console.WriteLine(bigNum2a.WriteNum());
            Console.WriteLine($"The first 1' digit is in position: {bigNum2a.MSB1Location}");

            Console.WriteLine();
        }
Example #25
0
        public static void L()
        {
            Console.WriteLine("(L) Using Inverse method.");
            BigNum bigNum1 = new BigNum(26);
            BigNum bigNum2 = new BigNum(21);

            Console.WriteLine("Calculates the opposite number of 26 mod 21:");
            Console.WriteLine(MathOps.Inverse(bigNum1, bigNum2).DecimalValue);
            Console.WriteLine("Calculates the opposite number of 21 mod 26:");
            Console.WriteLine(MathOps.Inverse(bigNum2, bigNum1).DecimalValue);

            BigNum bigNum3 = new BigNum(15);
            BigNum bigNum4 = new BigNum(10);

            Console.WriteLine("Calculates the opposite number of 15 mod 10:");
            if (MathOps.Inverse(bigNum3, bigNum4) == null)
            {
                Console.WriteLine("There is no opposite for 15");
            }

            Console.WriteLine();
        }
Example #26
0
        /// <summary>
        /// Gets BigNum number.
        /// Finds the index of the MSB 1 digit, run from it to the LSB.
        /// It has boolean variable <isSmaller> that set to true when the first 1's digits is cleared
        /// (set to 0).
        /// Unless <isSmaller> = true, this method cannot set any bit.
        /// Use random (IsGeneratedToSet() method) to set or clear that bit.
        /// </summary>
        /// <param name="top"></param>
        /// <returns></returns>
        private static BigNum GenerateNumberFromOneToGivenTop(BigNum top)
        {
            BigNum generatedNumber = new BigNum();

            if (top.MSB1Location.HasValue)
            {
                do
                {
                    bool       isSmaller         = false;
                    List <int> PositionsOf1sList = new List <int>();
                    for (int i = top.MSB1Location.Value; i < GlobalVariables.MAX_NUM; ++i)
                    {
                        if (top[i] == 1)
                        {
                            if (GenerateOneOrZero() == 0)
                            {
                                isSmaller = true;
                            }
                            else
                            {
                                PositionsOf1sList.Add(i);
                            }
                        }
                        else
                        {
                            if ((GenerateOneOrZero() == 1) && (isSmaller))
                            {
                                PositionsOf1sList.Add(i);
                            }
                        }
                    }

                    generatedNumber.ReadNum(PositionsOf1sList);
                } while ((generatedNumber.CompNumWithoutPrint(GlobalVariables.zero)) ||
                         (generatedNumber.CompNumWithoutPrint(top)));
            }

            return(generatedNumber);
        }
Example #27
0
        public static void D()
        {
            Console.WriteLine("(D) Using BigToLong method.");
            BigNum bigNumC1 = new BigNum(35L);
            long?  num1     = bigNumC1.BigToLong();

            Console.WriteLine(num1);

            BigNum bigNumC2 = new BigNum(9223372036854775807L);
            long?  num2     = bigNumC2.BigToLong();

            Console.WriteLine(num2);

            BigNum bigNumD = new BigNum();

            bigNumD.Complement();
            long?num3 = bigNumD.BigToLong();

            Console.WriteLine(num3);

            Console.WriteLine();
        }
Example #28
0
        /// <summary>
        /// O.
        /// Generates random prime number in the length of MAX_NUN/4.
        /// </summary>
        public static BigNum GenPrime()
        {
            BigNum     randomPrimeNumber = new BigNum();
            BigNum     top           = new BigNum();
            int        k             = 20;
            int        tryNumber     = 1;
            List <int> positionsOf1s = new List <int>();

            for (int i = 392; i < GlobalVariables.MAX_NUM; ++i)    // TODO change back.
            {
                positionsOf1s.Add(i);
            }

            top.ReadNum(positionsOf1s);
            Console.WriteLine("Generating random prime number...");
            do
            {
                Console.WriteLine($"try number: {tryNumber++}");
                randomPrimeNumber = GenerateNumberFromOneToGivenTop(top);
            } while (!IsPrime(randomPrimeNumber, k));

            return(randomPrimeNumber);
        }
Example #29
0
        /// <summary>
        /// J.
        /// Gets two BigNum type numbers, divided and divider.
        /// Returns by reference the result - quotient and reminder.
        /// </summary>
        /// <param name="divider"></param>
        public static void DivNum(BigNum divided, BigNum divider, BigNum quotientRetrunByRef, BigNum reminderReturnByRef)
        {
            List <int> positionsOf1s = new List <int>();

            if (divided.MSB1Location.HasValue)
            {
                int indexPos = divided.MSB1Location.Value + divider.Length - 1;

                BigNum subResult = new BigNum(divided);
                while (indexPos < GlobalVariables.MAX_NUM)
                {
                    BigNum numberFromLeftToIndex = GetSubBigNumFromLeftToIndex(subResult, indexPos);

                    if (numberFromLeftToIndex >= divider)
                    {
                        // Saving quotient's info.
                        positionsOf1s.Add(indexPos);

                        // Subtract.
                        int    numberOfShifts   = GlobalVariables.MAX_NUM - indexPos - 1;
                        BigNum numberToSubtract = new BigNum(divider);
                        numberToSubtract.ShiftLeft(numberOfShifts);
                        subResult.SubNum(numberToSubtract);
                    }

                    indexPos++;
                }

                quotientRetrunByRef.ReadNum(positionsOf1s);
                reminderReturnByRef.Set(subResult);
            }
            else
            {
                Console.WriteLine("Cannot divide by zero");
            }
        }
Example #30
0
        public static void K()
        {
            Console.WriteLine("(K) Using ExtendedGCD method.");

            Console.WriteLine("Calculates GCD(26, 21). Should be = 1");
            BigNum bigNum3 = new BigNum(26);
            BigNum bigNum4 = new BigNum(21);
            BigNum x       = new BigNum();
            BigNum y       = new BigNum();
            BigNum gcd     = new BigNum();

            MathOps.ExtendedGCD(bigNum4, bigNum3, x, y, gcd);
            Console.WriteLine($"GCD = {gcd.WriteNum()} = {bigNum3.DecimalValue}*{x.DecimalValue}" +
                              $" + {bigNum4.DecimalValue}*{y.DecimalValue}");

            Console.WriteLine("Calculates GCD(15, 10). Should be = 5");
            BigNum bigNum1 = new BigNum(15);
            BigNum bigNum2 = new BigNum(10);

            MathOps.ExtendedGCD(bigNum2, bigNum1, x, y, gcd);
            Console.WriteLine($"GCD = {gcd.DecimalValue} = {bigNum1.DecimalValue}*{x.DecimalValue}" +
                              $" + {bigNum2.DecimalValue}*{y.DecimalValue}");
            Console.WriteLine();
        }