Make count_ops() work with logic operations by creating a binary tree.

sympy/core/function.py

@@ -2326,7 +2326,18 @@ def count_ops(expr, visual=False):
     else:  # it's Basic not isinstance(expr, Expr):
         if not isinstance(expr, Basic):
             raise TypeError("Invalid type of expr")
-        ops = [count_ops(a, visual=visual) for a in expr.args]
+        else:
+            ops = []
+            args = [expr]
+            while args:
+                a = args.pop()
+                if a.args:
+                    o = C.Symbol(a.func.__name__.upper())
+                    if a.is_Boolean:
+                        ops.append(o*(len(a.args)-1))
+                    else:
+                        ops.append(o)
+                    args.extend(a.args)
 
     if not ops:
         if visual:

sympy/core/tests/test_count_ops.py

@@ -1,8 +1,9 @@
 from sympy import symbols, sin, exp, cos, Derivative, Integral, Basic, \
-    count_ops, S, And, I, pi, Eq
+    count_ops, S, And, I, pi, Eq, Or, Not, Xor ,Nand ,Nor, Implies,Equivalent, ITE
+from sympy.core.containers import Tuple
 
 x, y, z = symbols('x,y,z')
-
+a, b, c = symbols('a,b,c')
 
 def test_count_ops_non_visual():
     def count(val):
@@ -14,12 +15,23 @@ def count(val):
     assert count(x + y*x + 2*y) == 4
     assert count({x + y: x}) == 1
     assert count({x + y: S(2) + x}) is not S.One
-
+    assert count(Or(x,y)) == 1
+    assert count(And(x,y)) == 1
+    assert count(Not(x)) == 0
+    assert count(Nor(x,y)) == 1
+    assert count(Nand(x,y)) == 1
+    assert count(Xor(x,y)) == 3
+    assert count(Implies(x,y)) == 1
+    assert count(Equivalent(x,y)) == 1
+    assert count(ITE(x,y,z)) == 3
+    assert count(ITE(True,x,y)) == 0
 
 def test_count_ops_visual():
     ADD, MUL, POW, SIN, COS, EXP, AND, D, G = symbols(
         'Add Mul Pow sin cos exp And Derivative Integral'.upper())
     DIV, SUB, NEG = symbols('DIV SUB NEG')
+    OR, AND, IMPLIES, EQUIVALENT, BASIC, TUPLE = symbols(
+        'Or And Implies Equivalent Basic Tuple'.upper())
 
     def count(val):
         return count_ops(val, visual=True)
@@ -78,7 +90,33 @@ def count(val):
     assert count([x + 1, sin(x)*y, None]) == SIN + ADD + MUL
     assert count([]) is S.Zero
 
-    # XXX: These are a bit surprising, only Expr-compatible ops are counted.
-    assert count(And(x, y, z)) == 0
-    assert count(Basic(x, x + y)) == ADD
+    assert count(Basic()) == 0
+    assert count(Basic(Basic(),Basic(x,x+y))) == ADD + 2*BASIC
+    assert count(Basic(x, x + y)) == ADD + BASIC
+    assert count(Or(x,y)) == OR
+    assert count(And(x,y)) == AND
+    assert count(And(x**y,z)) == AND + POW
+    assert count(Or(x,Or(y,And(z,a)))) == AND + 2*OR
+    assert count(Nor(x,y)) == AND
+    assert count(Nand(x,y)) == OR
+    assert count(Xor(x,y)) == 2*AND + OR
+    assert count(Implies(x,y)) == IMPLIES
+    assert count(Equivalent(x,y)) == EQUIVALENT
+    assert count(ITE(x,y,z)) == 2*AND + OR
+    assert count([Or(x,y), And(x,y), Basic(x+y)]) == ADD + AND + BASIC + OR
+
+    assert count(Basic(Tuple(x))) == BASIC + TUPLE
+    #It checks that TUPLE is counted as an operation.
+
     assert count(Eq(x + y, S(2))) == ADD
+
+    # The test given below checks the results which comes when logical
+    # functions are given less number of arguments than required and
+    # don't raises an exception. They don't make much sense.
+    assert count(And((x,y+z))) == ADD
+    assert count(Equivalent(x)) == 0     # Equivalent(x) == 0
+    assert count(And(x)) == 0            # And(x) == 0
+    assert count(Nand(And(x,y))) == OR   # Nand(x) == Not(x)
+    assert count(Xor(And(x,y))) == AND   # Xor(x) == x
+    # Any logic function don't check if the argument is an empty tuple
+    assert count(And(x,())) == AND