Solver.cs

using System;
using System.Collections.Generic;
using MathParser.DataTypes;
using MathParser.DataTypes.DynamicDataTypes;

namespace MathParser
{
	/// <summary>
	/// Solver.
	/// This is the Entry point of the MathParsing liberay.
	/// </summary>

	/// The other Programmers will use this class as an interface.

	public delegate void SolverOnPrintDelegate<T>(T theType); // Internal delegate. Don't mess with them from outside the namespace MATH_PARSER.
	public delegate void SolverKeyWordsSyncDelegate<T>(ref T theList); // Internal delgate.
	public delegate void SolverMatrixFlagSync(ref string FlagStart, ref string FlagEnd, ref string FlagElementSeperation, ref string FlagRowSeperation);

	public class Solver : ISolver
	{
		string theExpression;
		bool saveHistory = false;
		//Dictionary<string, MathParserExpression> History;
		MathParserExpression solution;
		bool Processed = true;

		public SolverOnPrintDelegate<Matrix> OnMatixPrint = delegate { };
		public SolverOnPrintDelegate<Number> OnNumberPrint = delegate { };
		public static SolverKeyWordsSyncDelegate<List<string>> OnKeyWordsSync = null;
		public static SolverKeyWordsSyncDelegate<List<string>> On_LeftRight_Function_KeyWords_Sync = null;
		public SolverKeyWordsSyncDelegate<Dictionary<string, MathParserExpression>> OnConstantSync = null;
		public SolverMatrixFlagSync OnMatrixFlagSync = null;
		public static UnitFunctionExtentionDelegte On_Single_Argument_KeyWord_Implement = null;
		//public List<string>theKeyWordsList = new List<string>();
		//public List<string> 
		List<string> theUnitFunctionKeyWordsList;

		public MathParserExpression getSolution()
		{
			return solution;
		}

		public bool isProcessed()
		{
			return Processed;
		}

		void KeyWordsList(ref List<string> theKeyWordList)
		{
			if (theKeyWordList.Count != 0) {
				return;
			}
			theKeyWordList.Add("degToRad");
			theKeyWordList.Add("radToDeg");
			theKeyWordList.Add("sin");
			theKeyWordList.Add("cos");
			theKeyWordList.Add("tan");
			theKeyWordList.Add("cot");
			theKeyWordList.Add("cosec");
			theKeyWordList.Add("csc");
			theKeyWordList.Add("sec");
			theKeyWordList.Add("floor");
			theKeyWordList.Add("ceil");
			theKeyWordList.Add("abs");
			theKeyWordList.Add("sinh");
			theKeyWordList.Add("cosh");
			theKeyWordList.Add("tanh");
			theKeyWordList.Add("ln");
			theKeyWordList.Add("log");
			theKeyWordList.Add("arcCos");
			theKeyWordList.Add("arcSin");
			theKeyWordList.Add("arcTan");
			theKeyWordList.Add("sqrt");
			theKeyWordList.Add("round");
			theKeyWordList.Add("√");
			theKeyWordList.Add("trunc");
			theKeyWordList.Add("rref");
			theKeyWordList.Add("ref");
			theKeyWordList.Add("det");
			theKeyWordList.Add("adj");
			theKeyWordList.Add("rank");
			theKeyWordList.Add("inv");
			theKeyWordList.Add("transp");
			theKeyWordList.Add("rootByBisection_polynomial");
			theKeyWordList.Add("rootByRFM_polynomial");
			theKeyWordList.Add("rootByNRM_polynomial");
			theKeyWordList.Add("rootBySM_polynomial");
			theKeyWordList.Add("linearFit_XY");			// y = ax + b
			theKeyWordList.Add("polynomialFit_XY");  	// y = ax^2 + bx + c
			theKeyWordList.Add("exponentialFit_XY"); 	// y = a*e^bx
			theKeyWordList.Add("geometricFit_XY");      // y = a*x^b
			theKeyWordList.Add("linearFit_ND");         // y = a1x1 + a2x2 + a3x3 + ... + aNxN
			theKeyWordList.Add("interpolationByNFIM");    // This function does the Newton Foreard Interpolation.
			OnKeyWordsSync?.Invoke(ref theKeyWordList);
			theUnitFunctionKeyWordsList = theKeyWordList;
		}




		void LeftRightList(ref List<string> theList)
		{
			if (theList.Count != 0) {
				return;
			}
			theList.Add("P");
			theList.Add("C");
		}

		void ConstantList(ref Dictionary<string, MathParserExpression> ConstantList)
		{
			if (ConstantList.Count != 0) {
				return;
			}
			ConstantList.Add("e", new MathParserExpression(new Number((double)Math.E)));
			ConstantList.Add("pi", new MathParserExpression(new Number((double)Math.PI)));
			OnConstantSync?.Invoke(ref ConstantList);
		}

		public Solver()
		{
			Matrix.staticOnPrint = (Matrix matrix) =>
			{
				OnMatixPrint?.Invoke(matrix);
			};

			MatrixBuilder.staticOnFlagSync = (ref string FlagStart, ref string FlagEnd, ref string FlagElementSeperation, ref string FlagRowSeperation) =>
			{
				OnMatrixFlagSync?.Invoke(ref FlagStart, ref FlagEnd, ref FlagElementSeperation, ref FlagRowSeperation);
			};

			Number.staticOnPrint = (Number number) =>
			{
				OnNumberPrint?.Invoke(number);
			};

			//DigitalLogicSolver.syncKeyWords ();

			NonEquation.staticOnKeyWordSync += KeyWordsList;
			NonEquation.staticOnConstantSync += ConstantList;
		}

