For all performance evaluations presented in this document, including both single-threaded experiments in Section 3 and the multi-threaded experiments in Section 5, the following methodology was applied:

Each benchmark was executed at least three times, and the reported results correspond to the average execution time.Execution time was measured in nanoseconds by recording timestamps at the beginning and end of each run. All programs were compiled exclusively using the MSYS MinGW64 compiler.Benchmarks were performed on an AMD Ryzen 7 5800HS system (8 cores, 16 threads, 16 GB RAM). Output operations were disabled during benchmarking by commenting them out using “//” in C language. Performance improvements were determined by comparing the measured execution times. Algorithms ZS1 and Z1 generate each partition exactly once in standardrepresentation form and anti-lexicographic order. Algorithms ZS1 and Z1 generate partitions within the bounded range [X1, X2], where n ≥ X2 ≥ X1 ≥ 1 for any given integer n.

Input integer -> n;

Input lowest value of leftmost part -> x1;

Input highest value of leftmost part -> x2;

If (x1 = 1) then {x1 ⇓ 2};

For I ⇓ 0 to n do a[i] ⇓ 1;

A[1] ⇓ x2+1; h ⇓ 1; m ⇓ n – x2; x ⇓ 0;

A[1] ⇓ n; h ⇓ 1; m ⇓ 1; x ⇓ 0;

While(a[1]>=x1) do {

If (a[h] = 2) then {m ⇓ m + 1, a[h] ⇓ 1; h ⇓ h – 1;}

else {

t ⇓ m – h + 1; a[h] ⇓ a[h] – 1; r ⇓ a[h];

while (t >= r) do {h ⇓ h + 1; a[h] ⇓ r; t ⇓ t – r;}

if (t < 2) then {m ⇓ h + t;}

else { m ⇓ h + 1; h ⇓ h + 1; a[h] ⇓ t;}

}

if (a[1] >= x1) then {for i ⇓ 1 to m do output a[i];}

}

if (a[1] == 1) then {for i ⇓ 1 to n do output a[i];}

Algorithm ZS1 was extended to allow users to specify explicit lower [X1] and upper [X2] bounds on the leftmost part of a partition, thereby restricting the generation process to a selected subset of the integer partitions of n. The algorithm processes partition whose rightmost nonunit part equals 2 with exceptional efficiency: in such case, the successor partition is generated using only three elementary operations. This behavior confirms that Algorithm ZS1 satisfies a constant average delay property established in FastAlgorithmsforGeneratingIntegerPartitions.

As a result, Algorithm ZS1 remains the fastest known algorithm in its class and continues to be widely used. furthermore, as n increases, the proportion of partitions containing at least one part equal to 2 followed, when applicable by a sequence of 1’s grows significantly, as illustrated in Table 1.

For n = 50, 72.11% of the partitions end with a 2 followed, when applicable by a sequence of 1 s.For n = 170, this proportion increases to 83.05%.

Consequently, as n becomes larger, this behavior helps explain the strong empirical performance and scalability of Algorithm ZS1.

Algorithm Z1 is an optimized variant of ZS1, designed to accelerate the generation of integer partitions in standardrepresentation form and anti-lexicographic order. It supports explicit lower [X1] and upper [X2] bounds on the leftmost part, enabling restricted-range generation without altering the core structure of the algorithm. Its principal enhancement is a specialized fast path for partitions whose rightmost part is 3 followed, when applicable, by a sequence of 1 s. For the subset of cases 3 (x ≤ 3), illustrated in Table 1 and Table2, this optimization eliminates the iterative redistribution loop used in Algorithm ZS1.

Algorithm Z1 handles such partitions by directly redistributing the rightmost 3 and propagating the transformation until all 3 s and any intermediate 2 s are reduced to 1 s. For example, for n = 10, the partition (4, 3, 3), triggers case x = 0, producing the sequence:

(4,3,2,1),  (4,3,1,1,1),  

In the final partition, the trailing 3 reappears immediately before the block of 1 s, triggering case x = 3. Algorithm Z1 then directly generates:

(4,2,2,2),  (4,2,2,1,1),  (4,2,1,1,1,1),  (4,1,1,1,1,1,1).

AlgorithmZ1

Input integer -> n;

Input lowest value of leftmost part -> x1;

Input highest value of leftmost part -> x2;

If (x1 = 1) then {x1 ⇓ 2;};

