482 lines
15 KiB
C#
482 lines
15 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using UnityEngine;
|
|
|
|
namespace TransportGame.Utils
|
|
{
|
|
public class Expression
|
|
{
|
|
#region Types
|
|
|
|
/// <summary>
|
|
/// Token types
|
|
/// </summary>
|
|
protected enum TokenType
|
|
{
|
|
None, Literal, Identifier, Operator, ArgSeparator,
|
|
LParanthesis, RParanthesis, Function
|
|
};
|
|
|
|
/// <summary>
|
|
/// Represents a token
|
|
/// </summary>
|
|
protected class Token
|
|
{
|
|
/// <summary>
|
|
/// Token type
|
|
/// </summary>
|
|
public TokenType Type { get; set; }
|
|
|
|
/// <summary>
|
|
/// Token text
|
|
/// </summary>
|
|
public string Text { get; set; }
|
|
|
|
/// <summary>
|
|
/// Initializes a token
|
|
/// </summary>
|
|
/// <param name="type">Token type</param>
|
|
/// <param name="text">Token text</param>
|
|
public Token(TokenType type, string text)
|
|
{
|
|
Type = type;
|
|
Text = text;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public properties
|
|
/// <summary>
|
|
/// Gets the tokens in order
|
|
/// </summary>
|
|
protected List<Token> Tokens { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets the postfix expression
|
|
/// </summary>
|
|
protected List<Token> Postfix { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets the list of variables
|
|
/// </summary>
|
|
public Dictionary<string, float> Variables { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets or sets the expression string
|
|
/// </summary>
|
|
public string ExpressionString
|
|
{
|
|
get { return expressionString; }
|
|
set
|
|
{
|
|
expressionString = value;
|
|
parsed = false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private fields
|
|
|
|
private string expressionString;
|
|
private bool parsed = false;
|
|
|
|
#endregion
|
|
|
|
#region Constructor
|
|
|
|
/// <summary>
|
|
/// Initializes this instance of expression
|
|
/// </summary>
|
|
public Expression()
|
|
{
|
|
Tokens = new List<Token>();
|
|
Postfix = new List<Token>();
|
|
Variables = new Dictionary<string, float>();
|
|
|
|
Variables.Add("pi", Mathf.PI);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes this instance of expression
|
|
/// </summary>
|
|
/// <param name="expr">Expression text</param>
|
|
public Expression(string expr)
|
|
: this()
|
|
{
|
|
expressionString = expr;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Other stuff
|
|
|
|
/// <summary>
|
|
/// Adds a variable
|
|
/// </summary>
|
|
/// <param name="name">Variable name</param>
|
|
/// <param name="value">Variable value</param>
|
|
public void AddVariable(string name, float value)
|
|
{
|
|
Variables.Add(name, value);
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region Parser
|
|
|
|
private void AnalyzeLex()
|
|
{
|
|
Tokens.Clear();
|
|
|
|
for (int i = 0; i < ExpressionString.Length; i++)
|
|
{
|
|
if (char.IsWhiteSpace(ExpressionString[i])) continue;
|
|
|
|
if (IsOperator(ExpressionString[i]))
|
|
{
|
|
// Handle unary minus
|
|
if (IsUnaryMinus(ExpressionString[i]))
|
|
Tokens.Add(new Token(TokenType.Operator, "u"));
|
|
|
|
else
|
|
Tokens.Add(new Token(TokenType.Operator, ExpressionString[i].ToString()));
|
|
}
|
|
|
|
else if (ExpressionString[i] == '(')
|
|
Tokens.Add(new Token(TokenType.LParanthesis, ExpressionString[i].ToString()));
|
|
|
|
else if (ExpressionString[i] == ')')
|
|
Tokens.Add(new Token(TokenType.RParanthesis, ExpressionString[i].ToString()));
|
|
|
|
else if (ExpressionString[i] == ',')
|
|
Tokens.Add(new Token(TokenType.ArgSeparator, ExpressionString[i].ToString()));
|
|
|
|
else if (Char.IsDigit(ExpressionString[i]))
|
|
Tokens.Add(new Token(TokenType.Literal, GetLiteral(ExpressionString, ref i)));
|
|
|
|
else if (Char.IsLetter(ExpressionString[i]))
|
|
Tokens.Add(new Token(TokenType.Identifier, GetIdentifier(ExpressionString, ref i)));
|
|
|
|
else throw new Exception("Unrecognized character found!");
|
|
}
|
|
}
|
|
|
|
private void ConvertPostfix()
|
|
{
|
|
Stack<Token> stack = new Stack<Token>();
|
|
|
|
for (int i = 0; i < Tokens.Count; i++)
|
|
{
|
|
Token t = Tokens[i];
|
|
|
|
switch (t.Type)
|
|
{
|
|
case TokenType.Identifier:
|
|
|
|
// Followed by '(' means function
|
|
if (i + 1 < Tokens.Count && Tokens[i + 1].Type == TokenType.LParanthesis)
|
|
stack.Push(new Token(TokenType.Function, t.Text));
|
|
|
|
// Else, variable
|
|
else Postfix.Add(t);
|
|
|
|
break;
|
|
|
|
case TokenType.Literal:
|
|
Postfix.Add(t);
|
|
break;
|
|
|
|
case TokenType.ArgSeparator:
|
|
|
|
// We pop everything from the stack until left paranthesis open
|
|
while (stack.Peek().Type != TokenType.LParanthesis)
|
|
{
|
|
Postfix.Add(stack.Pop());
|
|
|
|
if (stack.Count == 0)
|
|
throw new Exception("Syntax error! Unexpected comma.");
|
|
}
|
|
|
|
break;
|
|
|
|
case TokenType.Operator:
|
|
|
|
if (IsLeftAssociative(t.Text))
|
|
{
|
|
while (stack.Count != 0 && Precedence(t.Text) <= Precedence(stack.Peek().Text))
|
|
Postfix.Add(stack.Pop());
|
|
}
|
|
|
|
else
|
|
{
|
|
while (stack.Count != 0 && Precedence(t.Text) < Precedence(stack.Peek().Text))
|
|
Postfix.Add(stack.Pop());
|
|
}
|
|
|
|
stack.Push(t);
|
|
break;
|
|
|
|
case TokenType.LParanthesis:
|
|
stack.Push(t);
|
|
break;
|
|
|
|
case TokenType.RParanthesis:
|
|
|
|
while (stack.Peek().Type != TokenType.LParanthesis)
|
|
{
|
|
Postfix.Add(stack.Pop());
|
|
|
|
if (stack.Count == 0)
|
|
throw new Exception("Mismatched parantheses!");
|
|
}
|
|
|
|
stack.Pop(); // Pop Lparanthesis
|
|
|
|
if (stack.Count > 0 && stack.Peek().Type == TokenType.Function)
|
|
Postfix.Add(stack.Pop()); // Pop function name
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (stack.Count > 0)
|
|
{
|
|
if (stack.Peek().Type == TokenType.LParanthesis)
|
|
throw new Exception("Mismatched parantheses!");
|
|
|
|
Postfix.Add(stack.Pop());
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parses the expression
|
|
/// </summary>
|
|
public void ParseExpression()
|
|
{
|
|
if (!parsed)
|
|
{
|
|
Tokens.Clear();
|
|
Postfix.Clear();
|
|
|
|
AnalyzeLex();
|
|
ConvertPostfix();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Evaluates the expression, and parses it if not parsed yet.
|
|
/// </summary>
|
|
/// <returns>Result of evaluation</returns>
|
|
public float Evaluate()
|
|
{
|
|
// Parse expression first
|
|
ParseExpression();
|
|
|
|
// Expression is empty, so is result
|
|
if (Postfix.Count == 0)
|
|
return 0;
|
|
|
|
Stack<float> stack = new Stack<float>();
|
|
|
|
foreach (var t in Postfix)
|
|
{
|
|
switch (t.Type)
|
|
{
|
|
// We already replace functions, so identifiers are variables
|
|
case TokenType.Identifier:
|
|
|
|
if (!Variables.ContainsKey(t.Text))
|
|
throw new Exception("Undefined variable '" + t.Text + "'.");
|
|
|
|
stack.Push(Variables[t.Text]);
|
|
break;
|
|
|
|
case TokenType.Literal:
|
|
stack.Push(float.Parse(t.Text));
|
|
break;
|
|
|
|
case TokenType.Operator:
|
|
switch (t.Text)
|
|
{
|
|
case "u":
|
|
stack.Push(stack.Pop() * -1);
|
|
break;
|
|
|
|
case "+":
|
|
stack.Push(stack.Pop() + stack.Pop());
|
|
break;
|
|
|
|
case "-":
|
|
{
|
|
float b = stack.Pop();
|
|
float a = stack.Pop();
|
|
stack.Push(a - b);
|
|
}
|
|
break;
|
|
|
|
case "*":
|
|
stack.Push(stack.Pop() * stack.Pop());
|
|
break;
|
|
|
|
case "/":
|
|
{
|
|
float b = stack.Pop();
|
|
float a = stack.Pop();
|
|
stack.Push(a / b);
|
|
}
|
|
break;
|
|
|
|
case "%":
|
|
{
|
|
float b = stack.Pop();
|
|
float a = stack.Pop();
|
|
stack.Push(a % b);
|
|
}
|
|
break;
|
|
|
|
case "^":
|
|
{
|
|
float b = stack.Pop();
|
|
float a = stack.Pop();
|
|
stack.Push(Mathf.Pow(a, b));
|
|
}
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case TokenType.Function:
|
|
EvaluateFunction(t.Text, ref stack);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return stack.Pop();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helper routines
|
|
|
|
private bool IsUnaryMinus(char c)
|
|
{
|
|
if (c == '-')
|
|
{
|
|
// Nothing in front, definitely unary
|
|
if (Tokens.Count == 0)
|
|
return true;
|
|
|
|
// See what's in front
|
|
TokenType inFront = Tokens.Last().Type;
|
|
|
|
// If what's in front cannot be an operand, than it is unary minus
|
|
return inFront == TokenType.ArgSeparator || inFront == TokenType.LParanthesis || inFront == TokenType.Operator;
|
|
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void EvaluateFunction(string func, ref Stack<float> stack)
|
|
{
|
|
switch (func)
|
|
{
|
|
case "sin": stack.Push(Mathf.Sin(stack.Pop())); break;
|
|
case "cos": stack.Push(Mathf.Cos(stack.Pop())); break;
|
|
case "tan": stack.Push(Mathf.Tan(stack.Pop())); break;
|
|
case "ctan": stack.Push(1 / Mathf.Tan(stack.Pop())); break;
|
|
|
|
case "arcsin": stack.Push(Mathf.Asin(stack.Pop())); break;
|
|
case "asin": stack.Push(Mathf.Asin(stack.Pop())); break;
|
|
case "arccos": stack.Push(Mathf.Acos(stack.Pop())); break;
|
|
case "acos": stack.Push(Mathf.Acos(stack.Pop())); break;
|
|
case "arctan": stack.Push(Mathf.Atan(stack.Pop())); break;
|
|
case "atan": stack.Push(Mathf.Atan(stack.Pop())); break;
|
|
|
|
case "truncate":
|
|
case "floor": stack.Push(Mathf.Floor(stack.Pop())); break;
|
|
case "ceil":
|
|
case "ceiling": stack.Push(Mathf.Ceil(stack.Pop())); break;
|
|
|
|
case "sqrt": stack.Push(Mathf.Sqrt(stack.Pop())); break;
|
|
case "cbrt": stack.Push(Mathf.Pow(stack.Pop(), 1.0f / 3.0f)); break;
|
|
case "root": stack.Push(Mathf.Pow(stack.Pop(), 1 / stack.Pop())); break;
|
|
|
|
case "abs": stack.Push(Math.Abs(stack.Pop())); break;
|
|
case "max": stack.Push(Math.Max(stack.Pop(), stack.Pop())); break;
|
|
case "min": stack.Push(Math.Min(stack.Pop(), stack.Pop())); break;
|
|
|
|
case "lg": stack.Push(Mathf.Log10(stack.Pop())); break;
|
|
case "log": stack.Push(Mathf.Log(stack.Pop(), stack.Pop())); break;
|
|
|
|
case "clamp01": stack.Push(Mathf.Clamp01(stack.Pop())); break;
|
|
case "clamp": stack.Push(Mathf.Clamp(stack.Pop(), stack.Pop(), stack.Pop())); break;
|
|
case "lerp": stack.Push(Mathf.Lerp(stack.Pop(), stack.Pop(), stack.Pop())); break;
|
|
|
|
default: throw new Exception("Undefined function '" + func + "'.");
|
|
}
|
|
}
|
|
|
|
private static bool IsLeftAssociative(string op)
|
|
{
|
|
return (op != "^");
|
|
}
|
|
|
|
private static int Precedence(string op)
|
|
{
|
|
switch (op)
|
|
{
|
|
case "+":
|
|
case "-": return 1;
|
|
|
|
case "*":
|
|
case "/":
|
|
case "%": return 2;
|
|
|
|
case "u":
|
|
case "^": return 3;
|
|
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
private static bool IsOperator(char c)
|
|
{
|
|
const string operators = "+-*/%^";
|
|
return operators.Contains(c);
|
|
}
|
|
|
|
private static string GetIdentifier(string s, ref int index)
|
|
{
|
|
int start = index;
|
|
|
|
while (index < s.Length && (char.IsLetterOrDigit(s[index]) || s[index] == '_'))
|
|
++index;
|
|
|
|
index -= 1;
|
|
|
|
return s.Substring(start, index + 1 - start);
|
|
}
|
|
|
|
private static string GetLiteral(string s, ref int index)
|
|
{
|
|
int start = index;
|
|
|
|
while (index < s.Length && (char.IsDigit(s[index]) || s[index] == '.'))
|
|
++index;
|
|
|
|
index -= 1;
|
|
|
|
return s.Substring(start, index + 1 - start);
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|