Строганцев Антон

.gitignore

@@ -1,3 +1,5 @@
+build/
+
 # Prerequisites
 *.d
 

CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.5)
+project(ArithmeticParser LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+FILE(GLOB SRC_HPP "src/*.hpp")
+
+add_executable(${PROJECT_NAME} "src/main.cpp" ${SRC_HPP})

src/Computer.hpp

@@ -0,0 +1,51 @@
+#pragma once 
+#include "Token.hpp"
+#include "Variables.hpp"
+#include "Expression.hpp"
+#include "Operations.hpp"
+
+namespace ap
+{
+	class Computer
+	{
+	public:
+		Computer(const Expression& exprGraphg, const Variables& variables) :
+			_graph(exprGraphg),
+			_variables(variables)
+		{	}
+
+		double compute()
+		{
+			return compute(_graph);
+		}
+
+	private:
+		const Expression& _graph;
+		const Variables& _variables;
+
+		double compute(const Expression& expr)
+		{
+			TokenType type = expr.token.type;
+			if (type == TokenType::DIGIT)
+				return std::stod(expr.token.expr);
+			else if (type == TokenType::VARIABLE)
+				return _variables.findVariable(expr.token.expr)->second;
+			else if (type == TokenType::UNARY_OPERATOR)
+				return applyUnaryOperation(expr.token.expr, expr.operands[0]);
+			else if (type == TokenType::BINARY_OPERATOR)
+				return applyBinaryOperation(expr.token.expr, expr.operands[0], expr.operands[1]);
+			else
+				throw std::runtime_error("unordered TokenType");
+		}
+
+		double applyUnaryOperation(const std::string& operation, const Expression& expr)
+		{
+			return Operations::Instance().findUnaryBySymbols(operation)->compute(compute(expr));
+		}
+
+		double applyBinaryOperation(const std::string& operation, const Expression& expr1, const Expression& expr2)
+		{
+			return Operations::Instance().findBinaryBySymbols(operation)->compute(compute(expr1), compute(expr2));
+		}
+	};
+}

src/Exceptions.hpp

@@ -0,0 +1,38 @@
+#pragma once
+#include <string>
+#include <stdexcept>
+
+namespace ap
+{
+	class UnorderedSymbols : public std::runtime_error
+	{
+	public:
+		UnorderedSymbols(size_t where, const std::string& ch) :
+			std::runtime_error("Unordered symbols at " + std::to_string(where) + " : \"" + ch + "\"")
+		{	}
+
+		UnorderedSymbols(size_t where, char ch) :
+			UnorderedSymbols(where, std::string() + ch)
+		{	}
+	};
+
+	class UnexpectedSymbols : public std::runtime_error
+	{
+	public:
+		UnexpectedSymbols(size_t where, const std::string& ch) :
+			std::runtime_error("Unexpected symbols at " + std::to_string(where) + " : \"" + ch + "\"")
+		{	}
+
+		UnexpectedSymbols(size_t where, char ch) :
+			UnexpectedSymbols(where, std::string() + ch)
+		{	}
+	};
+
+	class ExpectedSymbols : public std::runtime_error
+	{
+	public:
+		ExpectedSymbols(size_t where, const std::string& expectedChar) :
+			std::runtime_error("Symbol \"" + std::string(expectedChar) + std::string("\" expected at ") + std::to_string(where))
+		{	}
+	};
+}

src/Expression.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#include <string>
+#include <vector>
+#include "Token.hpp"
+
+namespace ap
+{
+	struct Expression
+	{
+		Expression(Token digit) :
+			token(digit)
+		{	}
+
+		Expression(Token operation, Expression operand) :
+			token(operation),
+			operands{ operand }
+		{	}
+
+		Expression(Token operation, Expression operand1, Expression operand2) :
+			token(operation),
+			operands{ operand1, operand2 }
+		{	}
+
+		Token token;
+		std::vector<Expression> operands;
+	};
+}

src/Operations.hpp

@@ -0,0 +1,135 @@
+#pragma once 
+#include <vector>
+
+namespace ap
+{
+	class IUnaryOperation
+	{
+	public:
+		virtual std::string getSymbols() = 0;
+		virtual double compute(double arg) = 0;
+	};
+
+	class IBinaryOperation
+	{
+	public:
+		virtual int getPriority() = 0;
+		virtual std::string getSymbols() = 0;
+		virtual double compute(double arg1, double arg2) = 0;
+	};
+
+
+	class UnaryMinus : public IUnaryOperation
+	{
+		virtual std::string getSymbols() override { return "-"; }
+		virtual double compute(double arg) override { return -arg; }
+	};
+
+	class Sinus : public IUnaryOperation
+	{
+		virtual std::string getSymbols() override { return "sin"; }
+		virtual double compute(double arg) override { return std::sin(arg); }
+	};
+
+	class Cosinus : public IUnaryOperation
+	{
+		virtual std::string getSymbols() override { return "cos"; }
+		virtual double compute(double arg) override { return std::cos(arg); }
+	};
+
+	class BinaryPlus : public IBinaryOperation
+	{
+	public:
+		virtual int getPriority() override { return 10; }
+		virtual std::string getSymbols() override { return "+"; }
+		virtual double compute(double arg1, double arg2) override { return arg1 + arg2; }
+	};
+
+	class BinaryMinus : public IBinaryOperation
+	{
+	public:
+		virtual int getPriority() override { return 10; }
+		virtual std::string getSymbols() override { return "-"; }
+		virtual double compute(double arg1, double arg2) override { return arg1 - arg2; }
+	};
+
+	class Multiplication : public IBinaryOperation
+	{
+	public:
+		virtual int getPriority() override { return 30; }
+		virtual std::string getSymbols() override { return "*"; }
+		virtual double compute(double arg1, double arg2) override { return arg1 * arg2; }
+	};
+
+	class Division : public IBinaryOperation
+	{
+	public:
+		virtual int getPriority() override { return 40; }
+		virtual std::string getSymbols() override { return "/"; }
+		virtual double compute(double arg1, double arg2) override { return arg1 / arg2; }
+	};
+
+	class Pow : public IBinaryOperation
+	{
+	public:
+		virtual int getPriority() override { return 50; }
+		virtual std::string getSymbols() override { return "^"; }
+		virtual double compute(double arg1, double arg2) override { return std::pow(arg1, arg2); }
+	};
+
+	// ��� ���������� �������� - �������� �� ��������� � ������ ���������������� ���� �������� � Operations()
+	class Operations
+	{
+		using TUnarys = std::vector<std::unique_ptr<IUnaryOperation>>;
+		using TBinarys = std::vector<std::unique_ptr<IBinaryOperation>>;
+	public:
+		static Operations& Instance()
+		{
+			static Operations operations;
+			return operations;
+		}
+
+		IUnaryOperation* findUnaryBySymbols(const std::string& symbols) const
+		{
+			for (const auto& operation : _unarys)
+				if (std::strncmp(operation->getSymbols().c_str(), symbols.c_str(), operation->getSymbols().size()) == 0)
+					return operation.get();
+			return nullptr;
+		}
+
+		IBinaryOperation* findBinaryBySymbols(const std::string& symbols) const
+		{
+			for (const auto& operation : _binarys)
+				if (std::strncmp(operation->getSymbols().c_str(), symbols.c_str(), operation->getSymbols().size()) == 0)
+					return operation.get();
+			return nullptr;
+		}
+
+		const TUnarys& getUnarys()
+		{
+			return _unarys;
+		}
+
+		const TBinarys& getBynarys()
+		{
+			return _binarys;
+		}
+
+	private:
+		TUnarys _unarys;
+		TBinarys _binarys;
+
+		Operations()
+		{
+			_unarys.emplace_back(new UnaryMinus());
+			_unarys.emplace_back(new Sinus());
+			_unarys.emplace_back(new Cosinus());
+
+			_binarys.emplace_back(new BinaryPlus());
+			_binarys.emplace_back(new BinaryMinus());
+			_binarys.emplace_back(new Multiplication());
+			_binarys.emplace_back(new Division());
+			_binarys.emplace_back(new Pow());
+		}
+	};
+}