sagemathgh-40939: n_nodes and number_of_nodes_xxx in tree related classes
    
fix sagemath#40935 in tree related classes.

cf sagemath#40932

Should `number_of_nodes` also be an alias, or perhaps instead of
`n_nodes`?
Should `n_nodes_to_the_right`, `n_nodes_at_depth` also be aliases?

Does this pollute the namespace too much?
    
URL: sagemath#40939
Reported by: Martin Rubey
Reviewer(s): David Coudert

Author: Release Manager

src/sage/combinat/abstract_tree.py

@@ -187,7 +187,7 @@ def pre_order_traversal_iter(self):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.number_of_nodes()
             7
             sage: l = [1 for i in t.pre_order_traversal_iter()]
             sage: len(l)
@@ -259,7 +259,7 @@ def iterative_pre_order_traversal(self, action=None):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.number_of_nodes()
             7
             sage: l = []
             sage: t.iterative_pre_order_traversal(lambda node: l.append(1))
@@ -376,7 +376,7 @@ def pre_order_traversal(self, action=None):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.number_of_nodes()
             7
             sage: l = []
             sage: t.pre_order_traversal(lambda node: l.append(1))
@@ -471,7 +471,7 @@ def post_order_traversal_iter(self):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.number_of_nodes()
             7
             sage: l = [1 for i in t.post_order_traversal_iter()]
             sage: len(l)
@@ -543,7 +543,7 @@ def post_order_traversal(self, action=None):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.number_of_nodes()
             7
             sage: l = []
             sage: t.post_order_traversal(lambda node: l.append(1))
@@ -617,7 +617,7 @@ def iterative_post_order_traversal(self, action=None):
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.number_of_nodes()
             7
             sage: l = []
             sage: t.iterative_post_order_traversal(lambda node: l.append(1))
