private void F(string partOfString)
{
if (String.IsNullOrWhiteSpace(partOfString))
{
throw new EmptyMemberException();
}
try
{
switch (partOfString[0])
{
case '[': Value = "["; Type = NodeType.Sin; Left = new ElementOfTree(); Left.S(partOfString.Substring(2, partOfString.Length - 3)); return;
case ']': Value = "]"; Type = NodeType.Cos; Left = new ElementOfTree(); Left.S(partOfString.Substring(2, partOfString.Length - 3)); return;
case '!': Value = "!"; Type = NodeType.Tan; Left = new ElementOfTree(); Left.S(partOfString.Substring(2, partOfString.Length - 3)); return;
case '?': Value = "?"; Type = NodeType.Ln; Left = new ElementOfTree(); Left.S(partOfString.Substring(2, partOfString.Length - 3)); return;
case '#': Value = "#"; Type = NodeType.Exp; Left = new ElementOfTree(); Left.S(partOfString.Substring(2, partOfString.Length - 3)); return;
case '%': Value = "%"; Type = NodeType.Sqrt; Left = new ElementOfTree(); Left.S(partOfString.Substring(2, partOfString.Length - 3)); return;
default: throw new IncorrectFunctionDefinitionException();
}
}
catch (ArgumentOutOfRangeException e)
{
throw new BracketsMissingException();
}
}
public Tree(string s)
{
s = Regex.Replace(s, "[s][i][n]", "[", RegexOptions.IgnoreCase);
s = Regex.Replace(s, "[c][o][s]", "]", RegexOptions.IgnoreCase);
s = Regex.Replace(s, "[t][a][n]", "!", RegexOptions.IgnoreCase);
s = Regex.Replace(s, "[l][n]", "?", RegexOptions.IgnoreCase);
s = Regex.Replace(s, "[e][x][p]", "#", RegexOptions.IgnoreCase);
s = Regex.Replace(s, "[s][q][r][t]", "%", RegexOptions.IgnoreCase);
Head = new ElementOfTree();
Head.S(s);
}
public void S(string partOfstring)
{
if (String.IsNullOrWhiteSpace(partOfstring))
{
throw new EmptyMemberException();
}
try
{
int sk = 0;
for (int i = partOfstring.Length - 1; i >= 0; i--)
{
if (partOfstring[i] == '(')
{
sk++;
continue;
}
if (partOfstring[i] == ')')
{
sk--;
continue;
}
if ((partOfstring[i] == '+' || partOfstring[i] == '-' && i != 0) && sk == 0)
{
Value = partOfstring[i].ToString();
Type = NodeType.PlusMinus;
Left = new ElementOfTree();
Left.S(partOfstring.Substring(0, i));
Right = new ElementOfTree();
Right.T(partOfstring.Substring(i + 1));
return;
}
}
if (partOfstring[0] == '-')
{
Value = partOfstring[0].ToString();
Type = NodeType.MinusU;
Left = new ElementOfTree();
Left.T(partOfstring.Substring(1, partOfstring.Length - 1));
return;
}
T(partOfstring);
}
catch (ExpressionException e)
{
e.Node = GetNormalNodeState(partOfstring);
throw;
}
}
private void Z(string pertOfString)
{
if (String.IsNullOrWhiteSpace(pertOfString))
{
throw new EmptyMemberException();
}
try
{
if (pertOfString[0] == '(' && pertOfString[pertOfString.Length - 1] == ')')
{
if (pertOfString[1] == '-')
{
Value = "-";
Type = NodeType.MinusU;
Left = new ElementOfTree();
Left.N(pertOfString.Substring(2, pertOfString.Length - 3));
}
else
{
Type = NodeType.Const;
N(pertOfString.Substring(1, pertOfString.Length - 2));
}
}
else
{
Regex constant = new Regex("^([a-w]|[y-z])$", RegexOptions.IgnoreCase);
if (constant.IsMatch(pertOfString))
{
Value = pertOfString;
Type = NodeType.Const;
return;
}
N(pertOfString);
}
}
catch (ExpressionException e)
{
e.Node = GetNormalNodeState(pertOfString);
throw;
}
}
public void ProcessTree(IContext processContext)
{
Head = processContext.Process(Head);
}
public void Determinate(ElementOfTree element)
{
if (element.Left != null)
{
Determinate(element.Left);
}
if (element.Right != null)
{
Determinate(element.Right);
}
Regex Const = new Regex("[x]", RegexOptions.IgnoreCase);
switch (element.Value)
{
case "-":
if (element.Right == null)
{
element.Type = NodeType.MinusU;
return;
}
element.Type = NodeType.PlusMinus;
return;
case "+": element.Type = NodeType.PlusMinus; return;
case "*": element.Type = NodeType.Multiply; return;
case "/": element.Type = NodeType.Divide; return;
case "^":
element.Type = NodeType.Degree;
return;
case "[":
element.Type = NodeType.Sin;
return;
case "]":
element.Type = NodeType.Cos;
return;
case "!":
element.Type = NodeType.Tan;
return;
case "?":
element.Type = NodeType.Ln;
return;
case "#":
element.Type = NodeType.Exp;
return;
case "%":
element.Type = NodeType.Sqrt;
return;
case "X":
case "x": element.Type = NodeType.X; return;
default: element.Type = NodeType.Const; return;
}
}
private void T(string partOfString)
{
if (String.IsNullOrWhiteSpace(partOfString))
{
throw new EmptyMemberException();
}
try
{
int sk = 0;
int divide = -1;
int multiply = -1;
int degree = -1;
for (int i = partOfString.Length - 1; i >= 0; i--)
{
if (partOfString[i] == '(')
{
sk++;
}
else
if (partOfString[i] == ')')
{
sk--;
}
else
if (sk == 0)
{
if (partOfString[i] == '/' && divide == -1)
{
divide = i;
}
else
if (partOfString[i] == '*' && multiply == -1)
{
multiply = i;
}
else
if (partOfString[i] == '^' && degree == -1)
{
degree = i;
}
}
}
if (divide != -1)
{
Value = partOfString[divide].ToString();
Type = NodeType.Divide;
Left = new ElementOfTree();
Left.T(partOfString.Substring(0, divide));
Right = new ElementOfTree();
Right.T(partOfString.Substring(divide + 1));
return;
}
if (multiply != -1)
{
Value = partOfString[multiply].ToString();
Type = NodeType.Multiply;
Left = new ElementOfTree();
Left.T(partOfString.Substring(0, multiply));
Right = new ElementOfTree();
Right.T(partOfString.Substring(multiply + 1));
return;
}
if (degree != -1)
{
Value = partOfString[degree].ToString();
Type = NodeType.Degree;
Left = new ElementOfTree();
Left.T(partOfString.Substring(0, degree));
Right = new ElementOfTree();
Right.Z(partOfString.Substring(degree + 1));
return;
}
M(partOfString);
}
catch (ExpressionException e)
{
e.Node = GetNormalNodeState(partOfString);
throw;
}
}
