From 20287ccb7dd3dca592540bb2bd9bf32e077f55f3 Mon Sep 17 00:00:00 2001 From: Christensen Date: Tue, 9 Jul 2019 02:34:48 -0500 Subject: [PATCH 1/7] shield division from surrounding multiplications --- pymbolic/mapper/stringifier.py | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/pymbolic/mapper/stringifier.py b/pymbolic/mapper/stringifier.py index ce6f0b8..7458b66 100644 --- a/pymbolic/mapper/stringifier.py +++ b/pymbolic/mapper/stringifier.py @@ -189,15 +189,21 @@ class StringifyMapper(pymbolic.mapper.Mapper): enclosing_prec, PREC_PRODUCT) def map_quotient(self, expr, enclosing_prec, *args, **kwargs): - return self.parenthesize_if_needed( - self.format("%s / %s", + # (-1) * ((-1)*x / 5) should not reassociate. Therefore raise precedence + # on the numerator and shield against surrounding products. + result = self.format("%s / %s", # space is necessary--otherwise '/*' becomes - # start-of-comment in C. ('*' from dereference) - self.rec(expr.numerator, PREC_PRODUCT, *args, **kwargs), + # start-of-comment in C. ('*' from dereference) + self.rec(expr.numerator, PREC_POWER, *args, **kwargs), self.rec( expr.denominator, PREC_POWER, # analogous to ^{-1} - *args, **kwargs)), - enclosing_prec, PREC_PRODUCT) + *args, **kwargs)) + + # Note ">=", not ">" as in parenthesize_if_needed(). + if enclosing_prec >= PREC_PRODUCT: + return "(%s)" % result + else: + return result def map_floor_div(self, expr, enclosing_prec, *args, **kwargs): # (-1) * ((-1)*x // 5) should not reassociate. Therefore raise precedence -- GitLab From eb9af00103b7118b86f1e7c45539224cf54b7007 Mon Sep 17 00:00:00 2001 From: Christensen Date: Tue, 9 Jul 2019 03:11:35 -0500 Subject: [PATCH 2/7] apply to remainder map as well --- pymbolic/mapper/stringifier.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/pymbolic/mapper/stringifier.py b/pymbolic/mapper/stringifier.py index 7458b66..4478129 100644 --- a/pymbolic/mapper/stringifier.py +++ b/pymbolic/mapper/stringifier.py @@ -229,12 +229,21 @@ class StringifyMapper(pymbolic.mapper.Mapper): enclosing_prec, PREC_POWER) def map_remainder(self, expr, enclosing_prec, *args, **kwargs): - return self.format("(%s %% %s)", - self.rec(expr.numerator, PREC_PRODUCT, *args, **kwargs), + # (-1) * ((-1)*x % 5) should not reassociate. Therefore raise precedence + # on the numerator and shield against surrounding products. + + result = self.format("%s %% %s", + self.rec(expr.numerator, PREC_POWER, *args, **kwargs), self.rec( - expr.denominator, PREC_POWER, # analogous to ^{-1} + expr.denominator, PREC_POWER, # analogous to ^{-1} *args, **kwargs)) + # Note ">=", not ">" as in parenthesize_if_needed(). + return "(%s)" % result if enclosing_prec >= PREC_PRODUCT: + return "(%s)" % result + else: + return result + def map_polynomial(self, expr, enclosing_prec, *args, **kwargs): from pymbolic.primitives import flattened_sum return self.rec(flattened_sum( -- GitLab From f9c5423eb3e22eac21464ffc4d962e6196ef4952 Mon Sep 17 00:00:00 2001 From: Christensen Date: Thu, 11 Jul 2019 00:19:54 -0500 Subject: [PATCH 3/7] enforce order of operations around products and divisions --- pymbolic/mapper/stringifier.py | 70 ++++++++++++++++------------------ 1 file changed, 32 insertions(+), 38 deletions(-) diff --git a/pymbolic/mapper/stringifier.py b/pymbolic/mapper/stringifier.py index 4478129..8d2b33a 100644 --- a/pymbolic/mapper/stringifier.py +++ b/pymbolic/mapper/stringifier.py @@ -184,42 +184,40 @@ class StringifyMapper(pymbolic.mapper.Mapper): enclosing_prec, PREC_SUM) def map_product(self, expr, enclosing_prec, *args, **kwargs): + # Spaces prevent '**z' (times dereference z), which + # is hard to read. + # Use PREC_SUM to enforce correct order of operations + # in a series of products, quotients, and remainders. + # Without it the mapper leaves out parentheses + # and the series evaluates left to right. return self.parenthesize_if_needed( - self.join_rec("*", expr.children, PREC_PRODUCT, *args, **kwargs), - enclosing_prec, PREC_PRODUCT) + self.join_rec(" * ", expr.children, PREC_PRODUCT, *args, **kwargs), + enclosing_prec, PREC_SUM) def map_quotient(self, expr, enclosing_prec, *args, **kwargs): # (-1) * ((-1)*x / 5) should not reassociate. Therefore raise precedence # on the numerator and shield against surrounding products. - result = self.format("%s / %s", - # space is necessary--otherwise '/*' becomes - # start-of-comment in C. ('*' from dereference) - self.rec(expr.numerator, PREC_POWER, *args, **kwargs), - self.rec( - expr.denominator, PREC_POWER, # analogous to ^{-1} - *args, **kwargs)) - - # Note ">=", not ">" as in parenthesize_if_needed(). - if enclosing_prec >= PREC_PRODUCT: - return "(%s)" % result - else: - return result + result = self.parenthesize_if_needed( + self.format("%s / %s", + # space is necessary--otherwise '/*' becomes + # start-of-comment in C. ('*' from dereference) + self.rec(expr.numerator, PREC_PRODUCT, *args, **kwargs), + self.rec( + expr.denominator, PREC_POWER, # analogous to ^{-1} + *args, **kwargs)), + enclosing_prec, PREC_SUM) def map_floor_div(self, expr, enclosing_prec, *args, **kwargs): # (-1) * ((-1)*x // 5) should not reassociate. Therefore raise precedence # on the numerator and shield against surrounding products. - - result = self.format("%s // %s", - self.rec(expr.numerator, PREC_POWER, *args, **kwargs), - self.rec( - expr.denominator, PREC_POWER, # analogous to ^{-1} - *args, **kwargs)) - - # Note ">=", not ">" as in parenthesize_if_needed(). - if enclosing_prec >= PREC_PRODUCT: - return "(%s)" % result - else: - return result + + result = self.parenthesize_if_needed( + self.format("%s // %s", + self.rec(expr.numerator, PREC_PRODUCT, *args, **kwargs), + self.rec( + expr.denominator, PREC_POWER, # analogous to ^{-1} + *args, **kwargs)), + enclosing_prec, PREC_SUM) def map_power(self, expr, enclosing_prec, *args, **kwargs): return self.parenthesize_if_needed( @@ -232,17 +230,13 @@ class StringifyMapper(pymbolic.mapper.Mapper): # (-1) * ((-1)*x % 5) should not reassociate. Therefore raise precedence # on the numerator and shield against surrounding products. - result = self.format("%s %% %s", - self.rec(expr.numerator, PREC_POWER, *args, **kwargs), - self.rec( - expr.denominator, PREC_POWER, # analogous to ^{-1} - *args, **kwargs)) - - # Note ">=", not ">" as in parenthesize_if_needed(). - return "(%s)" % result if enclosing_prec >= PREC_PRODUCT: - return "(%s)" % result - else: - return result + result = self.parenthesize_if_needed( + self.format("%s %% %s", + self.rec(expr.numerator, PREC_PRODUCT, *args, **kwargs), + self.rec( + expr.denominator, PREC_POWER, # analogous to ^{-1} + *args, **kwargs)), + enclosing_prec, PREC_SUM) def map_polynomial(self, expr, enclosing_prec, *args, **kwargs): from pymbolic.primitives import flattened_sum -- GitLab From 7cf5d8737d76e2d1a6682103aaf0d9390436849f Mon Sep 17 00:00:00 2001 From: Christensen Date: Thu, 11 Jul 2019 00:27:06 -0500 Subject: [PATCH 4/7] return result directly --- pymbolic/mapper/stringifier.py | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/pymbolic/mapper/stringifier.py b/pymbolic/mapper/stringifier.py index 8d2b33a..a43b5eb 100644 --- a/pymbolic/mapper/stringifier.py +++ b/pymbolic/mapper/stringifier.py @@ -197,7 +197,7 @@ class StringifyMapper(pymbolic.mapper.Mapper): def map_quotient(self, expr, enclosing_prec, *args, **kwargs): # (-1) * ((-1)*x / 5) should not reassociate. Therefore raise precedence # on the numerator and shield against surrounding products. - result = self.parenthesize_if_needed( + return self.parenthesize_if_needed( self.format("%s / %s", # space is necessary--otherwise '/*' becomes # start-of-comment in C. ('*' from dereference) @@ -210,8 +210,7 @@ class StringifyMapper(pymbolic.mapper.Mapper): def map_floor_div(self, expr, enclosing_prec, *args, **kwargs): # (-1) * ((-1)*x // 5) should not reassociate. Therefore raise precedence # on the numerator and shield against surrounding products. - - result = self.parenthesize_if_needed( + return self.parenthesize_if_needed( self.format("%s // %s", self.rec(expr.numerator, PREC_PRODUCT, *args, **kwargs), self.rec( @@ -229,8 +228,7 @@ class StringifyMapper(pymbolic.mapper.Mapper): def map_remainder(self, expr, enclosing_prec, *args, **kwargs): # (-1) * ((-1)*x % 5) should not reassociate. Therefore raise precedence # on the numerator and shield against surrounding products. - - result = self.parenthesize_if_needed( + return self.parenthesize_if_needed( self.format("%s %% %s", self.rec(expr.numerator, PREC_PRODUCT, *args, **kwargs), self.rec( -- GitLab From c01815d5004d5bdc4c007d0a77dc0e537f3ed649 Mon Sep 17 00:00:00 2001 From: Christensen Date: Thu, 11 Jul 2019 00:28:43 -0500 Subject: [PATCH 5/7] remove white spaces --- pymbolic/mapper/stringifier.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pymbolic/mapper/stringifier.py b/pymbolic/mapper/stringifier.py index a43b5eb..b831751 100644 --- a/pymbolic/mapper/stringifier.py +++ b/pymbolic/mapper/stringifier.py @@ -197,10 +197,10 @@ class StringifyMapper(pymbolic.mapper.Mapper): def map_quotient(self, expr, enclosing_prec, *args, **kwargs): # (-1) * ((-1)*x / 5) should not reassociate. Therefore raise precedence # on the numerator and shield against surrounding products. - return self.parenthesize_if_needed( + return self.parenthesize_if_needed( self.format("%s / %s", # space is necessary--otherwise '/*' becomes - # start-of-comment in C. ('*' from dereference) + # start-of-comment in C. ('*' from dereference) self.rec(expr.numerator, PREC_PRODUCT, *args, **kwargs), self.rec( expr.denominator, PREC_POWER, # analogous to ^{-1} -- GitLab From 425cb3d91d4dc15d8b174f6a4c3a6c5fda98cc7a Mon Sep 17 00:00:00 2001 From: Christensen Date: Thu, 11 Jul 2019 00:30:43 -0500 Subject: [PATCH 6/7] fix unaligned indentation --- pymbolic/mapper/stringifier.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymbolic/mapper/stringifier.py b/pymbolic/mapper/stringifier.py index b831751..5a76219 100644 --- a/pymbolic/mapper/stringifier.py +++ b/pymbolic/mapper/stringifier.py @@ -234,7 +234,7 @@ class StringifyMapper(pymbolic.mapper.Mapper): self.rec( expr.denominator, PREC_POWER, # analogous to ^{-1} *args, **kwargs)), - enclosing_prec, PREC_SUM) + enclosing_prec, PREC_SUM) def map_polynomial(self, expr, enclosing_prec, *args, **kwargs): from pymbolic.primitives import flattened_sum -- GitLab From ea1ceace6f301a4e82ce975b0900eb74050ec37e Mon Sep 17 00:00:00 2001 From: Christensen Date: Thu, 11 Jul 2019 00:36:01 -0500 Subject: [PATCH 7/7] remove spaces from around product --- pymbolic/mapper/stringifier.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pymbolic/mapper/stringifier.py b/pymbolic/mapper/stringifier.py index 5a76219..43e63f9 100644 --- a/pymbolic/mapper/stringifier.py +++ b/pymbolic/mapper/stringifier.py @@ -191,7 +191,7 @@ class StringifyMapper(pymbolic.mapper.Mapper): # Without it the mapper leaves out parentheses # and the series evaluates left to right. return self.parenthesize_if_needed( - self.join_rec(" * ", expr.children, PREC_PRODUCT, *args, **kwargs), + self.join_rec("*", expr.children, PREC_PRODUCT, *args, **kwargs), enclosing_prec, PREC_SUM) def map_quotient(self, expr, enclosing_prec, *args, **kwargs): -- GitLab