X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=Novacoin%2Fuint256.cs;h=c9134010ed604c09ce69335237065ff097fc5c8f;hb=198c3037b62f2c6007dee4c0a8b0fa41e9225c24;hp=317b8d651b418e1942b1228e2158bb6783724de0;hpb=1dcac5faa2b1477034f82466ffb16170fa2e9bb6;p=NovacoinLibrary.git

diff --git a/Novacoin/uint256.cs b/Novacoin/uint256.cs
index 317b8d6..c913401 100644
--- a/Novacoin/uint256.cs
+++ b/Novacoin/uint256.cs
@@ -18,6 +18,7 @@
 
 using System;
 using System.Diagnostics.Contracts;
+using System.Linq;
 
 namespace Novacoin
 {
@@ -202,7 +203,6 @@ namespace Novacoin
             return ret;
         }
 
-
         public static uint256 operator ++(uint256 a)
         {
             int i = 0;
@@ -251,6 +251,161 @@ namespace Novacoin
         {
             return a - new uint256(b);
         }
+
+        public static uint256 operator /(uint256 a, uint b)
+        {
+            var result = new uint256();
+
+            ulong r = 0;
+            int i = a.nWidth;
+
+            while (i-- > 0)
+            {
+                r <<= 32;
+                r |= a.pn[i];
+                result.pn[i] = (uint)(r / b);
+                r %= b;
+            }
+
+            return result;
+        }
+
+        public static uint256 operator *(uint256 a, ulong b)
+        {
+            var result = new uint256();
+
+            ulong c = 0;
+            uint i = 0;
+
+            do
+            {
+                c += a.pn[i] * b;
+                result.pn[i] = (uint)c;
+                c >>= 32;
+            } while (++i < result.nWidth);
+
+            return result;
+        }
+
+        public static uint256 operator *(uint256 a, uint256 b)
+        {
+            if (!a || !b)
+            {
+                // Multiplication by zero results with zero.
+                return 0;
+            }
+            else if (b.bits <= 32)
+            {
+                if (b.pn[0] == 1)
+                {
+                    // If right is 1 then return left operand value
+                    return a;
+                }
+
+                return a * b.pn[0];
+            }
+            else if (a.bits <= 32)
+            {
+                if (a.pn[0] == 1)
+                {
+                    // If left is 1 then return right operand value
+                    return b;
+                }
+
+                return a * b.pn[0];
+            }
+
+            int m = a.bits / 32 + (a.bits % 32 != 0 ? 1 : 0);
+            int n = b.bits / 32 + (b.bits % 32 != 0 ? 1 : 0);
+
+            uint256 result = new uint256();
+
+            uint[] left = a.pn.Take(m).ToArray();
+            uint[] right = b.pn.Take(n).ToArray();
+
+            for (int i = 0; i < m; ++i)
+            {
+                uint ai = left[i];
+                int k = i;
+
+                ulong temp = 0;
+                for (int j = 0; j < n; ++j)
+                {
+                    temp = temp + ((ulong)ai) * right[j] + result.pn[k];
+                    result.pn[k++] = (uint)temp;
+                    temp >>= 32;
+                }
+
+                while (temp != 0)
+                {
+                    temp += result.pn[k];
+                    result.pn[k++] = (uint)temp;
+                    temp >>= 32;
+                }
+            }
+
+            return result;
+        }
+
+        public static uint operator %(uint256 a, uint b)
+        {
+            ulong r = 0;
+            int i = a.nWidth;
+
+            while (i-- > 0)
+            {
+                r <<= 32;
+                r |= a.pn[i];
+                r %= b;
+            }
+
+            return (uint)r;
+        }
+
+        public static uint256 operator /(uint256 a, uint256 b)
+        {
+            if (b.bits <= 32)
+            {
+                return a / b.Low32;
+            }
+
+            uint256 result = new uint256();
+
+            uint[] quotient;
+            uint[] remainder_value;
+
+            int m = a.bits / 32 + (a.bits % 32 != 0 ? 1 : 0);
+            int n = b.bits / 32 + (b.bits % 32 != 0 ? 1 : 0);
+
+            BignumHelper.DivModUnsigned(a.pn.Take(m).ToArray(), b.pn.Take(n).ToArray(), out quotient, out remainder_value);
+
+            quotient.CopyTo(result.pn, 0);
+
+            return result;
+        }
+
+        public static uint256 operator %(uint256 a, uint256 b)
+        {
+            if (b.bits <= 32)
+            {
+                return a % b.Low32;
+            }
+
+            uint256 result = new uint256();
+
+            uint[] quotient;
+            uint[] remainder_value;
+
+            int m = a.bits / 32 + (a.bits % 32 != 0 ? 1 : 0);
+            int n = b.bits / 32 + (b.bits % 32 != 0 ? 1 : 0);
+
+            BignumHelper.DivModUnsigned(a.pn.Take(m).ToArray(), b.pn.Take(n).ToArray(), out quotient, out remainder_value);
+
+            remainder_value.CopyTo(result.pn, 0);
+
+            return result;
+
+        }
         #endregion
 
         #region Shift