Query/AppCalc/App.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Base;

namespace AppCalc {
	public sealed class App : IApp {
		private static readonly Regex RegexValidCharacters = new Regex(@"^[\s\d\.\-+*/%^]+$", RegexOptions.Compiled);
		private static readonly Regex RegexTokenSeparator = new Regex(@"((?<!\d)-?(((\d+)?\.\d+(\.\.\.)?)|\d+))|[^\d\s]", RegexOptions.ExplicitCapture | RegexOptions.Compiled);
		private static readonly Regex RegexRecurringDecimal = new Regex(@"\b(?:(\d+?\.\d{0,}?)(\d+?)\2+|([\d+?\.]*))\b", RegexOptions.Compiled);

		private static readonly char[] SplitSpace = { ' ' };

		public string[] RecognizedNames => new string[] {
			"calc",
			"calculate",
			"calculator"
		};

		public MatchConfidence GetConfidence(Command cmd) {
			return RegexValidCharacters.IsMatch(cmd.Text) ? MatchConfidence.Possible : MatchConfidence.None;
		}

		string IApp.ProcessCommand(Command cmd) {
			return ParseAndProcessExpression(cmd.Text);
		}

		private static string ParseAndProcessExpression(string text) {
			// text = RegexBalancedParentheses.Replace(text, match => " "+ParseAndProcessExpression(match.Groups[1].Value)+" "); // parens are handled as apps

			string expression = RegexTokenSeparator.Replace(text, match => " " + match.Value + " ");
			string[] tokens = expression.Split(SplitSpace, StringSplitOptions.RemoveEmptyEntries);

			decimal result = ProcessExpression(tokens);

			if (Math.Abs(result - decimal.Round(result)) < 0.0000000000000000000000000010M) {
				return decimal.Round(result).ToString(CultureInfo.InvariantCulture);
			}

			string res = result.ToString(CultureInfo.InvariantCulture);
			bool hasDecimalPoint = decimal.Round(result) != result;

			if (res.Length == 30 && hasDecimalPoint && res.IndexOf('.') < 15) { // Length 30 uses all available bytes
				res = res.Substring(0, res.Length - 1);

				Match match = RegexRecurringDecimal.Match(res);

				if (match.Groups[2].Success) {
					string repeating = match.Groups[2].Value;

					StringBuilder build = new StringBuilder(34);
					build.Append(match.Groups[1].Value);

					do {
						build.Append(repeating);
					} while (build.Length + repeating.Length <= res.Length);

					return build.Append(repeating.Substring(0, 1 + build.Length - res.Length)).Append("...").ToString();
				}
			}
			else if (hasDecimalPoint) {
				res = res.TrimEnd('0');
			}

			return res;
		}

		private static decimal ProcessExpression(string[] tokens) {
			bool isPostfix;

			if (tokens.Length < 3) {
				isPostfix = false;
			}
			else {
				try {
					ParseNumberToken(tokens[0]);
				} catch (CommandException) {
					throw new CommandException("Prefix notation is not supported.");
				}

				try {
					ParseNumberToken(tokens[1]);
					isPostfix = true;
				} catch (CommandException) {
					isPostfix = false;
				}
			}

			if (isPostfix) {
				return ProcessPostfixExpression(tokens);
			}
			else {
				return ProcessPostfixExpression(ConvertInfixToPostfix(tokens));
			}
		}

		private static IEnumerable<string> ConvertInfixToPostfix(IEnumerable<string> tokens) {
			Stack<string> operators = new Stack<string>();

			foreach (string token in tokens) {
				if (Operators.With2Operands.Contains(token)) {
					int currentPrecedence = Operators.GetPrecedence(token);
					bool currentRightAssociative = Operators.IsRightAssociative(token);

					while (operators.Count > 0) {
						int topPrecedence = Operators.GetPrecedence(operators.Peek());

						if ((currentRightAssociative && currentPrecedence < topPrecedence) || (!currentRightAssociative && currentPrecedence <= topPrecedence)) {
							yield return operators.Pop();
						}
						else {
							break;
						}
					}

					operators.Push(token);
				}
				else {
					yield return ParseNumberToken(token).ToString(CultureInfo.InvariantCulture);
				}
			}

			while (operators.Count > 0) {
				yield return operators.Pop();
			}
		}

		private static decimal ProcessPostfixExpression(IEnumerable<string> tokens) {
			Stack<decimal> stack = new Stack<decimal>();

			foreach (string token in tokens) {
				decimal operand1, operand2;

				if (token == "-" && stack.Count == 1) {
					operand2 = stack.Pop();
					operand1 = 0M;
				}
				else if (Operators.With2Operands.Contains(token)) {
					if (stack.Count < 2) {
						throw new CommandException("Incorrect syntax, not enough numbers in stack.");
					}

					operand2 = stack.Pop();
					operand1 = stack.Pop();
				}
				else {
					operand1 = operand2 = 0M;
				}

				switch (token) {
					case "+":
						stack.Push(operand1 + operand2);
						break;
					case "-":
						stack.Push(operand1 - operand2);
						break;
					case "*":
						stack.Push(operand1 * operand2);
						break;

					case "/":
						if (operand2 == 0M) {
							throw new CommandException("Cannot divide by zero.");
						}

						stack.Push(operand1 / operand2);
						break;

					case "%":
						if (operand2 == 0M) {
							throw new CommandException("Cannot divide by zero.");
						}

						stack.Push(operand1 % operand2);
						break;

					case "^":
						if (operand1 == 0M && operand2 == 0M) {
							throw new CommandException("Cannot evaluate 0 to the power of 0.");
						}
						else if (operand1 < 0M && Math.Abs(operand2) < 1M) {
							throw new CommandException("Cannot evaluate a root of a negative number.");
						}

						try {
							stack.Push((decimal) Math.Pow((double) operand1, (double) operand2));
						} catch (OverflowException ex) {
							throw new CommandException("Number overflow.", ex);
						}

						break;

					default:
						stack.Push(ParseNumberToken(token));
						break;
				}
			}

			if (stack.Count != 1) {
				throw new CommandException("Incorrect syntax, too many numbers in stack.");
			}

			return stack.Pop();
		}

		private static decimal ParseNumberToken(string token) {
			string str = token;

			if (str.StartsWith("-.")) {
				str = "-0" + str.Substring(1);
			}
			else if (str[0] == '.') {
				str = "0" + str;
			}

			if (str.EndsWith("...")) {
				string truncated = str.Substring(0, str.Length - 3);

				if (truncated.IndexOf('.') != -1) {
					str = truncated;
				}
			}

			decimal value;

			if (decimal.TryParse(str, NumberStyles.Float, CultureInfo.InvariantCulture, out value)) {
				if (value.ToString(CultureInfo.InvariantCulture) != str) {
					throw new CommandException("Provided number is outside of decimal range: " + token);
				}

				return value;
			}
			else {
				throw new CommandException("Invalid token, expected a number: " + token);
			}
		}
	}
}