For I ⇓ 0 to n do a[i] ⇓ 1;

A[1] ⇓ x2 + 1; h ⇓ 1; m ⇓ n – x2; x ⇓ 0;

While(a[1]>=x1) do {

While(a[h] = 2) do {

m ⇓ m+1, a[h] ⇓ 1; h ⇓ h – 1;

for i ⇓ 1 to m do output a[i];

}

if (a[h] = 3) then {

x ⇓ m – h; a[h] ⇓ 2;

if (x > 3) then {

while (x > 0) do {h ⇓ h+1; a[h] ⇓ 2; x ⇓ x – 2;}

if (x=0) then {m ⇓ h + 1;}

else {m ⇓ h;}

}

else if (x = 0) then { // m=h

m ⇓ m + 1;

for i ⇓ 1 to m do output a[i];

a[h] ⇓ 1; h ⇓ h – 1; m ⇓ m + 1;

}

else if (x = 1) then {

for i ⇓ 1 to h do output a[i]; output “ 2”;

for i ⇓ 1 to h do output a[i]; output “ 1 1”;

a[h] ⇓ 1; h ⇓ h – 1; m ⇓ m + 2;}

else if (x =2) then {

for i ⇓ 1 to h do output a[i]; output “ 2 1”;

for i ⇓ 1 to h do output a[i]; output “ 1 1 1”;

a[h] ⇓ 1; h ⇓ h – 1; m ⇓ m + 2;}

else { // x=3

for i ⇓ 1 to h do output a[i]; output “ 2 2”;

for i ⇓ 1 to h do output a[i]; output “ 2 1 1”;

for i ⇓ 1 to h do output a[i]; output “ 1 1 1 1”;

a[h] ⇓ 1; h ⇓ h – 1; m ⇓ m + 2;

}

// for all cases x=0, x=1, x=2, x=3

for i ⇓ 1 to m do output a[i];

} /* a[h] =3 */

else if (a[h] > 3) then {

t ⇓ m – h + 1; a[h] ⇓ a[h] – 1; r ⇓ a[h]

while (t >= r) do {h ⇓ h+1; a[h] ⇓ r; t ⇓ t – r}

if (t <2) then {m ⇓ h + t;}

else { m ⇓ h + 1; h ⇓ h + 1; a[h] ⇓ t;}

for i ⇓ 1 to m do output a[i];

} /* a[h] > 3 */

} /* while a[1] >= x1 */

Each output partition is constructed by concatenating a fixed prefix with suffixes obtained through redistribution of the rightmost 3. For example, when n = 11, the partition (4, 3, 2, 2), has prefix (4, 3) which is then combined with all partitions generated from redistributing (2, 2), such as (2, 1, 1) and (1, 1, 1, 1), yielding:

(4, 3, 2, 1, 1),  (4, 3, 1, 1, 1, 1).

This direct concatenation mechanism eliminates repeated state reconstruction and reduces several inner-loop transitions, resulting in an additional efficiency gain of approximately 5%. For n= 170, this increases the overall performance improvement to approximately 89%.

By explicitly handling rightmost 3 (x ≤ 3) structures, algorithm Z1 removes the most computationally expensive iterative steps present in algorithm ZS1, leading to significantly lower average delay and improved empirical performance. As a result, only rightmost 3 (x > 3) structures remain within the iterative process.

Algorithm Z1 further accelerates partition generation by optimizing cases in which the rightmost structure consists of a 2 or 3 (x ≤ 3), followed by any number of 1 s.

For n = 170, Algorithm Z1 produces:

207,202,977,471 partitions where the rightmost part is 2 before the trailing block of 1 s.31,862,447,624 partitions where the rightmost part is 3 (x ≤ 3) before the trailing block of 1 s. Table 1 shows that Count_3 (x ≤ 3) = 10,860,692,344 which are processed in batches to generate 31,862,447,624 partitions.

In comparison, Algorithm ZS1 generates 228,204,732,751 such partitions ending in 2. The difference

228,204,732,751 − 207,202,977,471 = 21,001,755,280

corresponds to partitions in which a 2 is created exclusively through the processing of rightmost 3 (x ≤ 3) structures. Algorithm Z1 handles these cases collectively whenever a rightmost 3 (x ≤ 3) is encountered, thereby improving efficiency. For clarification (21,001,755,280 + 10,860,692,344 = 31,862,447,624).