@@ -710,7 +710,7 @@ def contour_traversal(self, first_action=None, middle_action=None, final_action=
             sage: v = BinaryTree([u, u])
             sage: w = BinaryTree([v, v])
             sage: t = BinaryTree([w, w])
-            sage: t.node_number()
+            sage: t.number_of_nodes()
             7
             sage: l = []
             sage: t.contour_traversal(first_action = lambda node: l.append(0))
@@ -852,7 +852,7 @@ def paths_at_depth(self, depth, path=[]):
 
         .. SEEALSO::
 
-            :meth:`paths`, :meth:`paths_to_the_right`, :meth:`node_number_at_depth`
+            :meth:`paths`, :meth:`paths_to_the_right`, :meth:`number_of_nodes_at_depth`
 
         EXAMPLES::
 
@@ -886,7 +886,7 @@ def paths_at_depth(self, depth, path=[]):
             for i in range(len(self)):
                 yield from self[i].paths_at_depth(depth - 1, path + [i])
 
-    def node_number_at_depth(self, depth):
+    def number_of_nodes_at_depth(self, depth):
         r"""
         Return the number of nodes at a given depth.
 
@@ -900,7 +900,8 @@ def node_number_at_depth(self, depth):
 
         .. SEEALSO::
 
-            :meth:`node_number`, :meth:`node_number_to_the_right`, :meth:`paths_at_depth`
+            :meth:`number_of_nodes`, :meth:`number_of_nodes_to_the_right`,
+            :meth:`paths_at_depth`
 
         EXAMPLES::
 
@@ -915,7 +916,7 @@ def node_number_at_depth(self, depth):
               o    o
                    |
                    o
-            sage: [T.node_number_at_depth(i) for i in range(6)]
+            sage: [T.number_of_nodes_at_depth(i) for i in range(6)]
             [1, 3, 4, 2, 1, 0]
 
         TESTS:
@@ -927,15 +928,15 @@ def node_number_at_depth(self, depth):
             .
             sage: T.is_empty()
             True
-            sage: [T.node_number_at_depth(i) for i in range(3)]
+            sage: [T.number_of_nodes_at_depth(i) for i in range(3)]
             [0, 0, 0]
 
         Check that we do not hit a recursion limit::
 
             sage: T = OrderedTree([])
             sage: for _ in range(9999):
             ....:     T = OrderedTree([T])
-            sage: T.node_number_at_depth(2000)
+            sage: T.number_of_nodes_at_depth(2000)
             1
         """
         if self.is_empty():
@@ -965,6 +966,8 @@ def lf_action(node):
         self.contour_traversal(fr_action, m_action, fn_action, lf_action)
         return Integer(m)
 
+    node_number_at_depth = number_of_nodes_at_depth
+
     def paths_to_the_right(self, path):
         r"""
         Return a generator of paths for all nodes at the same
@@ -979,7 +982,7 @@ def paths_to_the_right(self, path):
 
         .. SEEALSO::
 
-            :meth:`paths`, :meth:`paths_at_depth`, :meth:`node_number_to_the_right`
+            :meth:`paths`, :meth:`paths_at_depth`, :meth:`number_of_nodes_to_the_right`
 
         EXAMPLES::
 
@@ -1023,7 +1026,7 @@ def paths_to_the_right(self, path):
         for p in self[path[0]].paths_to_the_right(path[1:]):
             yield tuple([path[0]] + list(p))
 
-    def node_number_to_the_right(self, path):
+    def number_of_nodes_to_the_right(self, path):
         r"""
         Return the number of nodes at the same depth and to the right of
         the node identified by ``path``.
@@ -1033,7 +1036,8 @@ def node_number_to_the_right(self, path):
 
         .. SEEALSO::
 
-            :meth:`node_number`, :meth:`node_number_at_depth`, :meth:`paths_to_the_right`
+            :meth:`number_of_nodes`, :meth:`number_of_nodes_at_depth`,
+            :meth:`paths_to_the_right`
 
         EXAMPLES::
 
@@ -1048,28 +1052,30 @@ def node_number_to_the_right(self, path):
               o    o
                    |
                    o
-            sage: T.node_number_to_the_right(())
+            sage: T.number_of_nodes_to_the_right(())
             0
-            sage: T.node_number_to_the_right((0,))
+            sage: T.number_of_nodes_to_the_right((0,))
             2
-            sage: T.node_number_to_the_right((0,1))
+            sage: T.number_of_nodes_to_the_right((0,1))
             2
-            sage: T.node_number_to_the_right((0,1,0))
+            sage: T.number_of_nodes_to_the_right((0,1,0))
             1
 
             sage: T = OrderedTree([])
-            sage: T.node_number_to_the_right(())
+            sage: T.number_of_nodes_to_the_right(())
             0
         """
         depth = len(path)
         if depth == 0:
             return Integer(0)
-        result = sum(son.node_number_at_depth(depth - 1)
+        result = sum(son.number_of_nodes_at_depth(depth - 1)
                      for son in self[path[0] + 1:])
         if path[0] < len(self) and path[0] >= 0:
-            result += self[path[0]].node_number_to_the_right(path[1:])
+            result += self[path[0]].number_of_nodes_to_the_right(path[1:])
         return result
 
+    node_number_to_the_right = number_of_nodes_to_the_right
+
     def subtrees(self):
         """
         Return a generator for all nonempty subtrees of ``self``.
@@ -1099,12 +1105,12 @@ def subtrees(self):
         TESTS::
 
             sage: t = OrderedTree([[], [[], [[], []], [[], []]], [[], []]])
-            sage: t.node_number() == len(list(t.subtrees()))
+            sage: t.number_of_nodes() == len(list(t.subtrees()))
             True
             sage: list(BinaryTree().subtrees())
             []
             sage: bt = BinaryTree([[],[[],[]]])
-            sage: bt.node_number() == len(list(bt.subtrees()))
+            sage: bt.number_of_nodes() == len(list(bt.subtrees()))
             True
         """
         return self.pre_order_traversal_iter()
@@ -1142,12 +1148,12 @@ def paths(self):
         TESTS::
 
             sage: t = OrderedTree([[], [[], [[], []], [[], []]], [[], []]])
-            sage: t.node_number() == len(list(t.paths()))
+            sage: t.number_of_nodes() == len(list(t.paths()))
             True
             sage: list(BinaryTree().paths())
             []
             sage: bt = BinaryTree([[],[[],[]]])
-            sage: bt.node_number() == len(list(bt.paths()))
+            sage: bt.number_of_nodes() == len(list(bt.paths()))
             True
         """
         if not self.is_empty():
@@ -1156,36 +1162,36 @@ def paths(self):
                 for p in t.paths():
                     yield (i,) + p
 
-    def node_number(self):
+    def number_of_nodes(self):
         """
         Return the number of nodes of ``self``.
 
         .. SEEALSO::
 
-            :meth:`node_number_at_depth`, :meth:`node_number_to_the_right`
+            :meth:`number_of_nodes_at_depth`, :meth:`number_of_nodes_to_the_right`
 
         EXAMPLES::
 
-            sage: OrderedTree().node_number()
+            sage: OrderedTree().number_of_nodes()
             1
-            sage: OrderedTree([]).node_number()
+            sage: OrderedTree([]).number_of_nodes()
             1
-            sage: OrderedTree([[],[]]).node_number()
+            sage: OrderedTree([[],[]]).number_of_nodes()
             3
-            sage: OrderedTree([[],[[]]]).node_number()
+            sage: OrderedTree([[],[[]]]).number_of_nodes()
             4
-            sage: OrderedTree([[], [[], [[], []], [[], []]], [[], []]]).node_number()
+            sage: OrderedTree([[], [[], [[], []], [[], []]], [[], []]]).number_of_nodes()
             13
 
         EXAMPLES::
 
-            sage: BinaryTree(None).node_number()
+            sage: BinaryTree(None).number_of_nodes()
             0
-            sage: BinaryTree([]).node_number()
+            sage: BinaryTree([]).number_of_nodes()
             1
-            sage: BinaryTree([[], None]).node_number()
+            sage: BinaryTree([[], None]).number_of_nodes()
             2
-            sage: BinaryTree([[None, [[], []]], None]).node_number()
+            sage: BinaryTree([[None, [[], []]], None]).number_of_nodes()
             5
 
         TESTS:
@@ -1195,7 +1201,7 @@ def node_number(self):
             sage: T = OrderedTree([])
             sage: for _ in range(9999):
             ....:     T = OrderedTree([T])
-            sage: T.node_number()
+            sage: T.number_of_nodes()
             10000
         """
         # An attribute _node_number for storing the number of nodes
@@ -1221,6 +1227,8 @@ def count(node):
         self.iterative_post_order_traversal(count)
         return self._node_number
 
+    node_number = number_of_nodes
+
     def depth(self):
         """
         Return the depth of ``self``.
@@ -1581,7 +1589,7 @@ def to_hexacode(self):
         """
         if len(self) > 15:
             raise ValueError("the width of the tree is too large")
-        if self.node_number() == 1:
+        if self.number_of_nodes() == 1:
             return "0"
         return ("%x" % len(self)) + "".join(u.to_hexacode() for u in self)
 
@@ -1609,7 +1617,7 @@ def tree_factorial(self):
             sage: BinaryTree().tree_factorial()
             1
         """
-        nb = self.node_number()
+        nb = self.number_of_nodes()
         if nb <= 1:
             return Integer(1)
         return nb * prod(s.tree_factorial() for s in self)
@@ -2409,7 +2417,7 @@ def leaf_labels(self):
             sage: LBT(None).leaf_labels()
             []
         """
-        return [t.label() for t in self.subtrees() if t.node_number() == 1]
+        return [t.label() for t in self.subtrees() if t.number_of_nodes() == 1]
 
     def __eq__(self, other):
         """

src/sage/combinat/bijectionist.py

@@ -156,7 +156,7 @@
     ....:         else:
     ....:             return m+1
     sage: bij = Bijectionist(A, B, tau)
-    sage: bij.set_statistics((lambda a: a.size(), lambda b: b.node_number()-1))
+    sage: bij.set_statistics((lambda a: a.size(), lambda b: b.number_of_nodes()-1))
     sage: from sage.combinat.cyclic_sieving_phenomenon import orbit_decomposition
     sage: bij.set_constant_blocks(orbit_decomposition(A, theta))
     sage: list(bij.solutions_iterator())
@@ -173,7 +173,7 @@
     ....:                                          B2.to_dyck_word()).to_binary_tree()
     sage: bij = Bijectionist(A, B)
     sage: bij.set_intertwining_relations((2, concat_path, concat_tree))
-    sage: bij.set_statistics((lambda d: d.semilength(), lambda t: t.node_number()))
+    sage: bij.set_statistics((lambda d: d.semilength(), lambda t: t.number_of_nodes()))
     sage: for D in sorted(bij.minimal_subdistributions_iterator(), key=lambda x: (len(x[0][0]), x)):
     ....:     ascii_art(D)
     ( [ /\ ], [ o ] )