/// <summary>
/// Checks and corrects mistakes in equation.
/// </summary>
/// <exception cref="EquationIsEmptyException">
/// The exception that is thrown when equation class has empty list of elements,
/// because given text is empty or correction of incorrectly written equation text left no elements in the equation.
/// </exception>
private void Integrity_Check()
{
Elements_Enumerator Equation_Rator = new Elements_Enumerator(Element_Colection);
Check_Integrity_Of_Equation_Begining(Equation_Rator);
if (Equation_Rator.MoveNext() == false)
{
IElement Even_Preious_Element = null;
do
{
Check_Integrity_Of_Current_Element(Equation_Rator, Even_Preious_Element);
Even_Preious_Element = Equation_Rator.Previous_Element;
} while (Equation_Rator.MoveNext() == false);
}
if (Element_Colection.Count < 1)
{
throw new EquationIsEmptyException();
}
while (Element_Colection[Element_Colection.Count - 1] is INot_At_The_End)
{
Element_Colection.RemoveAt(Element_Colection.Count - 1);
if (Element_Colection.Count < 1)
{
throw new EquationIsEmptyException();
}
}
}
/// <summary>
/// Searches closing bracket for given open bracket in equation.
/// </summary>
/// <param name="Opening_Bracket"></param>
/// <param name="Root_Bracket_Pair"></param>
/// <returns></returns>
private Bracket_Pair Search_for_Close_Bracket(Open_Bracket Opening_Bracket, Bracket_Pair Root_Bracket_Pair)
{
int bracket_Index = Element_Colection.IndexOf(Opening_Bracket);
int bracket_Level = 0;
for (int i = bracket_Index; i < Element_Colection.Count; i++)
{
if (Element_Colection[i] is Open_Bracket)
{
bracket_Level++;
}
if (Element_Colection[i] is Close_Bracket CB)
{
if (--bracket_Level == 0)
{
return(new Bracket_Pair(Opening_Bracket, CB, Root_Bracket_Pair));
}
}
}
while (--bracket_Level > 0)
{
Element_Colection.Add(new Close_Bracket());
}
return(Add_Close_Bracket(Opening_Bracket, Root_Bracket_Pair));
}
/// <summary>
/// Adds missing copening bracket at the beging of equation if missing.
/// </summary>
/// <param name="Closing_Bracket"></param>
/// <param name="Root_Bracket_Pair"></param>
private void Add_Open_Bracket(Close_Bracket Closing_Bracket, Bracket_Pair Root_Bracket_Pair)
{
Open_Bracket new_OB = new Open_Bracket();
Element_Colection.Insert(0, new_OB);
Bracket_Pair bracket_Pair = new Bracket_Pair(new_OB, Closing_Bracket, Root_Bracket_Pair);
}
/// <summary>
/// Adds missing closing bracket at the end of equation if missing.
/// </summary>
/// <param name="_Open_Bracket"></param>
/// <param name="Root_Bracket_Pair"></param>
/// <returns></returns>
private Bracket_Pair Add_Close_Bracket(Open_Bracket _Open_Bracket, Bracket_Pair Root_Bracket_Pair)
{
Close_Bracket new_CB = new Close_Bracket();
Element_Colection.Add(new_CB);
return(new Bracket_Pair(_Open_Bracket, new_CB, Root_Bracket_Pair));
}
/// <summary>
/// Selects every character to organized as element list.
/// </summary>
private void Element_Selector()
{
if (the_Equation == default(string) || the_Equation == "")
{
Element_Colection.Add(new Number(0));
return;
}
for (int i = 0; i < the_Equation.Length; i++)
{
i = Element_Segregator(i);
}
}
/// <summary>
/// Checks does given character is operand.
/// </summary>
/// <param name="sign">Character to check is operand.</param>
private bool Is_Operand(char sign)
{
for (int i = 0; i < Order_Of_Operations.operand_Sings.Length; i++)
{
for (int k = 0; k < Order_Of_Operations.operand_Sings[i].Length; k++)
{
if (Order_Of_Operations.operand_Sings[i][k] == sign)
{
Element_Colection.Add(Order_Of_Operations.Operands[i][k]);
return(true);
}
}
}
return(false);
}
/// <summary>
/// Checks does given character is bracket.
/// </summary>
/// <param name="sign">Character to check is bracket.</param>
private bool Is_Bracket(char sign)
{
if (sign == '(')
{
Element_Colection.Add(new Open_Bracket());
return(true);
}
if (sign == ')')
{
Element_Colection.Add(new Close_Bracket());
return(true);
}
return(false);
}
/// <summary>
/// Returns end index of number whether given index is start of a number or do nothing if not.
/// </summary>
private int End_Number(int first_Sign_Position)
{
int sign_Position = first_Sign_Position;
sign_Position = End_of_Number_Finder(sign_Position);
if (first_Sign_Position == sign_Position)
{
return(sign_Position);
}
else
{
Number Parsed_Number = _Parser.Parse(the_Equation.Substring(
first_Sign_Position, sign_Position - first_Sign_Position));
Element_Colection.Add(Parsed_Number);
return(sign_Position);
}
}
/// <summary>
/// Removes wrong elements at the begining of the equation and returns number of removed elements.
/// </summary>
/// <param name="Equation_Rator"></param>
/// <exception cref="EquationIsEmptyException">
private int Check_Integrity_Of_Equation_Begining(Elements_Enumerator Equation_Rator)
{
int removed_Elements = 0;
if (Equation_Rator.MoveNext() == true)
{
throw new EquationIsEmptyException();
}
// If equation begings by operand[s] - removes it[them]
while (Equation_Rator.Current_Element is INot_At_the_Begining)
{
if (Element_Colection.RemoveAt(Equation_Rator.Current_Index) == false)
{
throw new EquationIsEmptyException();
}
removed_Elements++;
}
return(removed_Elements);
}
/// <summary>
/// Recreats string of equation after correcting mistakes.
/// </summary>
public string Recreate_Equation()
{
return(Element_Colection.Recreate_Equation());
}
/// <summary>
/// Finds mistakes of given elements and correct them in custom way.
/// </summary>
/// <param name="Equation_Rator">Enumerator of current list.</param>
/// <param name="Even_Preious_Element">elemnt </param>
private void Check_Integrity_Of_Current_Element(Elements_Enumerator Equation_Rator, IElement Even_Preious_Element)
{
IElement Current_Element = Equation_Rator.Current_Element;
IElement Previous_Element = Equation_Rator.Previous_Element;
if (Even_Preious_Element is Bracket && Equation_Rator.Previous_Element is IOperand && Equation_Rator.Current_Element is Bracket)
{
if (Even_Preious_Element is Open_Bracket || Equation_Rator.Current_Element is Close_Bracket)
{
Element_Colection.RemoveAt(Equation_Rator.Current_Index);
Equation_Rator--;
Element_Colection.RemoveAt(Equation_Rator.Current_Index);
int removed_Elements = Check_Integrity_Of_Equation_Begining(
new Elements_Enumerator(Element_Colection));
for (int i = 0; i <= removed_Elements; i++)
{
Equation_Rator--;
}
}
}
else if (Current_Element is Open_Bracket && Previous_Element is INot_Outside_The_Open_Bracket)
{
Element_Colection.Insert(Equation_Rator.Current_Index, new Multiplication());
Equation_Rator--;
}
else if (Previous_Element is Operand && Current_Element is Operand)
{
Element_Colection.RemoveAt(Equation_Rator.Current_Index);
Equation_Rator--;
}
else if (Previous_Element is Open_Bracket && Current_Element is Close_Bracket)
{
Element_Colection.RemoveAt(Equation_Rator.Current_Index);
Equation_Rator--;
Element_Colection.RemoveAt(Equation_Rator.Current_Index);
Equation_Rator--;
}
else if (Previous_Element is Close_Bracket && Current_Element is INot_Outside_The_Close_Bracket)
{
Element_Colection.Insert(Equation_Rator.Current_Index, new Multiplication());
Equation_Rator--;
}
else if (Previous_Element is Open_Bracket && Current_Element is INot_Intside_Bracket)
{
Element_Colection.RemoveAt(Equation_Rator.Current_Index);
Equation_Rator--;
}
else if (Current_Element is Close_Bracket && Previous_Element is INot_Intside_Bracket)
{
Element_Colection.RemoveAt(Equation_Rator.Current_Index - 1);
Equation_Rator--;
}
}
