Fast algorithm for generating ascending compositions

TL;DR

This paper introduces a new, highly efficient algorithm for generating all ascending compositions of a positive integer, improving upon existing methods by leveraging tree structures for better performance.

Contribution

The paper presents a novel ascending composition generation algorithm that significantly outperforms previous algorithms by utilizing tree structures for efficient enumeration.

Findings

Algorithm is faster than existing methods

Uses tree structures for efficient generation

Applicable to systematic integer partition enumeration

Abstract

In this paper we give a fast algorithm to generate all partitions of a positive integer $n$. Integer partitions may be encoded as either ascending or descending compositions for the purposes of systematic generation. It is known that the ascending composition generation algorithm is substantially more efficient than its descending composition counterpart. Using tree structures for storing the partitions of integers, we develop a new ascending composition generation algorithm which is substantially more efficient than the algorithms from the literature.

Figures

Tables

Table 1. Table 1: Experimental results on few Intel CPU

	Theoretical		Experimental $r\left(n\right)$
$n$	$r_1\left(n\right)$	$r_2\left(n\right)$	Pentium Dual	Intel Celeron	Intel Atom
20	0.89556	0.82113	0.82257	0.78651	0.93977
30	0.88738	0.79381	0.74365	0.75669	0.92693
40	0.88467	0.77992	0.74621	0.75323	0.93712
50	0.88403	0.77197	0.74905	0.76713	0.83457
60	0.88438	0.76731	0.76146	0.76397	0.89760
70	0.88525	0.76465	0.76036	0.76893	0.89812
80	0.88639	0.76326	0.75739	0.77172	0.90994
90	0.88766	0.76271	0.75549	0.77064	0.88617
100	0.88901	0.76274	0.75464	0.76323	0.89064
110	0.89037	0.76319	0.75352	0.77381	0.88936
120	0.89174	0.76392	0.75358	0.77326	0.89617
130	0.89308	0.76485	0.75445	0.77012	0.89004

Equations

$$x^{\prime }\in \left\{x,x+1,\dots ,\lfloor \frac{y}{2}\rfloor ,y\right\}\text{mbox}and{y}^{\prime }=y-x^{\prime }.$$