For n = 150, Algorithm Z1 increases the proportion of special-case partitions from 82.12% (ZS1) to 86.43% (Z1).

For n = 170, this proportion rises from 83.05% (ZS1) to 87.01% (Z1). Refer to Table 1.

These results show that as n increases, partitions whose rightmost parts equal to 2 or 3 (x ≤ 3) constitute an increasingly large share of all partitions.

For n = 170, as shown in Table 3, algorithm ZS1 required 1099.354004 seconds in a single-threaded execution, whereas algorithm Z1 completed the same task in 696.825012 seconds, representing a 36.38% reduction in execution time.

Table 3. Z1 Time saving seconds percentage.

When evaluated using the MSYS MinGW64 compiler on an Intel^TM Core i7-12700H (2.3 GHz), performance tests for n= 150 show that algorithm ZS1 required 522.903992 seconds in a sequential run, whereas algorithm Z1 completed the same task in 297.003902 seconds, representing 43.20% reduction in execution time.

These results indicate that the performance advantages of Algorithm Z1 are influenced by both hardware configuration and compiler environment.

Constant Average Delay Property for Algorithm Z1

Algorithm Z1 is organized into three components for generating the partitions of a given n:

Generation of partitions with leftmost part equal 2 (followed, if applicable, by 1 s) Generation of partitions with leftmost part equal 3 (followed, if applicable, by 1 s) Generation of partitions with leftmost part greater than 3

For partitions whose leftmost part is 2, the generation procedure is identical to that of the original Algorithm ZS1 and requires no modification.

For partitions with leftmost part greater than 3, consider for example n = 17 with the partition

(4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1).

The next partition generated is

(3, 3, 3, 3, 3, 2).

In this case, the loop redistributes the 1 s t = n − p = 17 − 4 = 13, using parts of size p = 4 − 1 = 3, followed by a minor adjustment. The number of iterations is therefore approximately ⌊13/3⌋, plus a constant term, resulting in about five iterations. As the size of the redistributed part p increases, the number of required iterations decreases.

For example, when n = 17, if the leftmost part is 10 instead of 4, the partition

(10, 1, 1, 1, 1, 1, 1, 1)

is transformed into

(9, 8),

requiring only a single iteration. The leftmost part 9, is obtained by decrementing 10, by 1. Each iteration of the while loop performs a constant number of operations, approximately three.

The most computationally expensive iterations occur when a part of size p = 4 is redistributed into parts of size 3, In this situation, the number of loop iterations is on the order of

W = ⌊(t + 1)/(p − 1)⌋ + S).

where, S = 0 if (⌊(t + 1)/(p − 1)⌋ mod 0) = 0,

S = 1 if (⌊(t + 1)/(p − 1)⌋ mod 0) > 0

Consequently, the total number of instructions C required to generate the next partition, including loop execution, termination, and trailing conditional operations, can be expressed as follows:

U= 3 (instructions per partition generation),

Q = 3 (termination and trailing conditions)

