Novacoin/BigNum.cs

   1 \feffusing System;
   2 using System.Collections.Generic;
   3 using System.Linq;
   4 using System.Text;
   5 using System.Threading.Tasks;
   6
   7 using Org.BouncyCastle.Math;
   8
   9 namespace Novacoin
  10 {
  11     /// <summary>
  12     /// Wrapper for bouncycastle's Biginteger class.
  13     /// </summary>
  14     public class BigNum : IComparable<BigNum>, IEquatable<BigNum>
  15     {
  16         /// <summary>
  17         /// Internal coby of Biginteger object.
  18         /// </summary>
  19         private BigInteger bn;
  20
  21         #region Constructors
  22         public BigNum(BigInteger bnValue)
  23         {
  24             bn = bnValue;
  25         }
  26
  27         public BigNum(byte[] dataBytes)
  28         {
  29             bn = new BigInteger(dataBytes);
  30         }
  31
  32         public BigNum(ulong ulongValue)
  33         {
  34             bn = new BigInteger(BitConverter.GetBytes(ulongValue));
  35         }
  36
  37         public BigNum(uint256 uint256Value)
  38         {
  39             bn = new BigInteger(uint256Value);
  40         }
  41         #endregion
  42
  43         #region Basic arithmetics
  44         public static BigNum operator +(BigNum a, ulong b)
  45         {
  46             var bnValueToAdd = new BigInteger(BitConverter.GetBytes(b));
  47             return new BigNum(a.bn.Add(bnValueToAdd));
  48         }
  49
  50         public static BigNum operator -(BigNum a, ulong b)
  51         {
  52             var bnValueToSubstract = new BigInteger(BitConverter.GetBytes(b));
  53             return new BigNum(a.bn.Subtract(bnValueToSubstract));
  54         }
  55
  56         public static BigNum operator +(BigNum a, uint256 b)
  57         {
  58             var bnValueToAdd = new BigInteger(b);
  59             return new BigNum(a.bn.Add(bnValueToAdd));
  60         }
  61
  62         public static BigNum operator -(BigNum a, uint256 b)
  63         {
  64             var bnValueToSubstract = new BigInteger(b);
  65             return new BigNum(a.bn.Subtract(bnValueToSubstract));
  66         }
  67
  68         public static BigNum operator +(BigNum a, BigNum b)
  69         {
  70             return new BigNum(a.bn.Add(b.bn));
  71         }
  72
  73         public static BigNum operator -(BigNum a, BigNum b)
  74         {
  75             return new BigNum(a.bn.Subtract(b.bn));
  76         }
  77
  78         public static BigNum operator /(BigNum a, ulong b)
  79         {
  80             var bnDivider = new BigInteger(BitConverter.GetBytes(b));
  81             return new BigNum(a.bn.Divide(bnDivider));
  82         }
  83
  84         public static BigNum operator /(BigNum a, uint256 b)
  85         {
  86             var bnDivider = new BigInteger(b);
  87             return new BigNum(a.bn.Divide(bnDivider));
  88         }
  89
  90         public static BigNum operator /(BigNum a, BigNum b)
  91         {
  92             return new BigNum(a.bn.Divide(b.bn));
  93         }
  94
  95         public static BigNum operator *(BigNum a, ulong b)
  96         {
  97             var bnMultiplier = new BigInteger(BitConverter.GetBytes(b));
  98             return new BigNum(a.bn.Multiply(bnMultiplier));
  99         }
 100
 101         public static BigNum operator *(BigNum a, uint256 b)
 102         {
 103             var bnMultiplier = new BigInteger(b);
 104             return new BigNum(a.bn.Multiply(bnMultiplier));
 105         }
 106
 107         public static BigNum operator *(BigNum a, BigNum b)
 108         {
 109             return new BigNum(a.bn.Multiply(b.bn));
 110         }
 111         #endregion
 112
 113         #region Comparison operations
 114         public static bool operator <(BigNum a, BigNum b)
 115         {
 116             return a.bn.CompareTo(b.bn) < 0;
 117         }
 118         public static bool operator <=(BigNum a, BigNum b)
 119         {
 120             return a.bn.CompareTo(b.bn) <= 0;
 121         }
 122
 123         public static bool operator >(BigNum a, BigNum b)
 124         {
 125             return a.bn.CompareTo(b.bn) > 0;
 126         }
 127
 128         public static bool operator >=(BigNum a, BigNum b)
 129         {
 130             return a.bn.CompareTo(b.bn) >= 0;
 131         }
 132
 133         public static bool operator ==(BigNum a, BigNum b)
 134         {
 135             return a.bn.CompareTo(b.bn) == 0;
 136         }
 137
 138         public static bool operator !=(BigNum a, BigNum b)
 139         {
 140             return a.bn.CompareTo(b.bn) != 0;
 141         }
 142
 143         #endregion
 144
 145         #region Cast operators
 146         public static implicit operator BigNum(BigInteger bnValue)
 147         {
 148             return new BigNum(bnValue);
 149         }
 150
 151         public static implicit operator BigNum(ulong ulongValue)
 152         {
 153             return new BigNum(ulongValue);
 154         }
 155
 156         public static implicit operator BigNum(uint256 uint256Value)
 157         {
 158             return new BigNum(uint256Value);
 159         }
 160
 161         public static implicit operator ulong (BigNum a)
 162         {
 163             return (ulong)a.bn.LongValue;
 164         }
 165
 166         public int CompareTo(BigNum other)
 167         {
 168             return bn.CompareTo(other.bn);
 169         }
 170
 171         public bool Equals(BigNum other)
 172         {
 173             if (object.ReferenceEquals(other, null))
 174             {
 175                 return false;
 176             }
 177
 178             return this == other;
 179         }
 180
 181         public override int GetHashCode()
 182         {
 183             return bn.GetHashCode();
 184         }
 185
 186         public override bool Equals(object obj)
 187         {
 188             if (object.ReferenceEquals(obj, null))
 189             {
 190                 return false;
 191             }
 192
 193             return this == (obj as BigNum);
 194         }
 195
 196         #endregion
 197     }
 198 }