$$x_l=\{\begin{array}{ll}x,& \text{mbox}if2x\le y,\\ y,& \text{mbox}otherwise\end{array}\text{mbox}and{y}_l=y-x_l,$$

$$x_r=\{\begin{array}{ll}x+1,& \text{mbox}if2+x\le y,\\ x+y,& \text{mbox}otherwise\end{array}\text{mbox}and{y}_r=x+y-x_r.$$

$$p^{(t)}(n,m)=p^{(t)}(n-m,m)+p^{(t)}(n,m+1).$$

$$p^{(2)}(15,3)=p^{(2)}(12,3)+p^{(2)}(15,4)=4+3=7.$$

$$p^{(t)}(n,m)=1+\sum _{k=m}^{\lfloor \frac{n}{t+1}\rfloor }{p}^{(t)}(n-k,k).$$

$$p^{(2)}(15,3)=1+p^{(2)}(12,3)+p^{(2)}(11,4)+p^{(2)}(10,5)=1+4+1+1=7.$$

$$p^{(t)}(n,m)=p^{(t-1)}(n,m)-p^{(t-1)}(n-t,m).$$

$$p^{(t-1)}(t+1,1)=p^{(t-1)}(t,1)+p^{(t-1)}(t+1,2)=2+1=3,$$

$$p^{(t)}(n^{\prime },m)=p^{(t-1)}(n^{\prime },m)-p^{(t-1)}(n^{\prime }-t,m)$$

$$p^{(t)}(n,m)$$

$$p^{(t-1)}(n-k,k)=1,\text{mbox}for\lfloor \frac{n}{t+1}\rfloor <k\le \lfloor \frac{n}{t}\rfloor ,$$

$$p^{(t-1)}(n-t-k,k)=1,\text{mbox}for\lfloor \frac{n}{t+1}\rfloor <k\le \lfloor \frac{n-t}{t}\rfloor ,$$

$$p^{(t)}(n,m)=\sum _{k=m}^{\lfloor n/t\rfloor }{p}^{(t-1)}(n-k,k)-\sum _{k=m}^{\lfloor (n-t)/t\rfloor }{p}^{(t-1)}(n-t-k,k).$$

$$p^{(3)}(15,3)=p^{(2)}(15,3)-p^{(2)}(12,3)=7-4=3.$$

$$p^{(t)}(n)=p^{(t-1)}(n)-p^{(t-1)}(n-t).$$

$$p^{(2)}(n)=p(n)-p(n-2).$$

$$p^{(3)}(n)=p(n)-p(n-2)-p(n-3)+p(n-5).$$

$$p(n)\le p(n-1)+p(n-2)-p(n-5).$$

$$\sum _{n=0}^{\infty }\frac{z^n}{{\left(q;q\right)}_n}=\frac{1}{{\left(z;q\right)}_{\infty }},$$

$${\left(A;q\right)}_n=\left(1-A\right)\left(1-Aq\right)\cdots (1-A{q}^{n-1}).$$

$$\frac{1-q-q^2+q^5}{{\left(q;q\right)}_{\infty }}$$

$$p^{(3)}(n)\le p^{(2)}(n-1).$$

$$4p^{(3)}(n)\le 3p^{(2)}(n).$$

$$p^{(2)}(n)\le 2p^{(2)}(n-3)+p^{(2)}(n-4)+p^{(2)}(n-5).$$

$$r_1(n)=\frac{p(n)+1.25\cdot p^{(3)}(n)}{p(n)+p^{(2)}(n)},$$

$$r_2(n)=\frac{p(n)+4p^{(3)}(n)}{p(n)+3p^{(2)}(n)}.$$

$$r(n)=\frac{t_1(n)}{t_2(n)}.$$

Full text

Keywords: algorithm, ascending composition, integer partition, generation.

MSC 2010: 05A17, 05C05, 05C85, 11P84

1 Introduction

Any positive integer $n$ can be written as a sum of one or more positive integers $\lambda_{i}$, $n=\lambda_{1}+\lambda_{2}+\cdots+\lambda_{k}$. If the order of integers $\lambda_{i}$ does not matter, this representation is known as an integer partition; otherwise, it is know as a composition. When $\lambda_{1}\leq\lambda_{2}\leq\cdots\leq\lambda_{k}$, we have an ascending composition. If $\lambda_{1}\geq\lambda_{2}\geq\cdots\geq\lambda_{k}$ then we have a descending composition. We notice that more often than not there appears the tendency of defining partitions as descending composition and this is also the convention used in this paper. In order to indicate that $\lambda=[\lambda_{1},\lambda_{2},\ldots,\lambda_{k}]$ is a partition of $n$, we use the notation $\lambda\vdash n$ introduced by G. E. Andrews [2]. The number of all partitions of a positive integer $n$ is denoted by $p(n)$ (sequence $A000041$ in OEIS [8]).

The choice of the way in which the partitions are represented is crucial for the efficiency of their generating algorithm. Kelleher [4, 5] approaches the problem of generating partitions through ascending compositions and proves that the algorithm AccelAsc is more efficient than any other previously known algorithms for generating integer partitions.

In this study we show that the tree structures presented by Lin [6] can be used to efficiently generate ascending compositions in standard representation. The idea of using tree structures to store all partitions of an integer is based on the fact that two partitions of the same integers could have more common parts. Lin [6] created the tree structures according to the following rule: the root of the tree is labeled with $(1,n)$, and $(x^{\prime},y^{\prime})$ is a child of the node $(x,y)$ if and only if

[TABLE]

If $x^{\prime}=y$ then $(x^{\prime},y^{\prime})=(y,0)$ is a leaf node. It is obvious that any leaf node has the form $(x,0)$, $0<x\leq n$.

Lin [6] proved that $[x_{1},x_{2},\ldots,x_{k}]$ with $x_{1}\leq x_{2}\leq\cdots\leq x_{k}$ is an ascending composition of $n$ if and only if $(x_{0},y_{0}),(x_{1},y_{1}),\ldots,(x_{k},y_{k})$ is a path from the root $(x_{0},y_{0})$ to a leaf $(x_{k},y_{k})$ and then, basing on this, it is shown that the total number of nodes needed to store all the partitions of an integer is twice the number of leaf nodes in its partition tree. Obviously, the number of leaf nodes in partition tree of $n$ is $p(n)$, namely the number of the partitions of $n$.

It is well-known that any ordered tree can be converted into a binary tree by changing the links between the nodes. Converting the tree for storing integer partitions, we get a binary tree. Deleting then the root of this binary tree we get a strict binary tree that stores all the partitions of an integer. Applying these conversions to the tree from figure 1, we obtain the strict binary tree in figure 2.

In order to generate the ascending compositions we use a depth-first traversal of partition strict binary tree. When we reach a leaf node we list from the path that connects the root node with the leaf node only the leaf node and the nodes that are followed by the left child. For instance, $(1,5)(1,4)(1,3)(2,2)(2,0)$ is a path that connects the root node $(1,5)$ to the leaf node $(2,0)$. From this path node $(1,3)$ is deleted when listing because it is followed by the node $(2,2)$ which is its right child. Keeping from every remained pair only the first value, we get the ascending composition $[1,1,2,2]$.

Considering, on the one hand, the way in which the partition tree of $n$ was created, and on the other hand, the rule according to which we can convert any ordered tree into a binary tree, we can deduce the rule according to which we can directly create the partition strict binary tree of $n$. The root of partition strict binary tree of $n$ is labeled with $(1,n-1)$, the node $(x_{l},y_{l})$ is the left child of the node $(x,y)$ if and only if

[TABLE]

and the node $(x_{r},y_{r})$ is the right child of the node $(x,y)$ if and only if

[TABLE]

2 A special case of restricted integer partitions

The integer partitions in which the parts are at least as large as $m$ represent an example of partition with restrictions. We denote by $p(n,m)$ the number of partitions $\lambda\vdash n$ in which the parts are at least as large as $m$.

A special case of partitions that have parts at least as large as $m$ is the partition $\lambda\vdash n$ with the property $\lambda_{1}\geq t\cdot\lambda_{2}$, where $t$ is a positive integer. We consider that the partition $[n]$ has this property and we denote the number of these partitions by $p^{(t)}(n,m)$. For instance, $p^{(2)}(15,3)=7$, namely $15$ has seven partitions with parts as least as large as $3$ in which the first part is at least twice the second part: $[15]$, $[12,3]$, $[11,4]$, $[10,5]$, $[9,3,3]$, $[8,4,3]$ and $[6,3,3,3]$.

When $\left\lfloor\frac{n}{t+1}\right\rfloor<m\leq n$, it is easily seen that $p^{(t)}(n,m)=1$.

Theorem 2.1**.**

Let $n$, $m$ and $t$ be positive integers so that $m\leq\left\lfloor\frac{n}{t+1}\right\rfloor$. Then

[TABLE]

Proof.

If $\lambda\vdash n$ is a partition in which the parts are at least as large as $m$ and $\lambda_{1}\geq t\cdot\lambda_{2}$, then the smallest part from $\lambda$ is $m$ or is at least as large as $m+1$. The number of partitions $\lambda\vdash n$ with the smallest part $m$ and $\lambda_{1}\geq t\cdot\lambda_{2}$ is $p^{(t)}(n-m,m)$. Considering that $p^{(t)}(n,m+1)$ is the number of partitions $\lambda\vdash n$ where the smallest part is at least as large as $m+1$ and $\lambda_{1}\geq t\cdot\lambda_{2}$, the theorem is proved. ∎

For instance,

[TABLE]

The number $12$ has four partitions with parts at least as large as $3$ in which the first part is twice the second part: $[12]$, $[9,3]$, $[8,4]$ and $[6,3,3]$. The number $15$ has three partitions with parts at least as large as $4$ in which the first part is twice the second part: $[15]$, $[11,4]$ and $[10,5]$.

Theorem 2.2**.**

Let $n$, $m$ and $t$ be positive integers so that $m\leq\left\lfloor\frac{n}{t+1}\right\rfloor$. Then

[TABLE]

Proof.

We expand the term $p^{(t)}(n,m+1)$ from the relation (1) and take into account that $p^{(t)}\left(n,\left\lfloor\frac{n}{t+1}\right\rfloor+1\right)=1$. ∎

For example,

[TABLE]

The following theorem presents a recurrence relation that, applied consecutively, allows us to write the numbers $p^{(t)}(n,m)$ in terms of $p(n,m)$.

Theorem 2.3**.**

Let $n$, $m$ and $t$ be positive integers, so that $n>t>1$ and $m\leq\left\lfloor\frac{n}{t+1}\right\rfloor$. Then

[TABLE]

Proof.

We are to prove the theorem by induction on $n$. For $n=t+1$ we have $m=1$. Considering that $p^{(t)}(t+1,1)=2$, $p^{(t-1)}(1,1)=1$ and

[TABLE]

the base case of induction is finished. We suppose that the relation

[TABLE]

is true for any integer $n^{\prime}$, $t<n^{\prime}<n$. By Theorem 2.2 we can write

[TABLE]

and, on considering that

[TABLE]

and

[TABLE]

we get

[TABLE]

According to Theorem 2.2, the proof is finished. ∎

For instance,

[TABLE]

The number $15$ has three partitions with parts at least as large as $3$ in which the first part is thrice the second part: $[15]$, $[12,3]$ and $[9,3,3]$.

The $p^{(t)}(n,m)$ numbers are then also a direct generalization of the terminal compositions developed by Kelleher [4, section 5.4.1].

We denote by $p^{(t)}(n)$ the number of partitions $\lambda\vdash n$ that have the property $\lambda_{1}\geq t\cdot\lambda_{2}$. It is clear that $p^{(t)}(n)=p^{(t)}(n,1)$. We then immediately have the following result.

Corollary 2.4**.**

Let $n$ and $t$ be positive integers, so that $n>t>1$. Then

[TABLE]

The following two corollaries then follows easily from Corollary 2.4.

Corollary 2.5**.**

Let $n$ be a positive integer. Then, the number of partitions of $n$, that have the first part at least twice larger than the second part is

[TABLE]

For instance, $p^{(2)}(5)=p(5)-p(3)=7-3=4$, that means that number $5$ has four partitions that have the first part at least twice larger than the second part: $[5]$, $[4,1]$, $[3,1,1]$ and $[2,1,1,1]$. The sequence $p^{(2)}(n)$ appears in OEIS [8] as $A027336$. Corollary 2.5 is known and can be found in Kelleher [5, Corollary 4.1].

Corollary 2.6**.**

Let $n$ be a positive integer. Then, the number of partitions of $n$, that have the first part at least thrice larger than the second part is

[TABLE]

Proof.

For $n\in\left\{1,2,3\right\}$ the formula is immediately proved. For $n>3$ we apply Corollary 2.4 and Corollary 2.5. ∎

For example, $p^{(3)}(5)=p^{(2)}(5)-p^{(2)}(2)=4-1=3$, which means that number $5$ has three partitions that have the first part at least thrice larger than the second part: $[5]$, $[4,1]$ and $[3,1,1]$. The sequence $p^{(3)}(n)$ appears in OEIS [8] as $A121659$.

The next theorem allows us to deduce an upper bound for $p^{(3)}(n)$.

Theorem 2.7**.**

Let $n$ be a positive integer. Then

[TABLE]

Proof.

(G. E. Andrews, Personal Communication) To prove the theorem we use Euler’s formula [1]

[TABLE]

where

[TABLE]

We need to show that, except for the constant term, all the coefficients in

[TABLE]

are non-positive.

We have

[TABLE]

and clearly the coefficient of $q^{0}$ is $1$, the coefficients of $q^{k}$ for $1\leq k\leq 6$ are all [math], and for $k>6$ all the coefficients are negative. ∎

We can then present the following corollary of Theorem 2.7.

Corollary 2.8**.**

Let $n$ be a positive integer. Then

[TABLE]

Proof.

To prove this inequality we apply Corollary 2.4 and Theorem 2.8. ∎

3 Traversal of partition tree

To generate all the integer partitions of $n$ we can traverse in depth-first order the partition tree. To do this we need efficient traversal algorithms. Generally, for inorder traversing a binary tree we can efficiently use a stack. Strict binary trees are particular cases of binary trees and for their inorder traversal we can use Algorithm 1, built as algorithm INORD12 presented by Livovschi and Georgescu [7, pp. 66].

Analyzing Algorithm 1, we note that in the stack $S$ there are pushed only those nodes that are not leaf nodes in the strict binary tree for storing integer partition of $n$. As this strict binary tree has $2p(n)-1$ nodes, we deduce that algorithm 1 executes $p(n)-1$ operations of pushing in the stack $S$ (line 7) and the same number of operations of popping from the stack $S$ (line 12). The leaf nodes are visited in the line 10, and the inner nodes are visited in the line 13. Thus, we deduce that the total number of iterations of the internal while loop from the lines 5-18 is $p(n)$.

Strict binary trees for storing integer partitions are special cases of strict binary trees, while Algorithm 1 is a general algorithm for inorder traversal of the strict binary trees. Adapting Algorithm 1 to the special case of partition strict binary trees leads to more efficient algorithms for inorder traversal of these trees. Next we are to show how these algorithms can be obtained.

Let $(x,y)$ be a node from partition strict binary tree, so that $2x\leq y$. If $(x_{l},y_{l})$ is the left child of the node $(x,y)$ and has the property $2x_{l}>y_{l}$ then, $(x_{l},y_{l})$ is the root of a strict binary subtree with exactly three nodes: $(x,y-x)$, $(y-x,0)$ and $(y,0)$. If $(x_{r},y_{r})$ is the right child of the node $(x,y)$ and has the property $2x_{r}>y_{r}$ then $(x_{r},y_{r})$ is the root of a strict binary subtree where all the left descendents are leaf nodes. This note allows us to inorder traverse the partition strict binary tree by the help of a stack in which we push only those nodes $(x,y)$ that have the property $2x\leq y$. In this way, we get the Algorithm 2 for inorder traversal of the partition strict binary tree of $n$.

The number of the inner nodes that have the form $(x,y)$ with the property $2x\leq y$ is equal to the number of the partition of $n$ that have at least two parts where the first part is at least twice larger than the second part. Algorithm 2 executes $p^{(2)}(n)-1$ operations of pushing in the stack $S$ (line 7) and as many operations of popping from the stack $S$ (line 16). Any inner nodes that has the form $(x,y)$ with the property $2x>y$ has only a left child which is leaf node. A leaf node that has a left child is always visited in the line 11 and, by the help of Corollary 2.5, we deduce that the number of these nodes is $p(n-2)$. A leaf node that is a right child is visited in the line 14. It results that the total number of iterations of the internal while loop from the lines 5-22 is $p^{(2)}(n)$.

Thus, the reducing of the number of operations executed upon the stack allows to get a more efficient algorithm for traversing the partition strict binary tree. But the number of operations executed upon the stack could be reduced even more.

Let $(x,y)$ be a node from the partition strict binary tree, so that $3x\leq y$. If $(x_{l},y_{l})$ is the left child of the node $(x,y)$ and has the property $3x_{l}>y_{l}$, then $2x_{l}\leq y_{l}$ and $(x_{l},y_{l})$ is the root of a strict binary tree in which the left subtree is a strict binary tree in which all the left children are leaf nodes. This note allows us to modify Algorithm 2 in order to get a new algorithm for inorder traversing the partition strict binary trees. Thus, in Algorithm 3 we push in the stack $S$ only those inner nodes $(x,y)$ that have the property $3x\leq y$.

The number of the nodes $(x,y)$ with the property $3x\leq y$ from the partition strict binary tree of positive integer $n$ is equal to the number of partitions of $n$ that have at least two parts where the first one is at least three times larger than the second one. In this way, Algorithm 3 executes $p^{(3)}(n)-1$ operations of pushing in the stack $S$ (line 7) and as many operations of popping from the stack $S$ (line 26). In other words, the lines 7-8 are executed $p^{(3)}(n)-1$ times, in the same way as the lines 26-28. The total number of iterations of the internal while loop from the lines 10-19 is $p^{(2)}(n)-p^{(3)}(n)$, namely $p^{(2)}(n-3)$. The leaf nodes that are right children are visited in the lines 17 and 24. The number of these nodes is $p^{(2)}(n)$. Considering that the line 17 is executed $p^{(2)}(n-3)$ times, we deduce that the total number of iterations of the internal while loop from the lines 5-32 is $p^{(3)}(n)$.

4 Algorithms for generating ascending compositions

We showed above how we can use a stack for an efficient traversal of partition strict binary trees. In Algorithm 1, when visiting a node, the stack contains a part from the nodes that are on the path which connects that node to the root. Which are the nodes stored in the stack? A node is in a stack when another node is visited if and only if the visited node is the left child of the node from the stack. Taking into account the fact that partition strict binary trees have been obtained by converting partition trees, it is clear that, when visiting a leaf node, the content of the stack together with the leaf node represents a partition.

To get an efficient algorithm for generating ascending compositions, we can replace the stack from Algorithm 2 with an array that has nonnegative integer components $\left(a_{1},a_{2},\ldots,a_{k}\right)$, where $a_{1}$ represents the bottom of the stack and $a_{k}$ represents the top of the stack. If we give up visiting the inner nodes from Algorithm 2 and the visit of a leaf node is preceded by the visit of the array $\left(a_{1},a_{2},\ldots,a_{k}\right)$ we get Algorithm 4 for generating ascending compositions in lexicographic order.

Algorithm 4 is presented in a form that allows fast identification both of the correlation between the operations executed in the stack $S$ and the operations executed with the array $\left(a_{1},a_{2},\ldots,a_{k}\right)$, and the movement operations in the tree. Thus, the lines 8-10 are responsible with the pushing of the nodes in the stack and the movement in the left subtree. The extraction of the nodes of the stack is realized in the lines 27-29, and the movement in the right subtree is realized in the lines 19-20 and 30-31. A slightly optimized version of Algorithm 4 is presented in Algorithm 5.

We note that Algorithm 5 was rewritten without using the if statement and the boolean variable $c$. It is obvious that the statements from the first branch of the if statement could not be eliminated, but they were rearranged around the visit statement (line 21). This was possible because the initializing statement of the variable $k$ was changed. As Algorithm 5 executes less assignment statements and does not contain the if statement, the time required to execute Algorithm 5 is less than the time required to execute Algorithm 4.

Comparing the algorithm AccelAsc described and analyzed by Kelleher [4, 5] with Algorithm 5, we note that Algorithm 5 is a slightly modified version of the algorithm AccelAsc. In fact we have two presentations of the same algorithm. The differences are determined by the different methods of getting them.

The notes made upon the number of operations executed in Algorithm 2 allow us to determine how many times the assignment statement are executed and how many times the boolean expressions are evaluated in Algorithm 5.

Theorem 4.1**.**

Algorithm 5 executes $4p(n)+4p^{(2)}(n)$ assignment statements and evaluates $p(n)+3p^{(2)}(n)$ boolean expressions.

Proof.

The total number of iterations of the internal while loop from the lines 5-24 is $p^{(2)}(n)$, and the while loop contains $5$ assignment statements. The total number of iterations of the internal while loop from the lines 6-10 is $p^{(2)}(n)-1$, and the while loop contains $3$ assignment statements. The total number of iterations of the internal while loop from the lines 12-18 is $p(n-2)$, and the while loop contains $4$ assignment statements. Taking into account the first 3 assignment statements from the algorithm, we get the relation with which we determine the number of executions of assignment statements: $8p^{(2)}(n)+4p(n-2)$. The boolean expression from the line 5 is evaluated $p^{(2)}(n)+1$ times, the boolean expression from the line 6 is evaluated $p^{(2)}(n)+p^{(2)}(n)-1$ times, and the boolean expression from the line 12 is evaluated $p^{(2)}(n)+p(n-2)$ times. Thus, it results that the boolean expressions from the algorithm are evaluated $4p^{(2)}(n)+p(n-2)$ times. According to Corollary 2.5, the proof is finished. ∎

If in Algorithm 3 we execute the conversions made in Algorithm 2, we get Algorithm 6 for generating ascending composition in lexicographic order.

The notes made upon the number of operations executed in Algorithm 3 allow us to determine how many times the assignment statements are executed and how many times the boolean expressions are evaluated in Algorithm 6.

Theorem 4.2**.**

Algorithm 6 executes $4p(n)+5p^{(3)}(n)$ assignment statements and evaluates $p(n)+4p^{(3)}(n)$ boolean expressions.

Proof.

The total number of iterations of the internal while loop from the lines 5-44 is $p^{(3)}(n)$, and the while loop contains $6$ assignment statements. The total number of iterations of the internal while loop from the lines 6-10 is $p^{(3)}(n)-1$, and the while loop contains $3$ assignment statements. The total number of iterations of the internal while loop from the lines 13-31 is $p^{(2)}(n)-p^{(3)}(n)$, and the while loop contains $8$ assignment statements. The total number of iterations of the internal while loops from the lines 20-26 and 32-38 are $p(n-2)-\left(p^{(2)}(n)-p^{(3)}(n)\right)$, and each of them contains $4$ assignment statements. Taking into account the first 3 assignment statements from the algorithm, we get the relation with which we determine the number of executions of assignment statements: $5p^{(3)}(n)+4p^{(2)}(n)+4p(n-2)$. The boolean expression from the line 5 is evaluated $p^{(3)}(n)+1$ times, the boolean expression from the line 6 is evaluated $p^{(3)}(n)+p^{(3)}(n)-1$ times, the boolean expression from the line 13 is evaluated $p^{(2)}(n)$ times, and the boolean expressions from the lines 20 and 32 are evaluated $p^{(3)}(n)+p(n-2)$. It results that the boolean expressions from the algorithm are evaluated $4p^{(3)}(n)+p^{(2)}(n)+p(n-2)$ times. By Corollary 2.5 and Corollary 2.6 the proof is finished. ∎

Theorem 4.3**.**

Algorithm 6 is more efficient than Algorithm 5.

Proof.

According to Theorem 4.1 and Theorem 4.2, it is sufficient to show that

[TABLE]

By Corollary 2.4, we can rewrite this inequality as $p^{(2)}(n)\leq 4p^{(2)}(n-3)$. Using Corollary 2.4 and Corollary 2.8, we obtain

[TABLE]

Taking into account $p^{(2)}(n-1)\leq p^{(2)}(n)$, the theorem is proved. ∎

5 Experimental results and conclusions

We denote by $r_{1}(n)$ the ratio of the number of assignment statements executed by Algorithm 6 and the number of assignment statements executed by Algorithm 5,

[TABLE]

and by $r_{2}(n)$ the ratio of the number of boolean expressions evaluated by Algorithm 6 and the number of boolean expressions evaluated by Algorithm 5,

[TABLE]

We can see the evolution of the ratios $r_{1}(n)$ and $r_{2}(n)$, for $1<n\leq 1500$. The graph is realized in Maple [3] and allows to note that the best performances of Algorithm 6 compared to Algorithm 5 appears for $50\leq n\leq 150$.

Now let us measure CPU time for few values of $n$. To do this we encode the algorithms in C++ and the programs obtained with Visual C++ 2010 Express Edition will be run on three computers in similar conditions. The processor of the first computer is Intel Pentium Dual T3200 2.00 GHz, the processor of the second computer is Intel Celeron M 520 1.60GHz, and the the processor of third one is Intel Atom N270 1.60GHZ.

CPU time is measured when the program runs without printing out ascending compositions. We denote by $t_{1}(n)$ the average time for Algorithm 6 obtained after ten measurements, by $t_{2}(n)$ the average time for Algorithm 5 obtained after ten measurements, and by $r(n)$ the ratio of $t_{1}(n)$ and $t_{2}(n)$,

[TABLE]

In Table 1 we present the results obtained after the measurements made and also the ratios $r_{1}(n)$ and $r_{2}(n)$.

Analyzing the data presented in Table 1, we realize that the ratio $r_{2}(n)$ is a good approximation of the ratio $r(n)$, obtained experimentally on computers with Intel Pentium Dual or Intel Celeron processors. We note that the ratio $r(n)$ obtained on the computer with Intel Atom processors is well approximated by the ratio $r_{1}(n)$.

Algorithm 6 is the fastest algorithm for generating ascending compositions in lexicographic order in standard representation and can be considered an accelerated version of the algorithm AccelAsc that Kelleher [4, 5] presented.

Acknowledgements.

The author is greatly indebted to Professor George E. Andrews from the Department of Mathematics of The Pennsylvania State University who offered us the proof for Theorem 4 in a private context. The author would like to express his gratitude for the careful reading and helpful remarks to Oana Merca, which have resulted in what is hopefully a clearer paper. Moreover, the author wishes to thank the referee for his/her useful suggestions.