Remove Hash, Hash256, Hash160 and ScryptHash256 classes.

[NovacoinLibrary.git] / Novacoin / uint256.cs

diff --git a/Novacoin/uint256.cs b/Novacoin/uint256.cs
index 0c451ef..317b8d6 100644 (file)
--- a/Novacoin/uint256.cs
+++ b/Novacoin/uint256.cs
@@ -1,15 +1,29 @@
-\feffusing System;
-using System.Collections.Generic;
+\feff/**
+ *  Novacoin classes library
+ *  Copyright (C) 2015 Alex D. (balthazar.ad@gmail.com)
+
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Affero General Public License as
+ *  published by the Free Software Foundation, either version 3 of the
+ *  License, or (at your option) any later version.
+
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Affero General Public License for more details.
+
+ *  You should have received a copy of the GNU Affero General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
 using System.Diagnostics.Contracts;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Numerics;
 
 namespace Novacoin
 {
     public class uint256 : base_uint
     {
+        #region Access to internal representation
         new protected int nWidth {
             get { return base.nWidth; }
             private set { base.nWidth = value; }
@@ -18,7 +32,9 @@ namespace Novacoin
             get { return base.pn; }
             private set { base.pn = value; }
         }
+        #endregion
 
+        #region Constructors
         public uint256()
         {
             nWidth = 8;
@@ -57,7 +73,21 @@ namespace Novacoin
             var bytes = Interop.ReverseBytes(Interop.HexToArray(hex));
             pn = Interop.ToUInt32Array(bytes);
         }
+        #endregion
+
+        #region Cast operators
+        public static implicit operator uint256(byte[] bytes)
+        {
+            return new uint256(bytes);
+        }
+
+        public static implicit operator uint256(ulong n)
+        {
+            return new uint256(n);
+        }
+        #endregion
 
+        #region Compact representation
         /// <summary>
         /// Compact representation of unsigned 256bit numbers.
         /// 
@@ -72,11 +102,11 @@ namespace Novacoin
                 int nSize = (bits + 7) / 8;
                 uint nCompact = 0;
                 if (nSize <= 3)
-                    nCompact = ((uint)GetLow64()) << 8 * (3 - nSize);
+                    nCompact = ((uint)Low64) << 8 * (3 - nSize);
                 else
                 {
                     uint256 bn = this >> 8 * (nSize - 3);
-                    nCompact = (uint)bn.GetLow64();
+                    nCompact = (uint)bn.Low64;
                 }
 
                 if ((nCompact & 0x00800000) != 0)
@@ -113,12 +143,9 @@ namespace Novacoin
                 pn = i.pn;
             }
         }
+        #endregion
 
-        private void SetBytes(byte[] bytes)
-        {
-            pn = Interop.ToUInt32Array(Interop.ReverseBytes(bytes));
-        }
-
+        #region Bitwise operations
         public static uint256 operator ~(uint256 a)
         {
             var ret = new uint256();
@@ -129,6 +156,41 @@ namespace Novacoin
             return ret;
         }
 
+        public static uint256 operator ^(uint256 a, uint256 b)
+        {
+            var result = new uint256();
+            result.pn = new uint[a.nWidth];
+            for (int i = 0; i < result.nWidth; i++)
+            {
+                result.pn[i] = a.pn[i] ^ b.pn[i];
+            }
+            return result;
+        }
+
+        public static uint256 operator &(uint256 a, uint256 b)
+        {
+            var result = new uint256();
+            result.pn = new uint[a.nWidth];
+            for (int i = 0; i < result.nWidth; i++)
+            {
+                result.pn[i] = a.pn[i] & b.pn[i];
+            }
+            return result;
+        }
+
+        public static uint256 operator |(uint256 a, uint256 b)
+        {
+            var result = new uint256();
+            result.pn = new uint[a.nWidth];
+            for (int i = 0; i < result.nWidth; i++)
+            {
+                result.pn[i] = a.pn[i] | b.pn[i];
+            }
+            return result;
+        }
+        #endregion
+
+        #region Basic arithmetics
         public static uint256 operator -(uint256 a)
         {
             var ret = new uint256();
@@ -161,16 +223,6 @@ namespace Novacoin
             return a;
         }
 
-        public static uint256 operator ^(uint256 a, uint256 b)
-        {
-            var result = new uint256();
-            result.pn = new uint[a.nWidth];
-            for (int i = 0; i < result.nWidth; i++)
-            {
-                result.pn[i] = a.pn[i] ^ b.pn[i];
-            }
-            return result;
-        }
 
         public static uint256 operator +(uint256 a, uint256 b)
         {
@@ -199,29 +251,9 @@ namespace Novacoin
         {
             return a - new uint256(b);
         }
+        #endregion
 
-        public static uint256 operator &(uint256 a, uint256 b)
-        {
-            var result = new uint256();
-            result.pn = new uint[a.nWidth];
-            for (int i = 0; i < result.nWidth; i++)
-            {
-                result.pn[i] = a.pn[i] & b.pn[i];
-            }
-            return result;
-        }
-
-        public static uint256 operator |(uint256 a, uint256 b)
-        {
-            var result = new uint256();
-            result.pn = new uint[a.nWidth];
-            for (int i = 0; i < result.nWidth; i++)
-            {
-                result.pn[i] = a.pn[i] | b.pn[i];
-            }
-            return result;
-        }
-
+        #region Shift
         public static uint256 operator <<(uint256 a, int shift)
         {
             var result = new uint256();
@@ -265,5 +297,6 @@ namespace Novacoin
 
             return result;
         }
+        #endregion
     }
 }