using System; using System.Numerics; using System.Text; namespace EulerNumber { public class BigDecimal : IComparable { //The number represents all the digits in the displayed value. //The precision is the number of decimal places. //maxPrecision is the maximum number of decimal places allowed. //This is adjustable to any arbitrary number with the function provided. private BigInteger number = 0; private BigInteger precision = 0; private static BigInteger maxPrecision = 10000; public static BigInteger MAXPRECISION { get { return maxPrecision; } } #region Constructors //Constructors that accept limited numeric types public BigDecimal() { BigInteger test = new BigInteger(); BigInteger test2 = test + 1; } public BigDecimal(BigInteger num) { number = num; } public BigDecimal(int num) { number = num; } public BigDecimal(double num) { BigDecimal temp = new BigDecimal((decimal)num); number = temp.number; precision = temp.precision; } public BigDecimal(decimal num) { number = (BigInteger)num; if (num == 0) { return; } if (number == 0) { string tempNum = num.ToString(); if (num < 0) { tempNum = "-" + tempNum.Substring(tempNum.IndexOf('.') + 1); } tempNum = tempNum.Substring(tempNum.IndexOf('.') + 1); precision = tempNum.Length; number = BigInteger.Parse(tempNum); return; } string temp = decimal.Remainder(num, decimal.Truncate(num)).ToString(); string tempFraction = temp.Substring(temp.IndexOf('.') + 1); precision = tempFraction.Length; number = BigInteger.Parse(tempFraction) + (number * BIPow(10, precision)); } public BigDecimal(float num) { BigDecimal temp = new BigDecimal((decimal)num); number = temp.number; precision = temp.precision; } public BigDecimal(long num) { number = num; } public BigDecimal(ulong num) { number = num; } public BigDecimal(uint num) { number = num; } private BigDecimal(byte[] num) { number = new BigInteger(num); } #endregion Constructors #region Operators //Implicit operators for simple casting from limited numeric types public static implicit operator BigDecimal(int v) { return new BigDecimal(v); } public static implicit operator BigDecimal(double v) { return new BigDecimal(v); } public static implicit operator BigDecimal(decimal v) { return new BigDecimal(v); } public static implicit operator BigDecimal(float v) { return new BigDecimal(v); } public static implicit operator BigDecimal(BigInteger v) { return new BigDecimal(v); } public static implicit operator BigDecimal(long v) { return new BigDecimal(v); } public static implicit operator BigDecimal(ulong v) { return new BigDecimal(v); } public static implicit operator BigDecimal(uint v) { return new BigDecimal(v); } public static implicit operator BigDecimal(byte[] v) { return new BigDecimal(v); } //Equals operator public static bool operator ==(BigDecimal a, BigDecimal b) { return a.CompareTo(b) == 0; } //Not Equals operator public static bool operator !=(BigDecimal a, BigDecimal b) { return a.CompareTo(b) != 0; } //Plus operator public static BigDecimal operator +(BigDecimal a, BigDecimal b) { BigDecimal outVal = 0; if (a.precision == b.precision) { outVal = a.number + b.number; outVal.precision = a.precision; return outVal; } BigInteger maxPrecision = BigInteger.Max(a.precision, b.precision); if (a.precision < maxPrecision) { outVal = a.number * BIPow(10, maxPrecision - a.precision) + b.number; } else { outVal = b.number * BIPow(10, maxPrecision - b.precision) + a.number; } outVal.precision = maxPrecision; return outVal; } //Minus operator public static BigDecimal operator -(BigDecimal a, BigDecimal b) { return a + (b * -1); } //Multiplication operator public static BigDecimal operator *(BigDecimal a, BigDecimal b) { BigDecimal outVal = a.number * b.number; outVal.precision = a.precision + b.precision; return outVal; } //Division operator public static BigDecimal operator /(BigDecimal a, BigDecimal b) { BigDecimal outVal = 0; BigInteger dividend = a.number; BigInteger divisor = b.number; BigInteger maxPrecision = BigInteger.Max(a.precision, b.precision); if (a.precision < maxPrecision) { a.precision = maxPrecision; a.number = a.number * BIPow(10, maxPrecision - a.precision); } if (b.precision < maxPrecision) { b.precision = maxPrecision; b.number = b.number * BIPow(10, maxPrecision - b.precision); } BigInteger remainder = 0; outVal.number = BigInteger.DivRem(a.number, b.number, out remainder); while (remainder != 0 && outVal.precision < MAXPRECISION) { while (BigInteger.Abs(remainder) < BigInteger.Abs(b.number)) { remainder *= 10; outVal.number *= 10; outVal.precision++; } outVal.number = outVal.number + BigInteger.DivRem(remainder, b.number, out remainder); } return outVal; } //Greater than operator public static bool operator >(BigDecimal a, BigDecimal b) { BigInteger maxPrecision = BigInteger.Max(a.precision, b.precision); if (a.precision < maxPrecision) { return (a.number * BIPow(10, maxPrecision - a.precision)) > b.number; } if (b.precision < maxPrecision) { return a.number > (b.number * BIPow(10, maxPrecision - b.precision)); } return a.number > b.number; } //Less than operator public static bool operator <(BigDecimal a, BigDecimal b) { BigInteger maxPrecision = BigInteger.Max(a.precision, b.precision); if (a.precision < maxPrecision) { return (a.number * BIPow(10, maxPrecision - a.precision)) < b.number; } if (b.precision < maxPrecision) { return a.number < (b.number * BIPow(10, maxPrecision - b.precision)); } return a.number < b.number; } #endregion Operators #region Public Functions public override string ToString() { String outVal = number.ToString(); if (precision == 0) { return string.Format("{0}.0", outVal); } string startString = "0."; if (outVal.TrimStart("-".ToCharArray()).Length < precision) { if (number < 0) { startString = "-0."; outVal = outVal.TrimStart("-".ToCharArray()); } StringBuilder sb = new StringBuilder(startString + NewString('0', precision - outVal.Length) + outVal); return sb.ToString(); } return outVal.Insert(outVal.Length - (int)precision, "."); } public int CompareTo(object a) { return ToString().CompareTo(a.ToString()); } public override int GetHashCode() { return ToString().GetHashCode(); } public override bool Equals(object obj) { return this.CompareTo(obj) == 0; } //Function to change the maximum precision the class will use public static void ChangeMaxPrecision(BigInteger value) { maxPrecision = value; } #endregion Public Functions #region Private Functions //A function to build a new string of repeating characters using BigInteger count. private static string NewString(char c, BigInteger count) { if (count <= int.MaxValue) { return new string(c, (int)count); } StringBuilder sb = new StringBuilder(); for (BigInteger i = 0; i < count; i++) { sb.Append(c); } return sb.ToString(); } //A function to calculate a number raised to a power both numbers represented as BigIntegers private static BigInteger BIPow(BigInteger input, BigInteger exp) { if (exp == 0) { return 1; } if (exp == 1) { return input; } BigInteger outval = 1; while (exp != 0) { if (exp % 2 == 1) { outval *= input; } exp >>= 1; input *= input; } return outval; } #endregion Private Functions } internal class Program { private static void Main(string[] args) { /*Precision loss is qite big, but you`ll get like ~2000 decimals. After that point smthn interesting happens. !!!!!!!!! Will work in Visual Studio but not in SoloLearn, because "The type or namespace name 'Numerics' does not exist in the namespace 'System'" So we can`t use BigIntegers((*/ double iter = 0; double c = 1; double h = 0; double k = 1; double n = 2; BigDecimal e = new BigDecimal(n); BigDecimal fact = new BigDecimal(k); BigDecimal y = new BigDecimal(k); BigDecimal m = new BigDecimal(k); BigDecimal b = new BigDecimal(k); while (c < 10000) { fact = fact * c; iter++; b = y / fact; e = e + b; c++; } Console.WriteLine("Estimated value of e is {0}", e); Console.WriteLine("Iterations made: {0}", iter); } } }

Calculating e (long form)