public ElementOfTree Process(ElementOfTree element, IContext context)
{
((SimplifyContext)context).IsChanged = true;
if (element.Right.Type == NodeType.Const && element.Right.Value == "1")
{
element = element.Left;
return(element);
}
if (element.Right.Type == NodeType.Const && element.Right.Value == "0")
{
element = new ElementOfTree
{
Type = NodeType.Const,
Value = "1"
};
return(element);
}
if (element.Right.Type == NodeType.MinusU && element.Left.Value == "0")
{
element = new ElementOfTree
{
Type = NodeType.Const,
Value = "1"
};
return(element);
}
((SimplifyContext)context).IsChanged = false;
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
element.Type = NodeType.Const;
element.Left = null;
element.Value = "1";
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
element.Type = NodeType.Multiply;
element.Value = "*";
var tempL = element.Left.Copy();
var tempR = element.Right.Copy();
element.Left = context.Process(element.Left);
element.Right = new ElementOfTree
{
Value = "*",
Type = NodeType.Multiply,
Left = tempR,
Right = new ElementOfTree
{
Value = "^",
Type = NodeType.Degree,
Right = new ElementOfTree
{
Type = NodeType.PlusMinus,
Value = "-",
Left = element.Right.Copy(),
Right = new ElementOfTree
{
Value = "1",
Type = NodeType.Const
}
},
Left = tempL
}
};
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
var result = new ElementOfTree
{
Right = context.Process(element.Left.Copy()),
Left = new ElementOfTree
{
Left = new ElementOfTree
{
Type = NodeType.Const,
Value = "1"
},
Right = new ElementOfTree
{
Left = new ElementOfTree
{
Type = NodeType.Const,
Value = "2"
},
Right = element,
Type = NodeType.Multiply,
Value = "*"
},
Value = "/",
Type = NodeType.Divide
},
Value = "*",
Type = NodeType.Multiply
};
return(result);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
element.Left = new ElementOfTree
{
Type = NodeType.PlusMinus,
Value = "-",
Left = new ElementOfTree
{
Type = NodeType.Multiply,
Value = "*",
Left = context.Process(element.Left.Copy()),
Right = element.Right
},
Right = new ElementOfTree
{
Type = NodeType.Multiply,
Value = "*",
Left = element.Left,
Right = context.Process(element.Right.Copy())
}
};
element.Right = new ElementOfTree
{
Type = NodeType.Degree,
Value = "^",
Left = element.Right,
Right = new ElementOfTree
{
Type = NodeType.Const,
Value = "2"
}
};
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
if (element.Right.Type == NodeType.Divide && element.Left.Type == NodeType.Const && element.Left.Value == "1")
{
element.Left = element.Right.Right;
element.Right = element.Right.Left;
return(element);
}
if (element.Left.Type == NodeType.Const && element.Left.Value == "0")
{
element = element.Right;
return(element);
}
if (element.Left.Type == NodeType.MinusU && element.Left.Left.Value == "0")
{
element = element.Right;
return(element);
}
if (element.Right.Type == NodeType.Const && element.Right.Value == "1")
{
element = element.Left;
return(element);
}
((SimplifyContext)context).IsChanged = false;
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
element.Right = element.Copy();
element.Type = NodeType.Multiply;
element.Left = context.Process(element.Right?.Left.Copy());
element.Value = "*";
return(element);
}
public ElementOfTree Process(ElementOfTree element)
{
if (_strategies.Keys.Contains(element.Type))
{
foreach (var strategy in _strategies[element.Type])
{
element = strategy.Process(element, this);
}
}
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
((SimplifyContext)context).IsChanged = true;
if (element.Type == NodeType.Multiply && element.Right?.Type == NodeType.Const && element.Left?.Type != NodeType.Const)
{
var temp = element.Right;
element.Right = element.Left;
element.Left = temp;
}
((SimplifyContext)context).IsChanged = false;
return(element);
}
private ElementOfTree ProcessElement(ElementOfTree element)
{
if (_strategies.Keys.Contains(element.Type))
{
foreach (var strategy in _strategies[element.Type])
{
element = strategy.Process(element, this);
}
}
else
{
IsChanged = false;
}
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
var tempElem = element.Copy();
element.Right = new ElementOfTree
{
Type = NodeType.Cos,
Value = element.Value.Replace("[", "]"),
Left = element.Left
};
element.Left = context.Process(tempElem.Left);
element.Type = NodeType.Multiply;
element.Value = "*";
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
var tempElem = element.Copy();
tempElem.Type = NodeType.Sin;
tempElem.Value = tempElem.Value.Replace("]", "[");
element.Left = context.Process(element.Left.Copy());
element.Right = new ElementOfTree
{
Value = "-",
Type = NodeType.MinusU,
Left = tempElem
};
element.Value = "*";
element.Type = NodeType.Multiply;
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
element.Value = "*";
element.Type = NodeType.Multiply;
element.Right = new ElementOfTree
{
Value = "/",
Type = NodeType.Divide,
Left = new ElementOfTree
{
Type = NodeType.Const,
Value = "1"
},
Right = element.Left
};
element.Left = context.Process(element.Left.Copy());
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
element.Type = NodeType.PlusMinus;
element.Value = "+";
var leftTemp = element.Left.Copy();
element.Left = new ElementOfTree
{
Value = "*",
Type = NodeType.Multiply,
Left = element.Left,
Right = context.Process(element.Right.Copy())
};
element.Right = new ElementOfTree
{
Value = "*",
Type = NodeType.Multiply,
Left = context.Process(leftTemp),
Right = element.Right
};
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
var leftResult = new ElementOfTree
{
Right = new ElementOfTree
{
Type = NodeType.Degree,
Value = "^",
Right = new ElementOfTree
{
Value = "2",
Type = NodeType.Const
},
Left = new ElementOfTree
{
Type = NodeType.Cos,
Value = "]",
Left = element.Left
}
},
Left = new ElementOfTree
{
Value = "1",
Type = NodeType.Const
},
Type = NodeType.Divide,
Value = "/"
};
var result = new ElementOfTree
{
Left = leftResult,
Right = context.Process(element.Left.Copy()),
Type = NodeType.Multiply,
Value = "*"
};
return(result);
}
public ElementOfTree Process(ElementOfTree element)
{
if (element.Right != null)
{
element.Right = Process(element.Right);
}
if (element.Left != null)
{
element.Left = Process(element.Left);
}
if (ToTheSimpliestForm)
{
IsChanged = true;
while (IsChanged)
{
element = ProcessElement(element);
}
}
else
{
element = ProcessElement(element);
}
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
((SimplifyContext)context).IsChanged = true;
if (element.Left?.Type == NodeType.Const && element.Right?.Type == NodeType.Const)
{
int a, b;
if (int.TryParse(element.Right.Value, out a) && int.TryParse(element.Left.Value, out b))
{
element.Value = (a * b).ToString();
element.Type = NodeType.Const;
element.Right = null;
element.Left = null;
return(element);
}
}
if (element.Right?.Type == NodeType.Const && element.Right.Value == "1")
{
element = element.Left;
return(element);
}
if (element.Left?.Type == NodeType.Const && element.Left.Value == "1")
{
element = element.Right;
return(element);
}
if (element.Right?.Type == NodeType.Const && element.Right.Value == "0")
{
element = element.Right;
return(element);
}
if (element.Left?.Type == NodeType.Const && element.Left.Value == "0")
{
element = element.Left;
return(element);
}
if (element.Right?.Type == NodeType.MinusU && element.Right.Left.Value == "0")
{
element = element.Right;
return(element);
}
if (element.Left?.Type == NodeType.MinusU && element.Left.Left.Value == "0")
{
element = element.Left;
return(element);
}
if (element.Type == NodeType.Multiply && element.Right?.Left?.Type == NodeType.Const &&
element.Left?.Type == NodeType.Const)
{
int a, b;
if (int.TryParse(element.Right.Left.Value, out a) && int.TryParse(element.Left.Value, out b))
{
element.Left.Value = (a * b).ToString();
element.Right = element.Right.Right;
return(element);
}
}
if (element.Right?.Type == NodeType.MinusU && element.Right.Type == NodeType.Const && element.Left.Type == NodeType.Const)
{
element.Type = NodeType.MinusU;
int a, b;
if (int.TryParse(element.Right?.Left?.Value, out a) && int.TryParse(element.Left.Value, out b))
{
element.Type = NodeType.MinusU;
element.Value = "-";
element.Right = null;
element.Left = new ElementOfTree
{
Type = NodeType.Const,
Value = (a * b).ToString()
};
}
}
if (element.Type == NodeType.Multiply && element.Right?.Left?.Type == NodeType.MinusU &&
element.Left?.Type == NodeType.Const)
{
element.Type = NodeType.MinusU;
int a, b;
if (int.TryParse(element.Right?.Left?.Left?.Value, out a) && int.TryParse(element.Left.Value, out b))
{
element.Left.Type = NodeType.MinusU;
element.Left.Value = "-";
element.Left.Right = null;
element.Left.Left = new ElementOfTree
{
Type = NodeType.Const,
Value = (a * b).ToString()
};
element.Right = element.Right.Right;
}
}
((SimplifyContext)context).IsChanged = false;
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
element.Left = context.Process(element.Left);
element.Right = context.Process(element.Right);
return(element);
}
public ElementOfTree Process(ElementOfTree element, IContext context)
{
((SimplifyContext)context).IsChanged = true;
if (element.Left.Type == NodeType.Const && element.Right.Type == NodeType.Const)
{
int a, b;
if (int.TryParse(element.Left.Value, out a) && int.TryParse(element.Right.Value, out b))
{
element.Value = element.Value == "+" ? (a + b).ToString() : (a - b).ToString();
element.Type = NodeType.Const;
element.Right = null;
element.Left = null;
return(element);
}
}
if (element.Right.Type == NodeType.Const && element.Right.Value == "0")
{
element = element.Left;
return(element);
}
if (element.Left.Type == NodeType.Const && element.Left.Value == "0")
{
if (element.Value == "-")
{
element.Type = NodeType.MinusU;
element.Value = "-";
element.Left = element.Right;
element.Right = null;
}
else
{
element = element.Right;
}
}
if (element.Left.Type == NodeType.Multiply && element.Right?.Type == NodeType.Multiply &&
element.Left.Right.Equals(element.Right.Right))
{
var tempElemR = element.Right.Left.Copy();
var tempElemL = element.Left.Left.Copy();
int a, b;
if (int.TryParse(tempElemL.Value, out a) && int.TryParse(tempElemR.Value, out b))
{
element = element.Right;
element.Left.Value = (a + b).ToString();
return(element);
}
return(element);
}
if (element.Right?.Type == NodeType.X && element.Left?.Type == NodeType.X)
{
element.Type = NodeType.Multiply;
element.Left = new ElementOfTree
{
Value = "2",
Type = NodeType.Const
};
element.Value = "*";
}
if (element.Right?.Type == NodeType.MinusU && element.Left.Type == NodeType.Const)
{
int a, b;
if (int.TryParse(element.Right?.Left.Value, out a) && int.TryParse(element.Left.Value, out b))
{
if (element.Value == "-")
{
element.Right.Left.Value = (a + b).ToString();
}
else
{
element.Right.Left.Value = (a - b).ToString();
}
element = element.Right;
return(element);
}
}
((SimplifyContext)context).IsChanged = false;
return(element);
}
