add operator conversion for efficient parallelizing

inc/expression.hpp

@@ -110,6 +110,12 @@ public:
 		case OPERATOR:
 			v.o = other.v.o;
 			break;
+		case CV:
+			v.cv.w = other.v.cv.w;
+			v.cv.i = other.v.cv.i;
+			break;
+		case NAT:
+			break;
 		default:
 			std::cout << "Warning: token type is invalid\n";
 			break;
@@ -131,12 +137,47 @@ public:
 		case OPERATOR:
 			v.o = other.v.o;
 			break;
+		case CV:
+			v.cv.w = other.v.cv.w;
+			v.cv.i = other.v.cv.i;
+			break;
+		case NAT:
+			break;
 		default:
 			std::cout << "Warning: token type is invalid\n";
 			break;
 		}
 	}
 
+	Expression::Token& operator=(const Expression::Token& other)
+	{
+		t = other.t;
+
+		switch (t)
+		{
+		case VAR:
+			v.s = other.v.s;
+			break;
+		case CONST:
+			v.d = other.v.d;
+			break;
+		case OPERATOR:
+			v.o = other.v.o;
+			break;
+		case CV:
+			v.cv.w = other.v.cv.w;
+			v.cv.i = other.v.cv.i;
+			break;
+		case NAT:
+			break;
+		default:
+			std::cout << "Warning: token type is invalid\n";
+			break;
+		}
+
+		return const_cast<Expression::Token&>(other);
+	}
+
 	std::shared_ptr<std::string> to_str(void) const
 	{
 		switch (t)

inc/parser.hpp

@@ -8,5 +8,6 @@ namespace Parser {
 std::vector<Expression::Token> tokenize_input(const char * const input_string);
 int assert_same(const std::vector<Expression::Token>& a, const std::vector<Expression::Token>& b);
 void print_token_vector(const std::vector<Expression::Token>& tv);
+void print_math_vector(const std::vector<Expression::Token>& tv);
 
 }

inc/syntaxer.hpp

@@ -12,6 +12,7 @@ struct SyntaxIssue
 };
 
 std::vector<SyntaxIssue> check_syntax(std::vector<Expression::Token>& tv);
+void apply_corrections(std::vector<Expression::Token>& tv);
 std::vector<Expression::Operation> build_op_vector(const std::vector<Expression::Token>& tv);
 
 }

src/parser.cpp

@@ -381,4 +381,15 @@ void print_token_vector(const std::vector<Expression::Token>& tv)
 	std::cout << "(" << *tv[i].to_str() << ")\n";
 }
 
+void print_math_vector(const std::vector<Expression::Token>& tv)
+{
+	int i, l;
+	for (i = 0, l = tv.size() - 1; i < l; i++)
+	{
+		std::cout << *tv[i].to_math_str() << " ";
+	}
+
+	std::cout << *tv[i].to_math_str() << "\n";
+}
+
 }

src/syntaxer.cpp

@@ -1,4 +1,5 @@
 #include "syntaxer.hpp"
+#include "parser.hpp"
 #include "expression.hpp"
 #include <vector>
 #include "print.h"
@@ -83,7 +84,7 @@ static int get_operator_weight(const std::vector<Expression::Token>& v, int loca
 	return weight;
 }
 
-static int get_min(const std::vector<int>& v)
+static int get_min_index(const std::vector<int>& v)
 {
 	int idx = 0;
 
@@ -98,6 +99,21 @@ static int get_min(const std::vector<int>& v)
 	return idx;
 }
 