C = ((⌊(t + 1)/(p − 1)⌋ + S) * U + Q

or equivalently,

C = W * U + Q.

For partitions whose leftmost part is 3, we consider the cases 3 (x ≤ 3), where x denotes the number of trailing 1 s. In these cases, the iterative procedure is replaced by a constant number of instructions (at most ten), including the conditional branching to determine the correct generation path. Each case produces a small batch of partitions via direct concatenation, without arithmetic iteration. When x = 3, four partitions are generated; when x = 2 or x = 1, three partitions are generated; and when x = 0, two partitions are generated. This yields an upper bound of C = 10 operations per generated partition.

When x > 3, the iterative procedure is again required, and the same expression C = W * U + Q applies.

Therefore, the most computational expensive iterations occur when t = n − 3 and p = 3, giving

C = (⌊((n − 3) +1)/2⌋ + S) * 3 + 3.

For example, when n = 15, the partition

(3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)

generates the partition

(2, 2, 2, 2, 2, 2, 2, 1), using

C = ((12 + 1)/2 + 1) * 3 + 3. C = 7 * 3 + 3. C = 24.

Let RP(n, m) denote the number of restricted partitions of n using at most m parts.

Lemma 1 and Theorem 1 are taken from my paper “FastAlgorithmsforGeneratingIntegerPartitions”. [2]

Lemma1. RP(n, L2) ≥ n²/12 for L2 ≥ 3.

Proof. Since RP(n, L2) ≥ RP(n, 3) for L2 > 3, it is sufficient to prove RP(n, 3) ≥ n²/12. In the multiplicityrepresentation, the partitions RP(n, 3) are the following kind: n = 3c₁ + 2c₂ + 1c₃ (i.e.y₁ = 3, y₂ = 2, y₃ = 1). The number of such partitions is equal to the number of the solutions of the above equation. Clearly 0 ≤ c₁ ≤ ⌊n/3⌋. For each c₁ in the interval we solve the equation 2c₂ + c₃ = n – 3c₁. This equation has a unique solution c₃ for each c₂, 0 ≤ c₂ ≤ ⌊n − 3c₁/2⌋. Therefore, for fixed c₁, the number of solutions is (⌊n − 3c₁)/2⌋ + 1 ≥ (n − 3c₁)/2. Taking values of c₁ into account, the number of solutions is ≥n/2 + (n − 3)/2 + (n − 6)/2 + … + (n − 3⌊n/3⌋)/2 = (⌊n/3⌋ + 1)n/2 − ⌊n/3(n⌊/3⌋ + 1)3/4 = (⌊n/3⌋ + 1)(n/2 − ⌊n/3⌋3/4) ≥ (⌊n/3⌋ + 1)(n/2 − n/4) ≥ n²/12.

Theorem1. Algorithms ZS1 and Z1 generate unrestricted integer partitions in Standardrepresentation with constant average delay, exclusive of the output.

Proof. Consider x_i ≥ 3 in the current partition. It received its value after a backtracking search (starting from the last part) was performed to find an index j ≤ i, called the turning point, that should change its value by 1 (increase/decrease for anti-lexicographic order) and to update values x_i for j ≤ i. The time to perform both backtracking searches is O(r_j) where r_j = n − x₁ − x₂ − … − x_j is the remainder to distribute after first j parts are fixed. We decided to change the cost of the backtrack search evenly to all “swept” parts, such that each of them receives constant O(1) time. Part x_i will be changed only after a similar backtracking step “swept” over i-th part or recognized i-th part as the turning point (note that i-th part is the turning point at least one of the two backtracking steps). There are RP(r_i, x_i) such partitions which all keep x_i intact. For x_i ≥ 3 the number of such partitions, according to Lemma 1, is ≥r_i²/12. Therefore, the average number of operations that are performed by such part i during the “run” of RP(r_i, x_i), including the change of its value, is O(1)/RP(r_i, x_i) ≤ O(1)/r_i² = O(1/r_i²) < q_i/r_i² where q_i is a constant. Thus the average number of operations for all parts of size ≥ 3 is ≤q₁/r₁² + q₂/r₂² + …+ q₃/r₃² ≤ q(1/r₁² + … + 1/r₃²) < q(1/n² + 1/(n − 1)² + … + 1/1²) < 2q (the last inequality can be obtained easily by applying integral operation on the last sum), which is a constant. The case in which x_i ≤ 2 was not considered. In this case, however, both algorithms ZS1 and Z1 perform a constant number of steps per partition on all such parts. Therefore, the algorithms ZS1 and Z1 have overall constant time average delay.

Algorithm Z3, a refinement of algorithm Z1, as illustrated in Figure 2, generates a balanced distribution of partition subsets by:

Figure 2. Example of algorithm Z3 input/output.

Dividing the full set of partitions into disjoint subsets.Ensuring that all partitions sharing the same leftmost part are grouped within the same subset.Organizing these subsets to enable efficient parallel or distributed execution.

The PartitionsFactor parameter improves load balancing by enabling a more uniform distribution of partitions across subsets. Each subset is assigned based on the total number of partitions and the number of available threads. Since all partitions sharing the same leftmost part must remain grouped together, any subset boundary that would otherwise divide such a block instead assigns the entire block to the next subset. As a result, the subsets do not contain identical numbers of partitions.

To facilitate efficient parallel execution, Algorithms Z1 and ZS1 were also adapted to accept input parameters directly from a batch file.

int main(int arg1, char *argv[]) {

n = atoi (argv[3]); x₁ = atoi (argv[4]); x₂ = atoi (argv[5]);

as an example in the batch file Z1a190.16.bat below: n = 190, x₁ = 28, x₂ = 29 etc….

Example of batch file: Batch file name: Z1a190.16.bat

echo Starting launching All scripts in parallel

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 28 29

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 26 27

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 31 32

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 23 24

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 52 190

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 33 34

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 39 41

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 42 45

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 46 51

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 18 20

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 21 22

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 35 36

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 37 38

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 25 25

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 30 30

start C:/msys64/mingw64/code/Z1a 3 Z1a 190 1 17

echo Finish launching All scripts in parallel

Tasks are prioritized according to partition count and estimated execution time, with larger workloads scheduled first in order to reduce startup imbalance and ensure a more even distribution of computational load across threads.

Algorithm Z3 computes P(n) using a single array. For example, for n = 200, it produces P(200) = 3,972,999,029,388. However, due to hardware and compiler constraints, generating all partitions for this value in a single sequential run is impractical. Empirical tests on an AMD Ryzen 7 5800HS system (8 cores, 16 threads, 16 GB RAM) indicate that the largest value that can be reliably handled on a single system is approximately n = 170, although this limit ultimately depends on the available hardware resources.

For n = 190, a complete single-run execution of Algorithm ZS1 resulted in system instability. While sequential execution of individual subsets completed successfully in 6139 seconds, parallel execution of all subsets was not feasible.

Similarly, for Algorithm Z1 at n = 190, a complete single-run execution also proved unstable. However, sequential execution of the subsets completed successfully in 4174 seconds, and parallel execution of all subsets was achievable representing a 32% reduction in total execution time compared with ZS1 (4174 seconds versus 6139 seconds).

For n = 200, generating all partitions in a single run using Algorithm ZS1, was not possible. Although sequential execution of the individual subsets remained feasible, full parallel execution again resulted in instability.

For Algorithm Z1 at n = 200, single-run generation was likewise not achievable; however, sequential execution of the subsets remained stable and provided approximately a 34% performance improvement over Algorithm ZS1. For example, the subset 60 - 200 required 596 seconds under Algorithm ZS1, compared with 393 seconds under algorithm Z1. Full parallel execution of all subsets within a single batch was not stable; consequently, parallel processing was curried out across three batches, although occasional instability was still observed.

Performance of Algorithms ZS1 and Z1 was evaluated under multi-threaded execution model, where multiple instances of each program were executed concurrently, with each instance responsible for generating a distinct subset of the integer partition space.

Partition subsets were assigned to threads through iterative tuning to obtain an approximately optimal balance of computational workload across threads.

5.1.1. Algorithm ZS1, 16 Threads, n = 170

For n = 170, as illustrated in Table 4, execution using sixteen-thread reduced the runtime from 1099.354 seconds in sequential mode to 157.539 seconds, corresponding to 14.33% of the original runtime and representing a reduction of 85.67%. CPU utilization reached 100% at the start of execution and subsequently stabilized at approximately 97%.

5.1.2. Algorithm Z1, 16 Threads, n = 170

Under identical experimental conditions, as illustrated in Table 5, Algorithm Z1 was executed using sixteen parallel threads on the same hardware platform, with each thread assigned a distinct subset of the integer partition space. The parallel

Table 4. Algorithm ZS1, 16 Threads, n = 170.

Table 5. Algorithm Z1, 16 Threads, n = 170.

execution completed in 124.427 seconds, compared with 696.825 seconds for the sequential execution. This corresponds to 17.86% of the sequential runtime (124.427 seconds, versus 696.825 seconds) and represents an overall reduction of 82.14% in execution time. Similarly, CPU utilization reached 100% at the start of execution and subsequently stabilized at approximately 97%.

Under sixteenthread parallel execution on the same hardware platform, Algorithm Z1 achieved 78.98% of the runtime of Algorithm ZS1 (124.427002 seconds versus 157.539993 seconds), corresponding to a performance improvement of 21.02%.

Algorithm Z1 serves as a highly efficient sequential baseline, characterized by strong runtime performance and minimal execution overhead. Although some parallel algorithms may offer higher throughput or improved scalability, these gains are often accompanied by additional coordination, communication, and synchronization costs. Consequently, the practical advantages of parallelism depend heavily on the structure and characteristics of the workload. In this context, Algorithm Z1 remains a competitive approach, particularly in environments where overhead limitations reduce the effectiveness of parallel execution.