public static bool DoMaths(ref string number, ref double l1, ref double l2, ref Operation op, Operation newOp, ref bool firstOperation)
{
// Do not assign l2 if it's first time
if (!firstOperation)
{
if (!double.TryParse(number, out l2))
{
number = MUtil.ExpNotationToDecimalNotation(number);
if (!double.TryParse(number, out l1))
{
Debug.LogError("Cannot parse " + number + " to number ( double )");
return(false);
}
}
l1 = op.function.Invoke(l1, l2);
}
else
{
firstOperation = false;
}
number = "";
op = newOp;
return(true);
}
public static double Calculate(string data)
{
if (data.Length == 0)
{
Debug.LogError("Data is empty");
return(double.NaN);
}
if (operations == null)
{
FillOperationsList();
}
if (bracketsFunctions == null)
{
FillBracketsFunctions();
}
data = MUtil.RemoveSpaces(data);
data = ChangePunctuationMark(data);
data = MUtil.ExpNotationToDecimalNotation(data);
data = ReplaceConstants(data);
data = CalculateBrackets(data);
if (data.StartsWith("E"))
{
return(double.NaN);
}
data = CalculateExpression(data);
double result = 0;
if (!double.TryParse(data, out result))
{
Debug.LogError("Cannot parse " + data + " to result ( double )");
return(double.NaN);
}
return(result);
}
public static string CalculateSpecificOperations(string data, Operation[] allowedOperations)
{
double l1 = 0, l2 = 0;
Operation op = null; // First operation is always addition
string actualNumber = "";
bool noPrevOperators = true;
bool operationIsAllowed = false;
int startIndex = 0;
string startData = "";
for (int i = 0; i < data.Length; i++)
{
op = FindOperation(data[i]);
if (op != null)
{
if (i == 0 && data[0] == '-')
{
startData += data[0];
continue;
}
startIndex = i;
break;
}
startData += data[i];
}
// No operator
if (op == null)
{
return(data);
}
if (startIndex == 0)
{
Debug.LogError("Operator without number: \"" + data + "\" op: " + op.name);
return("EOPWTHTNMBR");
}
if (!double.TryParse(startData, out l1))
{
if (startData[startData.Length - 1] == 'E')
{
for (int i = startData.Length; i < data.Length; i++)
{
if (MUtil.IsNumber(data[i]) || data[i] == '+')
{
startData += data[i];
}
else
{
break;
}
}
for (int i = 0; i < data.Length; i++)
{
if (data[i] == 'E')
{
if (data.Length > i + 1)
{
if (data[i + 1] == '+')
{
i += 2;
}
}
}
op = FindOperation(data[i]);
if (op != null)
{
break;
}
}
l1 = MUtil.GetDoubleFromExpNotation(startData);
data = data.Remove(0, startData.Length);
string decimalStartData = MUtil.ExpNotationToDecimalNotation(startData);
data = data.Insert(0, decimalStartData);
startData = decimalStartData;
startIndex = startData.Length;
Debug.Log("Data after converting exponent notation: " + data);
}
else
{
Debug.LogError("Cannot convert " + startData + " to l1 ( double )");
return("ECONVERSION");
}
if (l1.Equals(double.NaN))
{
Debug.LogError("Cannot convert " + startData + " to l1 ( double ). l1 = NaN");
return("ECONVERSION");
}
}
actualNumber = startData;
bool firstOperation = true;
// Multiply
for (int i = startIndex; i < data.Length; i++)
{
Operation aop = FindOperation(data[i]);
if (aop != null)
{
if (actualNumber.Length == 0 && data[i] == '-')
{
actualNumber += data[i];
continue;
}
operationIsAllowed = false;
for (int j = 0; j < allowedOperations.Length; j++)
{
if (op == allowedOperations[j])
{
operationIsAllowed = true;
break;
}
}
if (operationIsAllowed)
{
if (data[i] == '+' && i > 0 && (data[i - 1] == 'E'))
{
actualNumber += data[i];
continue;
}
//Debug.Log("Data before: " + data);
if (noPrevOperators)
{
data = data.Remove(0, actualNumber.Length);
i = 0;
}
else
{
string l1Str = MUtil.ToStandardNotationString(l1);
data = data.Remove(i - actualNumber.Length - 1 - l1Str.Length, actualNumber.Length + 1 + l1Str.Length);
i -= actualNumber.Length + 1 + l1Str.Length;
}
noPrevOperators = false;
//l1 = l2;
//actualNumber = MUtil.ExpNotationToDecimalNotation(actualNumber);
if (!DoMaths(ref actualNumber, ref l1, ref l2, ref op, aop, ref firstOperation))
{
return("ECONVERSION");
}
string standardNotL1 = MUtil.ToStandardNotationString(l1);
data = data.Insert(i, standardNotL1);
i += standardNotL1.Length;
actualNumber = "";
op = aop;
//Debug.Log("Data after: " + data);
}
else
{
if (data[i] == '+' && i > 0 && (data[i - 1] == 'E'))
{
actualNumber += data[i];
continue;
}
if (!double.TryParse(actualNumber, out l1))
{
actualNumber = MUtil.ExpNotationToDecimalNotation(actualNumber);
if (!double.TryParse(actualNumber, out l1))
{
Debug.LogError("Cannot parse " + actualNumber + " to number ( double ) #2");
return("ECONVERSION");
}
}
op = aop;
actualNumber = "";
noPrevOperators = false;
firstOperation = false;
}
}
else
{
actualNumber += data[i];
}
}
operationIsAllowed = false;
for (int j = 0; j < allowedOperations.Length; j++)
{
if (op == allowedOperations[j])
{
operationIsAllowed = true;
break;
}
}
if (operationIsAllowed)
{
if (data[data.Length - 1] == '+' && data.Length > 0 && (data[data.Length - 1] == 'E'))
{
return(data);
}
//Debug.Log("l1.ToString(): " + MUtil.ExpNotationToDecimalNotation(l1.ToString()) + ", lenght: " + MUtil.ExpNotationToDecimalNotation(l1.ToString()).Length);
string l1Str = MUtil.ToStandardNotationString(l1);
data = data.Remove(data.Length - actualNumber.Length - 1 - l1Str.Length, actualNumber.Length + 1 + l1Str.Length);
noPrevOperators = false;
//l1 = l2;
//actualNumber = MUtil.ExpNotationToDecimalNotation(actualNumber);
if (!DoMaths(ref actualNumber, ref l1, ref l2, ref op, operations[0], ref firstOperation))
{
return("ECONVERSION");
}
data = data.Insert(data.Length, MUtil.ToStandardNotationString(l1));
//i += l1.ToString().Length;
actualNumber = "";
op = operations[0];
//Debug.Log("Data after: " + data);
}
return(data);
}