+static int get_max_index(const std::vector<int>& v)
+{
+	int idx = 0;
+
+	for (int i = 1, l = v.size(); i < l; i++)
+	{
+		if (v[i] > v[idx])
+		{
+			idx = i;
+		}
+	}
+
+	return idx;
+}
+
 static void write_operation(
 		std::vector<Expression::Operation>& ov,
 		const std::vector<Expression::Token>& tv,
@@ -138,6 +154,66 @@ static void write_operation(
 	mp.erase(mp.begin() + position, mp.begin() + position + 1);
 }
 
+static void add_bracket_to(std::vector<Expression::Token>& tv, const int location, const int direction)
+{
+	int i = location + direction, l = tv.size(), lv = 0;
+
+	if (direction == -1)
+	{
+		for (; i >= 0; i--)
+		{
+			if (tv[i].t == Expression::Token::OPERATOR)
+			{
+				switch (tv[i].v.o)
+				{
+				case Expression::Token::OPA:
+					lv--;
+					break;
+				case Expression::Token::CPA:
+					lv++;
+					break;
+				default:
+					if (!lv)
+					{
+						tv.insert(tv.begin() + i + 1, Expression::Token(Expression::Token::OPA));
+						return;
+					}
+					break;
+				}
+			}
+		}
+
+		tv.insert(tv.begin(), Expression::Token(Expression::Token::OPA));
+	}
+	else if (direction == 1)
+	{
+		for (; i < l; i++)
+		{
+			if (tv[i].t == Expression::Token::OPERATOR)
+			{
+				switch (tv[i].v.o)
+				{
+				case Expression::Token::OPA:
+					lv++;
+					break;
+				case Expression::Token::CPA:
+					lv--;
+					break;
+				default:
+					if (!lv)
+					{
+						tv.insert(tv.begin() + i, Expression::Token(Expression::Token::CPA));
+						return;
+					}
+					break;
+				}
+			}
+		}
+
+		tv.emplace_back(Expression::Token::CPA);
+	}
+}
+
 static void create_prios_vector(const std::vector<Expression::Token>& tv, std::vector<int>& pv)
 {
 	for (int i = 0, cp = 0, l = tv.size(); i < l; i++)
@@ -183,6 +259,62 @@ static void find_top_prio_op_range(const std::vector<int>& mp, int& start, int&
 	}
 }
 
+struct Range
+{
+	int start, finish;
+
+	Range(int start, int finish)
+		: start(start), finish(finish)
+	{
+	}
+};
+
+static void find_select_prio_op_ranges(const std::vector<int>& mp, std::vector<Range>& ranges, int target_prio)
+{
+	for (int i = 0, l = mp.size(), prio = 0, recording_range = 0; i < l; i++)
+	{
+		if (mp[i] == target_prio && !recording_range)
+		{
+			recording_range = 1;
+			ranges.emplace_back(i, 0);
+		}
+		else if (mp[i] == target_prio && recording_range)
+		{
+			ranges.back().finish = i;
+		}
+		else if (mp[i] != target_prio && recording_range)
+		{
+			recording_range = 0;
+		}
+	}
+}
+
+static void rank_inner_ops_raw(std::vector<int>& inner_op_ranks, const std::vector<Expression::Token>& mv, const int start, const int finish)
+{
+	for (int i = 0, lvl = 0; i < finish - start + 1; i++)
+	{
+		int idx = get_mop_location(mv, start + i);
+
+		switch (mv[idx].v.o)
+		{
+		case Expression::Token::ADD:
+		case Expression::Token::SUB:
+			inner_op_ranks.push_back(0);
+			break;
+		case Expression::Token::MUL:
+		case Expression::Token::DIV:
+			inner_op_ranks.push_back(1);
+			break;
+		case Expression::Token::POW:
+			inner_op_ranks.push_back(2);
+			break;
+		default:
+			pr_warn("Operator is unrankable");
+			break;
+		}
+	}
+}
+
 static void rank_inner_ops(std::vector<int>& inner_top_ops, const std::vector<Expression::Token>& mv, const int start, const int finish)
 {
 	for (int i = 0, lvl = 0; i < finish - start + 1; i++)
@@ -238,7 +370,83 @@ static void weight_operators(std::vector<int>& operator_weights, const std::vect
 
 void apply_corrections(std::vector<Expression::Token>& tv)
 {
+	pr_debug("Starting with vector:");
+	Parser::print_math_vector(tv);
 
+	// global prio evaluation
+	std::vector<int> mp;
+	create_prios_vector(tv, mp);
+
+	for (int current_prio_level = mp[get_max_index(mp)]; current_prio_level >= 0; current_prio_level--)
+	{
+		// calculate how many ranges need to be processed at this level
+		std::vector<Range> rv;
+		find_select_prio_op_ranges(mp, rv, current_prio_level);
+
+		for (int current_range = rv.size() - 1; current_range >= 0; current_range--)
+		{
+			Range &outer_range = rv[current_range];
+
+			std::vector<int> inner_prios;
+			rank_inner_ops_raw(inner_prios, tv, outer_range.start, outer_range.finish);
+
+			for (int inner_prio = inner_prios[get_max_index(inner_prios)]; inner_prio >= 0; inner_prio--)
+			{
+				std::vector<Range> inner_ranges;
+				find_select_prio_op_ranges(inner_prios, inner_ranges, inner_prio);
+
+				for (int inner_range = inner_ranges.size() - 1; inner_range >= 0; inner_range--)
+				{
+					int corrections = 1;
+
+					Range &range = inner_ranges[inner_range];
+					while (corrections)
+					{
+						corrections = 0;
+
+						int same_op_cnt = -1;
+						for (int i = outer_range.start + range.start; i < outer_range.start + range.finish + 1; i++)
+						{
+							int loc = get_mop_location(tv, i);
+							Expression::Token& tok = tv[loc];
+
+							if (tok.v.o == Expression::Token::SUB || tok.v.o == Expression::Token::DIV)
+							{
+								same_op_cnt++;
+
+								if (same_op_cnt == 2)
+								{
+									same_op_cnt = 0;
+
+									corrections++;
+
+									switch (tok.v.o)
+									{
+									case Expression::Token::SUB:
+										tok.v.o = Expression::Token::ADD;
+										break;
+									case Expression::Token::DIV:
+										tok.v.o = Expression::Token::MUL;
+										break;
+									default:
+										pr_warn("Impossible operator in this branch, this is a bug!");
+										break;
+									}
+
+									// inverse order to keep location valid between calls
+									add_bracket_to(tv, loc,  1);
+									add_bracket_to(tv, loc, -1);
+
+									pr_debug("Updated vector:");
+									Parser::print_math_vector(tv);
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
 }
 
 std::vector<Expression::Operation> build_op_vector(const std::vector<Expression::Token>& tv)
@@ -272,7 +480,7 @@ std::vector<Expression::Operation> build_op_vector(const std::vector<Expression:
 				std::vector<int> operator_weights;
 				weight_operators(operator_weights, mv, inner_top_ops, start);
 
-				write_operation(ov, tv, mv, mp, start + inner_top_ops[get_min(operator_weights)]);
+				write_operation(ov, tv, mv, mp, start + inner_top_ops[get_min_index(operator_weights)]);
 				finish--;
 			}
 

src/test-cases.cpp

@@ -6,7 +6,7 @@
 TEST(parser_proper_test_1)
 {
 	auto o = Parser::tokenize_input("(1+2-c)");
-	Parser::print_token_vector(o);
+	Parser::print_math_vector(o);
 
 	std::vector<Expression::Token> r;
 
@@ -26,7 +26,7 @@ TEST(parser_proper_test_1)
 TEST(parser_proper_test_2)
 {
 	auto o = Parser::tokenize_input("(1**5,-snake+marble*34*(35 / 63.2))");
-	Parser::print_token_vector(o);
+	Parser::print_math_vector(o);
 
 	std::vector<Expression::Token> r;
 
@@ -56,7 +56,7 @@ TEST(parser_proper_test_2)
 TEST(parser_proper_test_3)
 {
 	auto o = Parser::tokenize_input(")))25.4,, 33..4 35 37 39 41 // +-*/***()()()");
-	Parser::print_token_vector(o);
+	Parser::print_math_vector(o);
 
 	std::vector<Expression::Token> r;
 
@@ -96,6 +96,15 @@ TEST(tree_proper_test_1)
 	return 0;
 }
 
+TEST(tree_proper_test_2)
+{
+	std::vector<Expression::Token> o = Parser::tokenize_input("(1**5 * (1-2-3-4-5-6-7-8))");
+	Syntax::apply_corrections(o);
+	std::vector<Expression::Operation> ov = Syntax::build_op_vector(o);
+
+	return 0;
+}
+
 void register_tests(void)
 {
 	REGISTER(parser_proper_test_1);
@@ -103,4 +112,5 @@ void register_tests(void)
 	REGISTER(parser_proper_test_3);
 
 	REGISTER(tree_proper_test_1);
+	REGISTER(tree_proper_test_2);
 }