		~Solver()
		{
			NonEquation.staticOnKeyWordSync -= KeyWordsList;
			NonEquation.staticOnConstantSync -= ConstantList;
		}
		public Solver(string theExpression)
		{
			Matrix.staticOnPrint = (Matrix matrix) =>
			{
				OnMatixPrint?.Invoke(matrix);
			};

			Number.staticOnPrint = (Number number) =>
			{
				OnNumberPrint?.Invoke(number);
			};

			MatrixBuilder.staticOnFlagSync = (ref string FlagStart, ref string FlagEnd, ref string FlagRowSeperation, ref string FlagElementSeperation) =>
			{
				OnMatrixFlagSync?.Invoke(ref FlagStart, ref FlagEnd, ref FlagRowSeperation, ref FlagElementSeperation);
			};

			NonEquation.staticOnKeyWordSync += KeyWordsList;
			NonEquation.staticOnConstantSync += ConstantList;
			this.theExpression = theExpression.Trim();
			if (this.theExpression.Contains("`"))
			{
				Processed = false;
				throw new Exception("Invalid symbol \" ` \" in the string cannot proceed");
			}
			if (this.theExpression.Contains("#"))
			{
				Processed = false;
				throw new Exception("Invalid symbol \" # \" in the string cannot proceed");
			}
			if (string.IsNullOrEmpty(this.theExpression) || string.IsNullOrWhiteSpace(this.theExpression))
			{
				Processed = false;
				throw new Exception("The given Expression doen not contain any information.");
			}
			if (theExpression.Contains("E"))
			{
				this.theExpression = theExpression.Replace ("E", "*10^");
				//theExpression = theExpression.Replace ("rref","reducedRowEchelonForm");

			}
		}

		public void setMathExpression(string theExpression)
		{
			Processed = true;
			this.theExpression = theExpression.Trim();
			if (this.theExpression.Contains("`"))
			{
				Processed = false;
				throw new Exception("Invalid symbol \" ` \" in the string cannot proceed");
			}
			if (this.theExpression.Contains("#"))
			{
				Processed = false;
				throw new Exception("Invalid symbol \" # \" in the string cannot proceed");
			}
			if (string.IsNullOrEmpty(this.theExpression) || string.IsNullOrWhiteSpace(this.theExpression))
			{
				Processed = false;
				throw new Exception("The given Expression doen not contain any information.");
			}
			if (theExpression.Contains("E"))
			{
				this.
				theExpression = theExpression.Replace ("E", "*10^");
				//this.theExpression = theExpression.Replace ("rref","reducedRowEchelonForm");
			}
		}

		public void SaveHistory()
		{
			saveHistory = true;
			Checker.History = new Dictionary<string, MathParserExpression>();
		}

		public void ClearHistory()
		{
			Checker.History.Clear();
		}

		public Dictionary<string, MathParserExpression> getHistory() => Checker.History;

		public void Solve()
		{
			MathParser.StringObserver sol = new StringObserver(theExpression, Checker.History);
			if (sol.isProcessed())
			{
				solution = sol.getSolution();
			}
			else
			{
				Processed = false;
				throw new Exception("Expression Unsolvable.");
			}

			solution.Statement = theExpression;

			if (saveHistory)
			{
				if (string.IsNullOrEmpty(solution.Tag) || string.IsNullOrWhiteSpace(solution.Tag))
				{
					if (solution.Type.Contains("Number"))
					{
						string name = autoNumberNamer();
						solution.Tag = name;
						solution.setEntireTag(name);
						Checker.History.Add(name, solution);
					}
					else if (solution.Type.Contains("Matrix"))
					{
						string name = autoMatrixNamer();
						solution.Tag = name;
						solution.setEntireTag(name);
						Checker.History.Add(name, solution);
					}
				}
				else
				{
					string name = solution.Tag;
					if (Checker.History.ContainsKey(name))
					{
						//	solution.setEntireTag (name);
						Checker.History[name] = solution;
					}
					else
					{
						//  solution.setEntireTag (name);
						Checker.History.Add(name, solution);
					}
				}
			}

		}     // end method for solve

		public void PrintSolution()
		{
			if (solution.Type.Contains("Number"))
			{
				((MathParser.DataTypes.DynamicDataTypes.Number)solution.Data)?.Print();
			}
			else if (solution.Type.Contains("Matrix"))
			{
				((MathParser.DataTypes.DynamicDataTypes.Matrix)solution.Data)?.Print();
			}
		}

		int ncount = 0;
		string autoNumberNamer()
		{
			ncount++;
			string name = "n" + ncount;
			if (!Checker.History.ContainsKey(name))
			{
				return name;
			}
			else
			{
				return autoNumberNamer();
			}
		}


		int mcount = 0;
		string autoMatrixNamer()
		{
			mcount++;
			string name = "m" + mcount;
			if (!Checker.History.ContainsKey(name))
			{
				return name;
			}
			else
			{
				return autoMatrixNamer();
			}
		}

		/*public bool theExpressionContainsDigitalLogic()
		{
			List<string> theDigitalKeyWords = DigitalLogicSolver.getKeyWordsList ();
			foreach(var x in theDigitalKeyWords){
				if (theExpression.Contains (x)) {
					return true;					
				}
			}
			return false;
		}*/


		public List<string> getUnitFunctionList()
		{
			return theUnitFunctionKeyWordsList;
		}


	}
}