public static string ParseExpression(string Expression)
{
string[] expressions = Expression.Split('='); //podzielenie na strone prawą i lewą
string rightOfExpression = "", leftOfExpression = "";
string toReturn = "";
Exception exception = new Exception("Bad format of expression.");
if (expressions.Length != 2)
{
throw exception;
}
bool flag = false; // flaga czy już zostało znalezione f w wyrażeniu
for (int i = 0; i < expressions[0].Length; i++)
{
if (expressions[0][i] == 'f')
{
if (flag)
{
throw exception;
}
else
{
leftOfExpression = expressions[0];
rightOfExpression = expressions[1];
flag = true;
}
}
}
for (int i = 0; i < expressions[1].Length; i++)
{
if (expressions[1][i] == 'f')
{
if (flag)
{
throw exception;
}
else
{
leftOfExpression = expressions[1];
rightOfExpression = expressions[0];
flag = true;
}
}
}
if (!flag)
{
throw exception;
}
while (leftOfExpression.Contains("(") || leftOfExpression.Contains(")") || leftOfExpression.Contains("*"))
{
string[] divided = DivideExpression(leftOfExpression);
if (divided.Length == 1)
{
if (isToPower(divided[0]))
{
int indexOfPower = SearchIndexPower(divided[0]);
string divideToPower = divided[0].Substring(1, indexOfPower - 2);
string[] toPower = DivideExpression(divideToPower);
int power = int.Parse(divided[0].Substring(indexOfPower + 1)); //+1 bo indexOfPower to index '^'
for (int i = 0; i < toPower.Length; i++)
{
if (isToPower(toPower[i]))
{
int indexOfS = SearchIndexPower(toPower[i]);
int powerOfS = int.Parse(toPower[i].Substring(indexOfS + 1));
toPower[i] = toPower[i].Substring(0, indexOfS + 1) + (powerOfS * power);
}
else
{
toPower[i] = toPower[i] + "^" + power;
}
}
leftOfExpression = "";
for (int i = 0; i < toPower.Length; i++)
{
if (i == toPower.Length - 1)
{
leftOfExpression += toPower[i];
}
else
{
leftOfExpression += toPower[i] + "*";
}
}
}
else
{
leftOfExpression = divided[0].Substring(1, divided[0].Length - 2);
}
}
else
{
int indexOfF = 0;
bool flagF = false;
for (int i = 0; i < divided.Length; i++)
{
if (divided[i].Contains("f"))
{
indexOfF = i;
flagF = true;
}
}
if (!flagF)
{
throw exception;
}
string left = "", right = "";
for (int i = 0; i < indexOfF; i++)
{
if (i == indexOfF - 1)
{
left += "(" + divided[i] + ")^-1";
}
else
{
left += "(" + divided[i] + ")^-1" + "*";
}
}
for (int i = divided.Length - 1; i >= indexOfF + 1; i--)
{
if (i == indexOfF + 1)
{
right += "(" + divided[i] + ")^-1";
}
else
{
right += "(" + divided[i] + ")^-1" + "*";
}
}
if (left.Length > 0)
{
//left = "(" + left + ")^-1";
rightOfExpression = left + "*" + rightOfExpression;
}
if (right.Length > 0)
{
//right = "(" + right + ")^-1";
rightOfExpression = rightOfExpression + "*" + right;
}
leftOfExpression = divided[indexOfF];
}
}
//Console.WriteLine("Right: " + rightOfExpression);
rightOfExpression = CalculateExpression(rightOfExpression);
if (leftOfExpression.Contains("^"))
{
int i = leftOfExpression.IndexOf('^');
string toParse = leftOfExpression.Substring(i + 1);
int root = int.Parse(toParse);
int[] permutationToRoot = ParsePermutation(rightOfExpression);
int[][] Cases = WithoutRepetition.RootOfPermutation(permutationToRoot, root);
if (Cases.Length == 0)
{
toReturn += "There aren't any solutions.";
}
else
{
int[][] permutationCycle = WithoutRepetition.PermutationToCycle(Cases[0]);
toReturn += "f=" + CycleToString(permutationCycle);
if (Cases.Length > 1)
{
for (int k = 1; k < Cases.Length; k++)
{
permutationCycle = WithoutRepetition.PermutationToCycle(Cases[k]);
toReturn += "||f=" + CycleToString(permutationCycle);
}
}
}
/*
* int[][] permutationCycle = WithoutRepetition.PermutationToCycle(Cases);
* rightOfExpression = CycleToString(permutationCycle);*/
}
return(toReturn);
//return "f=" + rightOfExpression;
}
