wheerd
commented
7 years ago I have a couple of ideas. First, if you recreate the ManyToOneReplacer every time you want to use it, it is not going to be faster than just using replace_all The setup time for creating all the states is much higher than just matching without it. It only pays off if you match multiple times or if you serialize the matcher and restore it. Otherwise the construction cost dominates the overall time.
A second thing are your constraints. To get the most speed out of them, you would need to split them up and turn them into individual constraints, i.e. get rid of the And inside. Then each constraint can be evaluated seperately. As an example, the constraint of the first pattern is
cons(And(FreeQ(List(a_, b_, c_, d_), x_), ZeroQ(Add(Mul(a_, d_), Mul(b_, c_))), PosQ(Mul(Pow(a_, Integer(-1)), b_, Pow(c_, Integer(-1)), d_))), (c, b, x, d, a))Instead, you should try to keep them to as few variables as possible, so that they can be evaluated early:
FreeQ(a_, x_)
FreeQ(b_, x_)
FreeQ(c_, x_)
FreeQ(d_, x_)
ZeroQ(Add(Mul(a_, d_), Mul(b_, c_)))
PosQ(Mul(Pow(a_, Integer(-1)), b_, Pow(c_, Integer(-1)), d_)))For FreeQ I think you don't need sympy to evaluate it. You can basically just use something like this:
class FreeQ(Constraint):
def __init__(self, expr, var):
self.expr = expr if isinstance(expr, str) else expr.name
self.var = var if isinstance(var, str) else var.name
def __call__(self, substitution):
return substitution[self.var] not in substitution[self.expr]
@property
def variables(self):
return frozenset([self.expr, self.var])
def with_renamed_vars(self, renaming):
return FreeQ(
renaming.get(self.expr, self.expr),
renaming.get(self.var, self.var)
)
def __eq__(self, other):
return isinstance(other, FreeQ) and other.expr == self.expr and other.var == self.var
def __hash__(self):
return hash((self.expr, self.var))I did not test this though. The first point is the most important one though. You only get a speedup, if you amortize the setup cost of the ManyToOneMatcher.
arihantparsoya
Hi, I implemented ~80 rules using
ManyToOneReplacerfor Rubi integration and MatchPy was able to match the subjects very quickly. However, when I added ~550 rules, there was significant decrease in speed while matching even smaller subjects.It would be great if you could advice us on how to solve this issue.
Here are the files for our project:
Patterns: https://github.com/parsoyaarihant/sympy/blob/rubi4/sympy/rubi/patterns.py Constraint: https://github.com/parsoyaarihant/sympy/blob/rubi4/sympy/rubi/constraint.py All Rubi Files: https://github.com/parsoyaarihant/sympy/tree/rubi4/sympy/rubi