数理統計: 重複順列と順列

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
55
56
57
58
59
60
61
62
63
64
65
import numpy as np
import math

def poch(z, m):
    """The Pochhammer symbol (rising factorial), is defined as
        (z)_m = Gamma(z+m)/Gamma(z)
        Gamma(z) = (z-1)! where m is int
    Parameters:	
    ----------
    z : array_like(int or float)
    m : array_like(int or float)
    Returns:	
    ----------
    poch : ndarray The value of the function.
    """
    if (z <= 0) or (m < 0):
        return 0
    return math.gamma(z+m)/math.gamma(z)

def perm(N, k, exact=False, repetition=False):
    """Permutations of N things taken k at a time, i.e., k-permutations of N.
    It's also known as "partial permutations".
    Parameters
    ----------
    N : int, ndarray
        Number of things.
    k : int, ndarray
        Number of elements taken.
    exact : bool, optional
        If `exact` is False, then floating point precision is used, otherwise
        exact long integer is computed.
    Returns
    -------
    val : int, ndarray
        The number of k-permutations of N.
    Notes
    -----
    - Array arguments accepted only for exact=False case.
    - If k > N, N < 0, or k < 0, then a 0 is returned.
    Examples
    --------
    >>> k = np.array([3, 4])
    >>> n = np.array([10, 10])
    >>> perm(n, k)
    array([  720.,  5040.])
    >>> perm(10, 3, exact=True)
    720
    """
    if exact:
        if (k > N) or (N < 0) or (k < 0):
            return 0
        val = 1
        for i in range(N - k + 1, N + 1):
            val *= i
        return val
    else:
        _poch = np.vectorize(poch)
        k, N = np.asarray(k), np.asarray(N)
        cond = (k <= N) & (N >= 0) & (k >= 0)
        vals = _poch(N - k + 1, k)
        if isinstance(vals, np.ndarray):
            vals[~cond] = 0
        elif not cond:
            vals = np.float64(0)
        return vals

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
import numpy as np
import math

def poch(z, m):
    """The Pochhammer symbol (rising factorial), is defined as
        (z)_m = Gamma(z+m)/Gamma(z)
        Gamma(z) = (z-1)! where m is int
    Parameters:	
    ----------
    z : array_like(int or float)
    m : array_like(int or float)
    Returns:	
    ----------
    poch : ndarray The value of the function.
    """
    if (z <= 0) or (m < 0):
        return 0
    return math.gamma(z+m)/math.gamma(z)

def comb(N, k, exact=False, repetition=False):
    """The number of combinations of N things taken k at a time.
    This is often expressed as "N choose k".
    Parameters
    ----------
    N : int, ndarray
        Number of things.
    k : int, ndarray
        Number of elements taken.
    exact : bool, optional
        If `exact` is False, then floating point precision is used, otherwise
        exact long integer is computed.
    repetition : bool, optional
        If `repetition` is True, then the number of combinations with
        repetition is computed.
    Returns
    -------
    val : int, float, ndarray
        The total number of combinations.
    See Also
    --------
    binom : Binomial coefficient ufunc
    Notes
    -----
    - Array arguments accepted only for exact=False case.
    - If N < 0, or k < 0, then 0 is returned.
    - If k > N and repetition=False, then 0 is returned.
    Examples
    --------
    >>> k = np.array([3, 4])
    >>> n = np.array([10, 10])
    >>> comb(n, k, exact=False)
    array([ 120.,  210.])
    >>> comb(10, 3, exact=True)
    120
    >>> comb(10, 3, exact=True, repetition=True)
    220
    """
    if repetition:
        return comb(N + k - 1, k, exact)
    if exact:
        if (k > N) or (N < 0) or (k < 0):
            return 0
        val = 1
        for i in range(N - k + 1, N + 1):
            val *= i
        for i in range(2, k + 1):
            val //= i
        return val
    else:
        _poch = np.vectorize(poch)
        _gamma = np.vectorize(math.gamma)
        k, N = np.asarray(k), np.asarray(N)
        cond = (k <= N) & (N >= 0) & (k >= 0)
        vals = _poch(N - k + 1, k)/_gamma(k+1)
        if isinstance(vals, np.ndarray):
            vals[~cond] = 0
        elif not cond:
            vals = np.float64(0)
        return vals

1
2
3
4
5
6
7
8
9
10
import itertools

all = itertools.combinations_with_replacement(['blue', 'red', 'black'], 4)
card = 0
print("---出力結果---")
for x in all:
    card +=1
    print(x)
print("---総数---")
print(card)

1
2
3
4
5
6
7
8
9
10
11
color_list = ['blue', 'red', 'black']
all = itertools.combinations_with_replacement(color_list, 2)
card = 0

print("---出力結果---")
for x in all:
    card +=1
    tmp = color_list + list(x)
    print(sorted(tmp))
print("---総数---")
print(card)

1
2
3
4
5
6
7
8
9
10
11
12
13
import collections
import itertools

coef_list = ['x', 'y', 'z', 'w']
all = itertools.combinations_with_replacement(coef_list, 6)
card = 0

print("---出力結果---")
for x in all:
    card +=1
    print(collections.Counter(x))
print("---総数---")
print(card)