parts: Enumerate the partitions of an integer

Description Usage Arguments Details Note Author(s) References See Also Examples

Description

\loadmathjax

Given an integer, return a matrix whose columns enumerate various partitions.

Function parts() returns the unrestricted partitions; function diffparts() returns the unequal partitions; function restrictedparts() returns the restricted partitions; function blockparts() returns the partitions subject to specified maxima; and function compositions() returns all compositions of the argument.

Usage

1
2
3
4
5
6
7
parts(n)
diffparts(n)
restrictedparts(n, m, include.zero=TRUE, decreasing=TRUE)
blockparts(f, n=NULL, include.fewer=FALSE)
compositions(n, m=NULL, include.zero=TRUE)
multiset(v,n=length(v))
mset(v)

Arguments

n

Integer to be partitioned. In function blockparts(), the default of NULL means to return all partitions of any size

m

In functions restrictedparts() and compositions(), the order of the partition

include.zero

In functions restrictedparts() and compositions(), Boolean with default FALSE meaning to include only partitions of n into exactly m parts; and TRUE meaning to include partitions of n into at most m parts (because zero parts are included)

include.fewer

In function blockparts(), Boolean with default FALSE meaning to return vectors whose sum is exactly n and TRUE meaning to return partitions whose sum is at most n

decreasing

In restrictedparts(), Boolean with default TRUE meaning to return partitions whose parts are in decreasing order and FALSE meaning to return partitions in lexicographical order, as appearing in Hindenburg's algorithm. Note that setting to decreasing to FALSE has the effect of making conjugate() return garbage

f

In function blockparts(), a vector of strictly positive integers that gives the maximal number of blocks; see details

v

In function multiset(), an integer vector representing a multiset. Argument n is the size of the sample to be taken

Details

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
>  parts(7)
                                  
[1,] 7 6 5 5 4 4 4 3 3 3 3 2 2 2 1
[2,] 0 1 2 1 3 2 1 3 2 2 1 2 2 1 1
[3,] 0 0 0 1 0 1 1 1 2 1 1 2 1 1 1
[4,] 0 0 0 0 0 0 1 0 0 1 1 1 1 1 1
[5,] 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1
[6,] 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1
[7,] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
> P(7)
[1] 15
> diffparts(9)
                    
[1,] 9 8 7 6 6 5 5 4
[2,] 0 1 2 3 2 4 3 3
[3,] 0 0 0 0 1 0 1 2
> Q(9)
[1] 8
> restrictedparts(9,4)
                                        
[1,] 9 8 7 6 5 7 6 5 4 5 4 3 6 5 4 4 3 3
[2,] 0 1 2 3 4 1 2 3 4 2 3 3 1 2 3 2 3 2
[3,] 0 0 0 0 0 1 1 1 1 2 2 3 1 1 1 2 2 2
[4,] 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 2
> R(4,9,include.zero=TRUE)
[1] 18
> blockparts(1:4,5)
                                                
[1,] 1 1 0 1 1 0 1 0 1 1 0 1 0 0 1 0 1 0 0 1 0 0
[2,] 2 1 2 2 1 2 0 1 2 1 2 0 1 0 1 2 0 1 0 0 1 0
[3,] 2 3 3 1 2 2 3 3 0 1 1 2 2 3 0 0 1 1 2 0 0 1
[4,] 0 0 0 1 1 1 1 1 2 2 2 2 2 2 3 3 3 3 3 4 4 4
> S(1:4,5)
[1] 22
> compositions(5,3)
                                              
[1,] 5 4 3 2 1 0 4 3 2 1 0 3 2 1 0 2 1 0 1 0 0
[2,] 0 1 2 3 4 5 0 1 2 3 4 0 1 2 3 0 1 2 0 1 0
[3,] 0 0 0 0 0 0 1 1 1 1 1 2 2 2 2 3 3 3 4 4 5
> S(rep(5,3),5)
[1] 21
> setparts(4)
                                  
[1,] 1 1 1 1 2 1 1 1 1 1 1 2 2 2 1
[2,] 1 1 1 2 1 2 1 2 2 1 2 1 1 3 2
[3,] 1 2 1 1 1 2 2 1 3 2 1 3 1 1 3
[4,] 1 1 2 1 1 1 2 2 1 3 3 1 3 1 4
>  setparts(c(1,2,2))
                                  
[1,] 1 1 1 1 1 1 1 1 1 1 1 1 3 3 3
[2,] 2 2 3 1 1 1 2 2 3 2 2 3 1 1 1
[3,] 3 2 2 3 2 2 1 1 1 3 2 2 2 1 2
[4,] 2 3 2 2 3 2 3 2 2 1 1 1 2 2 1
[5,] 1 1 1 2 2 3 2 3 2 2 3 2 1 2 2

Note

These vectorized functions return a matrix whose columns are the partitions. If this matrix is too large, consider enumerating the partitions individually using the functionality documented in nextpart.Rd.

One commonly encountered idiom is blockparts(rep(n,n),n), which is equivalent to compositions(n,n) [Sloane's A001700].

If you have a minimum number of balls in each block, a construction like

1
2
3
4
5
    x <- c(1,1,2,1)   # min
    y <- c(2,3,4,5)   # max
    
    sweep(blockparts(y-x,7-sum(x)),1,x,"+")
  

can be helpful (that is, subtract off the minimum number of balls and add them back again at the end).

Author(s)

Robin K. S. Hankin

References

See Also

nextpart

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
parts(5)
diffparts(10)
matplot(t(diffparts(27)),type='l',lty=1)

restrictedparts(9,4)
restrictedparts(9,4,FALSE)
restrictedparts(9,4,decreasing=TRUE)

blockparts(1:4)
blockparts(1:4,3)
blockparts(1:4,3,include.fewer=TRUE)

blockparts(c(4,3,3,2),5)  # Knuth's example, pre-fascicle 3a, p16

compositions(4)           # not the same as parts(4)
compositions(4,4) 

# With 10 blocks, enumerate all partitions with maxima of 1:5 and minima
# of c(0,1,1,2,1):

a <- c(0,1,1,2,1)
sweep(blockparts(1:5-a,10-sum(a)),1,a,"+")

#Knuth's example:
multiset(c(1,2,2,3))

multiset(rep(4+1:3,1:3),3)

RobinHankin/partitions documentation built on Feb. 18, 2021, 2:26 a.m.