public static LargeNumber operator /(LargeNumber l1, LargeNumber l2)
{
LargeNumber resultNumber = new LargeNumber();
LargeNumber zeroNumber = new LargeNumber();
if (l2.Compare(zeroNumber) == Comparision.Equal)
{
D.LogError("Attempted division by zero");
throw new System.DivideByZeroException();
}
else
{
if (l2.Compare(l1) == Comparision.Greater)
{
resultNumber.SetUpNumber("0");
}
else if (l2.Compare(l1) == Comparision.Equal)
{
resultNumber.SetUpNumber("1");
}
else
{
if (l1.numberBreakDown.Count > l2.numberBreakDown.Count + 1)
{
List <string> l1Abbreviated = new List <string>();
for (int i = 0; i <= l2.numberBreakDown.Count; i++)
{
l1Abbreviated.Add(l1.numberInString[i]);
}
LargeNumber l1Abb = new LargeNumber();
l1Abb.SetUpNumberFromList(l1Abbreviated);
LargeNumber result = new LargeNumber();
while (l1Abb.Compare(zeroNumber) != Comparision.Equal)
{
l1Abb = l1Abb - l2;
result++;
//D.Log("result = "+result.finalNumberWithFormat);
}
for (int i = l2.numberBreakDown.Count + 1; i < l1.numberBreakDown.Count; i++)
{
result.numberInString.Add("000");
}
resultNumber.SetUpNumberFromList(result.numberInString);
}
else
{
// D.Log("l1 = "+l1.finalNumberWithFormat+" , l2 = "+l2.finalNumberWithFormat);
while (l1.Compare(zeroNumber) != Comparision.Equal && (l1.Compare(l2) == Comparision.Greater || l1.Compare(l2) == Comparision.Equal))
{
l1 = l1 - l2;
resultNumber++;
}
}
}
}
return(resultNumber);
}
public static LargeNumber operator --(LargeNumber l)
{
LargeNumber l1 = new LargeNumber(1);
l = l - l1;
return(l);
}
public static LargeNumber operator *(LargeNumber l1, float l2)
{
LargeNumber l = new LargeNumber(l1);
if (l2 % 1 == 0)
{
LargeNumber multiplier = new LargeNumber((int)l2);
l = l * multiplier;
}
else
{
int beforeDecimal = (int)l2;
// D.Log("BEFORE DECIMAL = "+beforeDecimal);
float afterDecimal = (l2 % 1);
// D.Log("AFTER DECIMAL = "+afterDecimal);
string numberDecimal = l2.ToString(CultureInfo.InvariantCulture);
int lengthOfDecimalNumbers = numberDecimal.Substring(numberDecimal.IndexOf(".", StringComparison.Ordinal) + 1).Length;
afterDecimal = afterDecimal * Mathf.Pow(10, lengthOfDecimalNumbers);
int afterDecimalInt = (int)afterDecimal;
string number = "" + beforeDecimal + afterDecimalInt;
// D.Log("Number without decimal = "+number);
l = l * new LargeNumber(number);
string numberAfterMultipliaction = "";
for (int i = l.numberInString.Count - 1; i >= 0; i--)
{
string currentNumber = l.numberInString[i];
int index = currentNumber.Length - 1;
while (index >= 0)
{
numberAfterMultipliaction += "" + currentNumber[index];
index--;
}
}
if (numberAfterMultipliaction.Length > lengthOfDecimalNumbers)
{
// D.Log("numberAfterMultipliaction = "+numberAfterMultipliaction);
string numberAfterTruncation = numberAfterMultipliaction.Substring(lengthOfDecimalNumbers);
numberAfterTruncation = numberAfterTruncation.Reverse();
// D.Log("Number after truncation = "+numberAfterTruncation);
l.SetUpNumber(numberAfterTruncation);
}
else
{
l = new LargeNumber();
}
}
return(l);
}
public static LargeNumber operator %(LargeNumber number, float percentage)
{
LargeNumber percentNumber = new LargeNumber();
if (percentage % 1 == 0)
{
LargeNumber percent = new LargeNumber((int)percentage);
LargeNumber number100 = new LargeNumber(100);
percentNumber = number * percent;
percentNumber = percentNumber / number100;
}
else
{
int integerPart = (int)percentage;
LargeNumber part1 = new LargeNumber();
part1 = number % integerPart;
// D.Log("part 1 = "+part1.finalNumberWithFormat);
float value = percentage % 1;
string numberDecimal = value.ToString(CultureInfo.InvariantCulture);
int length = numberDecimal.Substring(numberDecimal.IndexOf(".", StringComparison.Ordinal) + 1).Length;
// D.Log("percentage % 1 = "+percentage % 1);
// D.Log("Length = "+length);
int multiplier = 1;
for (int i = 0; i < length; i++)
{
multiplier *= 10;
}
value *= multiplier;
int percentageValue = (int)value;
// D.Log("integer of decimal part = "+percentageValue);
LargeNumber part2 = new LargeNumber();
part2 = number % percentageValue;
// D.Log("part 2 = "+part2.finalNumberWithFormat);
LargeNumber multiplierLargeNumber = new LargeNumber(multiplier);
part2 = part2 / multiplierLargeNumber;
percentNumber = part1 + part2;
}
return(percentNumber);
}
public Comparision Compare(LargeNumber number2)
{
Comparision compare = Comparision.Equal;
if (numberBreakDown.Count < number2.numberBreakDown.Count)
{
compare = Comparision.Lesser;
}
else
{
if (numberBreakDown.Count > number2.numberBreakDown.Count)
{
compare = Comparision.Greater;
}
else //equal
{
if (numberBreakDown[0] < number2.numberBreakDown[0])
{
compare = Comparision.Lesser;;
}
else
{
for (int i = 0; i < numberBreakDown.Count; i++)
{
if (numberBreakDown[i] < number2.numberBreakDown[i])
{
compare = Comparision.Lesser;;
break;
}
else if (numberBreakDown[i] > number2.numberBreakDown[i])
{
compare = Comparision.Greater;
break;
}
}
}
}
}
return(compare);
}
public void Concatenate(LargeNumber l2)
{
string l2InString = "";
for (int i = 0; i < l2.numberInString.Count; i++)
{
l2InString += l2.numberInString[i];
}
// D.Log("l2InString = "+l2InString);
string currentNumber = "";
for (int i = 0; i < numberInString.Count; i++)
{
currentNumber += numberInString[i];
}
// D.Log("Current number = "+currentNumber);
currentNumber += l2InString;
// D.Log("Current number = "+currentNumber);
SetUpNumber(currentNumber);
}
// public static LargeNumber operator *(LargeNumber l1, LargeNumber l2)
// {
// LargeNumber resultNumber = new LargeNumber();
// resultNumber.SetUpNumberFromList(l1.numberInString);
//
// LargeNumber comparisonNumber = new LargeNumber(0);
//
// if (l2.Compare(comparisonNumber) == Comparision.Equal || l1.Compare(comparisonNumber) == Comparision.Equal)
// {
// resultNumber.SetUpNumber("0");
// }
// else
// {
// while (comparisonNumber.Compare(l2) != Comparision.Equal)
// {
// l2--;
// resultNumber = resultNumber + l1;
//// D.Log("answer = "+resultNumber.finalNumberWithFormat);
// }
//
// resultNumber = resultNumber - l1;
// }
// return resultNumber;
// }
//
// public static LargeNumber operator *(LargeNumber l1, float l2)
// {
//// D.Log("CALLED");
// LargeNumber l = new LargeNumber(l1);
//
// if (l2 % 1 == 0)
// {
// LargeNumber multiplier = new LargeNumber((int)l2);
// l = l * multiplier;
// }
// else
// {
// int beforeDecimal = (int) l2;
// float afterDecimal = (l2 % 1);
// string numberDecimal = l2.ToString(CultureInfo.InvariantCulture);
// int length = numberDecimal.Substring(numberDecimal.IndexOf(".", StringComparison.Ordinal)+1).Length;
// afterDecimal = afterDecimal * Mathf.Pow(10, length);
// int afterDecimalInt = (int) afterDecimal;
//
// int numberOfDecimalPlaces = (int)Mathf.Pow(10, length);
//
// LargeNumber resultAfterDecimal = l1 * new LargeNumber(afterDecimalInt);
// LargeNumber powerOfTen = new LargeNumber(numberOfDecimalPlaces);
// resultAfterDecimal = resultAfterDecimal / powerOfTen;
//// D.Log("resultAfterDecimal = "+resultAfterDecimal.finalNumberWithFormat);
//
// LargeNumber result = new LargeNumber();
// result = l1 * new LargeNumber(beforeDecimal);
// LargeNumber decimalResult = new LargeNumber(resultAfterDecimal);
// l = result + decimalResult;
// }
//
// return l;
// }
public static LargeNumber operator*(LargeNumber l1, LargeNumber l2)
{
LargeNumber result = new LargeNumber();
LargeNumber number1 = new LargeNumber();
LargeNumber number2 = new LargeNumber();
if (l1.Compare(l2) == Comparision.Greater)
{
number1.SetUpNumberFromList(l1.numberInString);
number2.SetUpNumberFromList(l2.numberInString);
}
else
{
number1.SetUpNumberFromList(l2.numberInString);
number2.SetUpNumberFromList(l1.numberInString);
}
int count = number2.numberInString.Count - 1;
List <string> resultNumbers = new List <string>();
string insertZero = "";
while (count >= 0)
{
string multiplier = number2.numberInString[count];
int multiplierLength = multiplier.Length - 1;
int multiplierInt = 0;
while (multiplierLength >= 0)
{
int resultInt = 0;
int carryForward = 0;
string resultString = "";
int.TryParse("" + multiplier[multiplierLength], out multiplierInt);
for (int i = number1.numberInString.Count - 1; i >= 0; i--)
{
string multiplicand = number1.numberInString[i];
int l1Count = multiplicand.Length - 1;
int multiplicandInt = 0;
while (l1Count >= 0)
{
int.TryParse("" + multiplicand[l1Count], out multiplicandInt);
resultInt = (multiplicandInt * multiplierInt) + carryForward;
carryForward = resultInt / 10;
resultInt = resultInt % 10;
resultString += resultInt.ToString();
l1Count--;
}
if (i == 0)
{
if (carryForward > 0)
{
resultString += carryForward;
}
}
}
// D.Log("resultString = "+resultString);
resultString = resultString.Reverse();
// D.Log("resultString = "+resultString);
resultString += insertZero;
insertZero += "0";
resultNumbers.Add(resultString);
multiplierLength--;
}
count--;
}
result = new LargeNumber(resultNumbers[0]);
for (int i = 1; i < resultNumbers.Count; i++)
{
result += new LargeNumber(resultNumbers[i]);
}
return(result);
}
public LargeNumber(LargeNumber l1)
{
SetUpNumberFromList(l1.numberInString);
}
public static LargeNumber operator -(LargeNumber l1, LargeNumber l2)
{
LargeNumber resultNumber = new LargeNumber();
if (l1.Compare(l2) == Comparision.Lesser || l1.Compare(l2) == Comparision.Equal)
{
resultNumber.SetUpNumber("0");
}
else
{
LargeNumber largerNumber = new LargeNumber(l1.numberInString);
LargeNumber smallerNumber = new LargeNumber(l2.numberInString);
largerNumber.numberBreakDown.Reverse();
smallerNumber.numberBreakDown.Reverse();
List <string> resultOfSubtractionString = new List <string>();
int carryForwardSubtraction = 0;
int resultOfSubtraction = 0;
for (int i = 0; i < smallerNumber.numberBreakDown.Count; i++)
{
resultOfSubtraction = largerNumber.numberBreakDown[i] - smallerNumber.numberBreakDown[i] - carryForwardSubtraction;
// D.Log("l1 = "+largerNumber.numberBreakDown[i]+" , l2 = "+smallerNumber.numberBreakDown[i]+" , carryforward = "+carryForwardSubtraction);
if (resultOfSubtraction < 0)
{
resultOfSubtraction *= -1;
carryForwardSubtraction = 1;
resultOfSubtraction = 1000 - resultOfSubtraction;
}
else
{
carryForwardSubtraction = 0;
}
// D.Log("Carry forward = "+carryForwardSubtraction);
// D.Log("result of subtraction = "+resultOfSubtraction);
string resultString = "" + resultOfSubtraction;
if (resultOfSubtraction < 10)
{
resultString = "00" + resultString;
}
else if (resultOfSubtraction < 100)
{
resultString = "0" + resultString;
}
resultOfSubtractionString.Add(resultString);
}
for (int i = smallerNumber.numberBreakDown.Count; i < largerNumber.numberBreakDown.Count; i++)
{
resultOfSubtraction = largerNumber.numberBreakDown[i] - carryForwardSubtraction;
if (resultOfSubtraction < 0)
{
resultOfSubtraction *= -1;
carryForwardSubtraction = 1;
resultOfSubtraction = 1000 - resultOfSubtraction;
}
else
{
carryForwardSubtraction = 0;
}
string resultString = "" + resultOfSubtraction;
if (resultOfSubtraction < 10)
{
resultString = "00" + resultString;
}
else if (resultOfSubtraction < 100)
{
resultString = "0" + resultString;
}
resultOfSubtractionString.Add(resultString);
}
resultOfSubtractionString.Reverse();
resultOfSubtractionString[0] = (Mathf.Max(0, resultOfSubtraction)).ToString();
int indexAfter0 = -1;
for (int i = 0; i < resultOfSubtractionString.Count; i++)
{
indexAfter0++;
if (resultOfSubtractionString[indexAfter0] != "0" &&
resultOfSubtractionString[indexAfter0] != "000")
{
break;
}
}
// D.Log("indexAfter0 = "+indexAfter0);
List <string> rectifiedResultOfSubtractionString = new List <string>();
for (int i = indexAfter0; i < resultOfSubtractionString.Count; i++)
{
rectifiedResultOfSubtractionString.Add(resultOfSubtractionString[i]);
}
resultOfSubtractionString = rectifiedResultOfSubtractionString;
string firstValue = resultOfSubtractionString[0];
int index = -1;
for (int i = 0; i < firstValue.Length; i++)
{
if (firstValue[i] == '0')
{
index++;
}
else
{
break;
}
}
// D.Log("index = "+index);
if (index >= 0)
{
string rectifiedFirstValue = "";
for (int i = index + 1; i < firstValue.Length; i++)
{
rectifiedFirstValue += firstValue[i];
}
resultOfSubtractionString[0] = rectifiedFirstValue;
}
resultNumber.SetUpNumberFromList(resultOfSubtractionString);
}
return(resultNumber);
}
public static LargeNumber operator +(LargeNumber l1, LargeNumber l2)
{
LargeNumber largerNumber = new LargeNumber();
LargeNumber smallerNumber = new LargeNumber();
int counter = 0;
// D.Log("l1 compare l2 = "+l1.Compare(l2));
if (l1.Compare(l2) == Comparision.Lesser)
{
counter = l1.numberBreakDown.Count;
largerNumber.SetUpNumberFromList(l2.numberInString);
smallerNumber.SetUpNumberFromList(l1.numberInString);
}
else if (l1.Compare(l2) == Comparision.Greater)
{
counter = l2.numberBreakDown.Count;
largerNumber.SetUpNumberFromList(l1.numberInString);
smallerNumber.SetUpNumberFromList(l2.numberInString);
}
else
{
counter = l1.numberBreakDown.Count;
largerNumber.SetUpNumberFromList(l2.numberInString);
smallerNumber.SetUpNumberFromList(l1.numberInString);
}
int carryForward = 0;
largerNumber.numberBreakDown.Reverse();
smallerNumber.numberBreakDown.Reverse();
for (int i = 0; i < counter; i++)
{
int resultOfAddition = largerNumber.numberBreakDown[i] + smallerNumber.numberBreakDown[i] + carryForward;
int resultToPut = resultOfAddition % 1000;
carryForward = resultOfAddition / 1000;
largerNumber.numberBreakDown[i] = resultToPut;
string resultToPutString = resultToPut.ToString();
if (resultToPut < 10)
{
resultToPutString = "00" + resultToPutString;
}
else if (resultToPut < 100)
{
resultToPutString = "0" + resultToPut;
}
largerNumber.numberInString[i] = resultToPutString;
}
if (largerNumber.numberBreakDown.Count > counter)
{
for (int i = counter; i < largerNumber.numberBreakDown.Count; i++)
{
int resultOfAddition = largerNumber.numberBreakDown[i] + carryForward;
int resultToPut = resultOfAddition % 1000;
carryForward = resultOfAddition / 1000;
largerNumber.numberBreakDown[i] = resultToPut;
string resultToPutString = resultToPut.ToString();
if (resultToPut < 10)
{
resultToPutString = "00" + resultToPutString;
}
else if (resultToPut < 100)
{
resultToPutString = "0" + resultToPut;
}
largerNumber.numberInString[i] = resultToPutString;
}
}
if (carryForward > 0)
{
largerNumber.numberBreakDown.Add(carryForward);
largerNumber.numberInString.Add("" + carryForward);
}
largerNumber.numberInString.Reverse();
largerNumber.numberBreakDown.Reverse();
largerNumber.numberInString[0] = "" + largerNumber.numberBreakDown[0];
largerNumber.SetUpNumberFromList(largerNumber.numberInString);
return(largerNumber);
}
