Typo.

[NovacoinLibrary.git] / Novacoin / base_uint.cs

diff --git a/Novacoin/base_uint.cs b/Novacoin/base_uint.cs
index 83ef1ed..8b36b12 100644 (file)
--- a/Novacoin/base_uint.cs
+++ b/Novacoin/base_uint.cs
@@ -18,6 +18,7 @@
 
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics.Contracts;
 
 namespace Novacoin
@@ -25,43 +26,88 @@ namespace Novacoin
     /// <summary>
     /// Base class for uint256 and uint160.
     /// </summary>
-    public class base_uint : IComparable<base_uint>, IEquatable<base_uint>
+    public class base_uint : IComparable<base_uint>, IEquatable<base_uint>, IEqualityComparer<base_uint>
     {
+        #region Internal representation
+        /// <summary>
+        /// Length of internal representation
+        /// </summary>
         protected int nWidth;
+        /// <summary>
+        /// Big numbers are stored as array of unsigned 32-bit integers.
+        /// </summary>
         protected uint[] pn;
+        #endregion
 
-        public double getDouble()
+        #region Helper properties
+        public double Double
         {
-            double ret = 0.0;
-            double fact = 1.0;
-
-            for (int i = 0; i < nWidth; i++)
+            get
             {
-                ret += fact * pn[i];
-                fact *= 4294967296.0;
-            }
+                double ret = 0.0;
+                double fact = 1.0;
+
+                for (int i = 0; i < nWidth; i++)
+                {
+                    ret += fact * pn[i];
+                    fact *= 4294967296.0;
+                }
 
-            return ret;
+                return ret;
+            }
         }
 
-        public ulong GetLow64()
+        public ulong Low64
         {
-            return pn[0] | (ulong)pn[1] << 32;
+            get { return pn[0] | (ulong)pn[1] << 32; }
         }
 
-        public uint GetLow32()
+        public uint Low32
         {
-            return pn[0];
+            get { return pn[0]; }
         }
 
+        /// <summary>
+        /// Total size in bytes.
+        /// </summary>
         public int Size
         {
             get
             {
-                return nWidth;
+                return nWidth * sizeof(uint);
+            }
+        }
+
+        /// <summary>
+        /// Zero or the position of highest non-zero bit plus one.
+        /// </summary>
+        protected int bits
+        {
+            get
+            {
+                for (int pos = nWidth - 1; pos >= 0; pos--)
+                {
+                    if (pn[pos] != 0)
+                    {
+                        for (int bits = 31; bits > 0; bits--)
+                        {
+                            if ((pn[pos] & 1 << bits) != 0)
+                                return 32 * pos + bits + 1;
+                        }
+                        return 32 * pos + 1;
+                    }
+                }
+                return 0;
             }
         }
+        #endregion
 
+
+        /// <summary>
+        /// Negation operator
+        /// </summary>
+        /// <param name="a">Value</param>
+        /// <returns>True if value is zero, false otherwise.</returns>
         public static bool operator !(base_uint a)
         {
             for (int i = 0; i < a.nWidth; i++)
@@ -75,6 +121,7 @@ namespace Novacoin
         }
 
 
+        #region Comparison operations
         public static bool operator <(base_uint a, base_uint b)
         {
             for (int i = a.nWidth - 1; i >= 0; i--)
@@ -138,7 +185,9 @@ namespace Novacoin
             }
             return true;
         }
+        #endregion
 
+        #region Equality operators
         public static bool operator ==(base_uint a, base_uint b)
         {
             if (object.ReferenceEquals(a, b))
@@ -187,22 +236,45 @@ namespace Novacoin
         {
             return (!(a == b));
         }
-
+        #endregion
+
+        #region Cast operations
+        /// <summary>
+        /// True cast operator
+        /// </summary>
+        /// <param name="a"></param>
+        /// <returns></returns>
         public static bool operator true(base_uint a)
         {
             return (a != 0);
         }
 
+        /// <summary>
+        /// False cast operator.
+        /// </summary>
+        /// <param name="a">Value</param>
+        /// <returns>Boolean result</returns>
         public static bool operator false(base_uint a)
         {
             return (a == 0);
         }
 
+        /// <summary>
+        /// Imlicit byte[] cast operator.
+        /// </summary>
+        /// <param name="a">Value</param>
         public static implicit operator byte[] (base_uint a)
         {
             return Interop.LEBytes(a.pn);
         }
-
+        #endregion
+
+        /// <summary>
+        /// Arrays equality checking helper method.
+        /// </summary>
+        /// <param name="a">Array 1</param>
+        /// <param name="b">Array 2</param>
+        /// <returns>Result.</returns>
         private static bool ArraysEqual(uint[] a, uint[] b)
         {
             Contract.Requires<ArgumentException>(a.Length == b.Length, "Array length mismatch.");
@@ -217,19 +289,26 @@ namespace Novacoin
             return true;
         }
 
-        public override int GetHashCode()
+
+        #region IEqualityComparer
+        public bool Equals(base_uint a, base_uint b)
         {
-            int hash = 17;
-            unchecked
+            if (object.ReferenceEquals(a, b))
             {
-                foreach (var element in pn)
-                {
-                    hash = hash * 31 + element.GetHashCode();
-                }
+                return true;
             }
-            return hash;
+
+            return ArraysEqual(a.pn, b.pn);
         }
 
+        public int GetHashCode(base_uint a)
+        {
+            return a.GetHashCode();
+        }
+
+        #endregion
+
+        #region IComparable
         public int CompareTo(base_uint item)
         {
             if (this > item)
@@ -243,10 +322,12 @@ namespace Novacoin
 
             return 0;
         }
+        #endregion
 
+        #region IEquatable
         public bool Equals(base_uint a)
         {
-            if (a == null)
+            if (object.ReferenceEquals(a, null))
             {
                 return false;
             }
@@ -254,11 +335,29 @@ namespace Novacoin
             return ArraysEqual(pn, a.pn);
         }
 
+        public override int GetHashCode()
+        {
+            int hash = 17;
+            unchecked
+            {
+                foreach (var element in pn)
+                {
+                    hash = hash * 31 + element.GetHashCode();
+                }
+            }
+            return hash;
+        }
+
         public override bool Equals(object o)
         {
             return Equals(o as base_uint);
         }
+        #endregion
 
+        /// <summary>
+        /// Serialize to string.
+        /// </summary>
+        /// <returns></returns>
         public override string ToString()
         {
             return Interop.ToHex(Interop.ReverseBytes(this));