public VeryLong DivideBy(VeryLong divisor, out VeryLong remainder)
{
string dividendString = "";
string divisorString = divisor.ToString();
string quotientDigit = "";
string quotient = "";
string mult = "";
string diff = "";
for (int i = 0; i < Length(); i++)
{
dividendString += GetFirstDigit(i);
dividendString = VeryLong.RemoveLeadingZeros(dividendString);
quotientDigit = DivideSimple(dividendString, divisorString);
quotient += quotientDigit;
mult = (new VeryLong(quotientDigit).Multiply(new VeryLong(divisorString))).ToString();
diff = (new VeryLong(dividendString).Subtract(new VeryLong(mult))).ToString();
dividendString = diff;
}
VeryLong quotientResult = new VeryLong(quotient);
remainder = new VeryLong(diff);
quotientResult.RemoveLeadingZeros();
return(quotientResult);
}
// Berechne die quadratwurzel aus q (Heronverfahren)
//
// 1 / q \
// xn+1 = --- * | xn + ---- |
// 2 \ xn /
// Each iteration about doubles the correct decimal places!
public static VeryLong Sqrt(VeryLong input, int numberOfDigits)
{
int additionalCalcDigits = 5;
int additionalLimitDigits = 0;
VeryLong limit = new VeryLong("0." + VeryLong.GetZeros(numberOfDigits + additionalLimitDigits) + "1"
+ VeryLong.GetZeros(additionalCalcDigits - additionalLimitDigits - 1));
VeryLong xnew;
VeryLong delta;
VeryLong xn = new VeryLong(input.ToString());
int i = 0;
while (true)
{
VeryLong summand2 = input.DivideBy(xn, numberOfDigits + additionalCalcDigits);
VeryLong factor = xn.Add(summand2);
xnew = new VeryLong("0.5").Multiply(factor);
delta = xnew.Subtract(xn);
Console.WriteLine("i " + i);
Console.WriteLine("Sqrt delta: " + delta.ToString());
Console.WriteLine("limit: " + limit.ToString());
Console.WriteLine("Sqrt: " + xnew.ToString());
xn = xnew;
i++;
if (!delta.Abs().IsLargerOrEqual(limit))
{
break;
}
}
xn.LimitPrecisionTo(numberOfDigits);
return(xn);
}
public VeryLong Subtract(VeryLong subtrahend)
{
int minuendDecimalPlaces = GetDecimalPlaces();
int subtrahendDecimalPlaces = subtrahend.GetDecimalPlaces();
int decimalPlaces = Math.Max(minuendDecimalPlaces, subtrahendDecimalPlaces);
FillUpDecimalPlacesWithZero(decimalPlaces);
subtrahend.FillUpDecimalPlacesWithZero(decimalPlaces);
string result = "";
int diff = 0;
int borrow = 0;
int currentLastDigit = 0;
int currentLastDigitSubtrahend = 0;
int i = 0;
if (!IsLargerOrEqual(subtrahend))
{
// swap: minuend is smaller than subtrahend --> result is negative
VeryLong newMinuend = subtrahend;
VeryLong newSubtrahend = new VeryLong(ToString());
VeryLong difference = newMinuend.Subtract(newSubtrahend);
return(new VeryLong("-" + difference.ToString()));
}
while (Length() > i || subtrahend.Length() > i || borrow != 0)
{
if (GetLastDigit(i) == ".")
{
result = result.Insert(0, ".");
i++;
continue;
}
currentLastDigit = int.Parse(GetLastDigit(i));
currentLastDigitSubtrahend = int.Parse(subtrahend.GetLastDigit(i));
diff = currentLastDigit - currentLastDigitSubtrahend - borrow;
if (diff < 0)
{
borrow = 1;
diff += 10;
}
else
{
borrow = 0;
}
result = result.Insert(0, diff.ToString());
i++;
}
result = RemoveLeadingZeros(result);
return(new VeryLong(result));
}
public VeryLong DivideBy(VeryLong divisor, int numberOfDigits)
{
int numberDecimalPlacesDivisor = divisor.GetDecimalPlaces();
divisor = RemoveDecimalPlaces(divisor);
FillUpDecimalPlacesWithZero(numberOfDigits + numberDecimalPlacesDivisor);
string dividendString = "";
string divisorString = divisor.ToString();
string quotientDigit = "";
string quotient = "";
string mult = "";
string diff = "";
for (int i = 0; i < Length(); i++)
{
if (GetFirstDigit(i) == ".")
{
quotient += ".";
continue;
}
dividendString += GetFirstDigit(i);
dividendString = VeryLong.RemoveLeadingZeros(dividendString);
quotientDigit = DivideSimple(dividendString, divisorString);
quotient += quotientDigit;
mult = (new VeryLong(quotientDigit).Multiply(new VeryLong(divisorString))).ToString();
diff = (new VeryLong(dividendString).Subtract(new VeryLong(mult))).ToString();
dividendString = diff;
}
VeryLong quotientResult = new VeryLong(quotient);
int resultDecimalPlaces = quotientResult.GetDecimalPlaces();
quotientResult = RemoveDecimalPlaces(quotientResult);
quotientResult.SetDecimalPlaces(resultDecimalPlaces - numberDecimalPlacesDivisor);
quotientResult.RemoveLeadingZeros();
quotientResult.LimitPrecisionTo(numberOfDigits);
return(quotientResult);
}
public static VeryLong RemoveDecimalPlaces(VeryLong number)
{
return(new VeryLong(number.ToString().Replace(".", "")));
}
public static VeryLong Pi(int numberOfDigits)
{
VeryLong factor = new VeryLong(1.ToString());
int additionalCalcDigits = 10;
int additionalLimitDigits = 0;
VeryLong pi = new VeryLong("0");
if (_piAlgorithm == PiAlgorithm.BBP)
{
pi = GetStartValueBBP(numberOfDigits + additionalCalcDigits); // BBP
}
else if (_piAlgorithm == PiAlgorithm.Euler)
{
pi = new VeryLong("3"); // Euler
}
VeryLong limit = new VeryLong("0." + VeryLong.GetZeros(numberOfDigits + additionalLimitDigits) + "1"
+ VeryLong.GetZeros(additionalCalcDigits - additionalLimitDigits - 1));
int i = 0;
StartTime();
while (true)
{
i++;
VeryLong term = new VeryLong("0");
if (_piAlgorithm == PiAlgorithm.BBP)
{
term = GetPiTermBBP(i, numberOfDigits + additionalCalcDigits, ref factor);
}
else if (_piAlgorithm == PiAlgorithm.Euler)
{
term = GetPiTermEuler(i, numberOfDigits + additionalCalcDigits);
}
if (!term.IsLargerOrEqual(limit))
{
Console.WriteLine("limit reached:");
Console.WriteLine("Term: " + term.ToString());
Console.WriteLine("limit: " + limit.ToString());
PrintTime();
break;
}
if (_piAlgorithm == PiAlgorithm.BBP) // BBP
{
pi = pi.Add(term);
}
else if (_piAlgorithm == PiAlgorithm.Euler)
{
if (i % 2 == 1)
{
pi = pi.Add(term);
}
else
{
pi = pi.Subtract(term);
}
}
if (i % 10 == 0)
{
Console.WriteLine();
Console.WriteLine("Term " + i);
Console.WriteLine("Pi: " + pi.ToString());
Console.WriteLine("Term: " + term.ToString());
Console.WriteLine("limit: " + limit.ToString());
PrintTime();
}
else if (i % 1 == 0)
{
Console.Write(".");
}
}
VeryLong piCorrectDigits = new VeryLong(pi.ToString().Remove(numberOfDigits + 2));
return(piCorrectDigits);
}
static void Main(string[] args)
{
for (int i = 0; i < 5; i++)
{
Console.WriteLine("Enter a calculation like '1+2' or enter 'pi'. Operations are + - * /. Numbers are integers of any size.");
string input = Console.ReadLine();
if (input == "pi")
{
Console.WriteLine("Enter the number of digits you want.");
string digitsString = Console.ReadLine();
int numberDigits = 0;
if (int.TryParse(digitsString, out numberDigits))
{
string pi = VeryLongMath.Pi(numberDigits).ToString();
Console.WriteLine("Pi is: " + pi.ToString());
}
else
{
Console.WriteLine("invalid number.");
}
continue;
}
if (input == "sqrt")
{
int numberDigits;
VeryLong number;
Console.WriteLine("Square root of?");
string numberString = Console.ReadLine();
Console.WriteLine("number of digits?");
string digitsString = Console.ReadLine();
if (int.TryParse(digitsString, out numberDigits))
{
number = new VeryLong(numberString);
string sqrt = VeryLongMath.Sqrt(number, numberDigits).ToString();
Console.WriteLine("Sqrt of " + numberString + " is: " + sqrt.ToString());
}
else
{
Console.WriteLine("invalid number.");
}
}
string[] parts = input.Split(new char[] { '+', '-', '*', '/' });
if (parts.Length != 2)
{
Console.WriteLine("invalid input.");
continue;
}
VeryLong number0 = new VeryLong(parts[0]);
VeryLong number1 = new VeryLong(parts[1]);
if (input.Contains('+'))
{
Console.WriteLine(number0.Add(number1).ToString());
}
else if (input.Contains('*'))
{
Console.WriteLine(number0.Multiply(number1).ToString());
}
else if (input.Contains('-'))
{
Console.WriteLine(number0.Subtract(number1).ToString());
}
else if (input.Contains('/'))
{
VeryLong remainder;
VeryLong quotient = number0.DivideBy(number1, out remainder);
Console.WriteLine(quotient.ToString() + " Remainder: " + remainder);
VeryLong quotientWithDecimal = number0.DivideBy(number1, 100);
Console.WriteLine(quotientWithDecimal.ToString());
}
else
{
Console.WriteLine("Please enter a valid operation...");
}
}
Console.ReadLine();
}
