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 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 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);
}