using System;
using System.Collections.Generic;
using System.Linq;
namespace Lib.Mathematics
{
public class Expression
{
internal Expression()
{
}
private List<Stack> _stacks = new List<Stack>();
public object Result { get; set; }
public string Term
{
get { return _term; }
internal set { _term = value;}
}
public readonly Dictionary<string, Expression> Variables = new Dictionary<string, Expression>();
private string _term;
public static Expression Parse(string expr)
{
var returns = new Expression {Term = expr};
expr = expr.Replace("²", "²0");
expr = expr.Replace("³", "³0");
expr = expr.Replace("sqrt[", "√");
expr = expr.Replace("pi", "π");
expr = expr.Replace("]", "");
expr = expr.Replace("√", "1√");
expr = expr.Replace("π", "1π1");
expr = expr.Replace("True", "1");
expr = expr.Replace("False", "0");
expr = returns.Variables.Aggregate(expr, (current, var) => current.Replace(var.Key + "*1", var.Value));
var chars = expr.ToCharArray();
var result = "";
foreach (var c in chars)
{
if (isNum(c))
{
result += c;
}
else
{
if (isOP(c))
{
returns._stacks.Add(new NumStack(Convert.ToDouble(result)));
returns._stacks.Add(new OpStack(c.ToString()));
result = "";
}
}
}
returns._stacks.Add(returns.getLastNum(expr));
returns._stacks = returns.dotbeforestatement(returns._stacks);
returns.Calculate();
return returns;
}
internal void Calculate()
{
for (var i = 0; i < _stacks.Count - 1; i++)
{
var stack = _stacks[i];
var opStack = stack as OpStack;
if (opStack != null)
{
var first = (NumStack)_stacks[i - 1];
var second = (NumStack)_stacks[i + 1];
var op = opStack;
var _result = new NumStack(0);
var resultisbool = false;
var boolresult = false;
switch (op.Value)
{
case "+":
_result = new NumStack(first.Value + second.Value);
break;
case "-":
_result = new NumStack(first.Value - second.Value);
break;
case "*":
_result = new NumStack(first.Value * second.Value);
break;
case "/":
_result = new NumStack(first.Value / second.Value);
break;
case "^":
_result = new NumStack(Math.Pow(first.Value, second.Value));
break;
case "%":
_result = new NumStack(first.Value % second.Value);
break;
case "&":
_result = new NumStack(Convert.ToDouble(first.Value.ToString() + second.Value.ToString()));
break;
case "²":
_result = new NumStack(first.Value * first.Value);
break;
case "³":
_result = new NumStack(first.Value * first.Value * first.Value);
break;
case "√":
_result = new NumStack(Math.Sqrt(second.Value));
break;
case "π":
_result = new NumStack(Math.PI);
break;
case "<":
resultisbool = true;
boolresult = first.Value < second.Value;
break;
case ">":
resultisbool = true;
boolresult = first.Value > second.Value;
break;
case "!":
resultisbool = true;
boolresult = first.Value != second.Value;
break;
}
_stacks.RemoveAt(0);
_stacks.RemoveAt(0);
_stacks.RemoveAt(0);
_stacks.Insert(0, _result);
Result = (_stacks[0] as NumStack).Value;
if (_stacks.Count != 1)
{
if (_stacks[0] != null && _stacks[1] != null && _stacks[2] != null)
{
Calculate();
}
}
if (resultisbool)
{
Result = boolresult;
}
}
}
}
#region "ObjectOperators"
public static Expression operator +(Expression e1, Expression e2)
{
return Parse(e1.Result + "+" + e2.Result);
}
public static bool operator ==(Expression e1, Expression e2)
{
return e1 == e2;
}
public static bool operator !=(Expression e1, Expression e2)
{
return e1 != e2;
}
public static Expression operator +(Expression e1, string e2)
{
e2 = e2.Replace("=", "");
return Parse(e2);
}
public static Expression operator -(Expression e1, Expression e2)
{
return Parse(e1.Result + "-" + e2.Result);
}
public static Expression operator *(Expression e1, Expression e2)
{
return Parse(e1.Result + "*" + e2.Result);
}
public static Expression operator /(Expression e1, Expression e2)
{
return Parse(e1.Result + "/" + e2.Result);
}
public static Expression operator <(Expression e1, Expression e2)
{
return Parse(e1.Result + "<" + e2.Result);
}
public static Expression operator >(Expression e1, Expression e2)
{
return Parse(e1.Result + ">" + e2.Result);
}
public static implicit operator Expression(string v)
{
return Parse(v);
}
public static implicit operator double(Expression instance)
{
return (double) instance.Result;
}
public static implicit operator bool(Expression instance)
{
return (bool) instance.Result;
}
public static implicit operator string(Expression instance)
{
return instance.Result.ToString();
}
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return false;
}
return base.Equals(obj);
}
#endregion
#region "Help Functions"
private static bool isNum(char s)
{
double result;
return double.TryParse(s.ToString(), out result);
}
private static bool isOP(char s)
{
return s == '+' | s == '-' | s == '*' | s == '/' | s == '^' | s == '%' | s == '&' | s == '²' | s == '3' | s == '<' | s == '>' | s == '!' | s == '√' | s == 'π';
}
private bool isPunctiaton(char s)
{
return s == '*' | s == '/';
}
private bool isBracketOpen(char s)
{
return s == '(';
}
private bool isBracketClosed(char s)
{
return s == ')';
}
private NumStack getLastNum(string s)
{
var c = s.Split(Convert.ToChar((_stacks[_stacks.Count - 1] as OpStack).Value));
return new NumStack(Convert.ToInt32(c[c.Length - 1]));
}
private List<Stack> dotbeforestatement(List<Stack> st)
{
var returns = st;
for (var i = 0; i < st.Count; i++)
{
var s = st[i];
if (s is OpStack)
{
var op = s as OpStack;
if (isPunctiaton(Convert.ToChar(op.Value)))
{
if (st.Count < 3)
{
var firstop = st[i - 2];
var first = st[i - 1];
var ops = s;
var second = st[i + 1];
returns.Remove(first);
returns.Remove(ops);
returns.Remove(second);
returns.Remove(firstop);
returns.InsertRange(0, new[] { first, ops, second, firstop });
}
}
}
}
return returns;
}
#endregion
#region "Implementations"
public override int GetHashCode()
{
return base.GetHashCode();
}
public Expression Clone()
{
return this;
}
public override string ToString()
{
return Result.ToString();
}
#endregion
}
}
namespace Lib.Mathematics
{
public class CalcedStack : Stack
{
public NumStack first { get; set; }
public OpStack op { get; set; }
public NumStack second { get; set; }
public NumStack result { get; set; }
public CalcedStack()
{
first = new NumStack(0);
op = new OpStack("");
second = new NumStack(0);
}
public override string ToString()
{
return first.Value.ToString() + op.Value + second.Value.ToString();
}
}
}
namespace Lib.Mathematics
{
public class NumStack : Stack<double>
{
public NumStack(double v)
: base(v)
{
}
}
}
namespace Lib.Mathematics
{
public class OpStack : Stack<string>
{
public OpStack(string v)
: base(v)
{
}
}
}
namespace Lib.Mathematics
{
public abstract class Stack<t> : Stack
{
public t Value { get; set; }
protected Stack(t v)
{
Value = v;
}
public override string ToString()
{
return Value.ToString();
}
}
public abstract class Stack
{
}
}
