hasslesstech/pzks-labs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add operator conversion for efficient parallelizing

Browse Source
This commit is contained in:
hasslesstech
2026-10-05 20:24:09 +03:00
parent 5fdcef4dd7
commit 6d1dfdac58
6 changed files with 277 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/syntaxer.cpp
+210 -2
View File
@@ -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--;
}