Implement ast.Pow Operator Rewriting Rule in AstRewriter

[tomv42]

Description:

This PR addresses the issue of implementing the ast.Pow operator (**) between a variable and an integer constant. The goal is to rewrite the exponentiation operation as a series of multiplication operations. The following changes have been made:

• Modified visit_BinOp method to handle ast.Pow nodes:
  • Checks if the operation is an exponentiation and the right operand is a positive integer constant.
  • Rewrites a ** n as a * a * ... * a (n times).
• Did not override visit_Pow because ast.Pow is not visited directly but as part of ast.BinOp.

Testing:

• Added unit tests in test_ast_rewriter.py
• Verified that a ** n is correctly transformed into a * a * ... * a for positive integer constants.
• Ensured that other binary operations are processed correctly by the visit_BinOp method.

Explanation:

I focused on overriding the visit_BinOp method to handle the ast.Pow operator. My understanding is that visit_Pow is not applicable here because ast.Pow is an operator within a BinOp node rather than a standalone node. Thus, visit_BinOp seemed to be the appropriate place to implement this transformation. I'm not entirely sure if this is the best approach, but it appears to work based on my testing.

Related Issue:

This PR resolves issue #23

---

Please review these changes and provide feedback :smile:

[dakk]

Hi Tom, great work; I will try the code tomorrow, but I already have some requests:

• can you also add a test class on https://github.com/dakk/qlasskit/blob/master/test/qlassf/test_int.py , testing pow?
• value ** 0 should be handled (replace it with constant 1 directly in astrewriter)
• the other request is a comment in the review

[tomv42]

Thank you for your feedback.

• I handled the exponentiation value of 0 in the AST rewriter.
• I added a test class in test_int.py to test the exponentiation (**) operator.
• I encountered an issue where mul could not multiply operands of different sizes (e.g., a ** 3 resulted in a * a * a where intermediate results have different sizes).
• I solved this by padding smaller operands with zeros to match the size of the larger operand before performing multiplication.
• All the tests now pass with tox