Gene Boggs > Math-Counting-0.1303 > Math::Counting

Math-Counting-0.1303.tar.gz

Dependencies

Annotate this POD

# CPAN RT

 Open 0
View/Report Bugs
Module Version: 0.1303

# NAME

Math::Counting - Combinatorial counting operations

version 0.1303

# SYNOPSIS

```  use Math::Counting ':student';
printf "Given n=%d, k=%d:\nF=%d\nP=%d\nC=%d\n",
\$n, \$k, factorial(\$n), permutation(\$n, \$k), combination(\$n, \$k);```

Engineering

```  use Math::Counting ':big';
printf "Given n=%d, k=%d, r=%d:\nF=%d\nP=%d\nD=%d\nC=%d\n",
\$n, \$k, \$r, bfact(\$n), bperm(\$n, \$k, \$r), bderange(\$n), bcomb(\$n, \$k, \$r);```

# DESCRIPTION

Compute the factorial, number of permutations and number of combinations.

The `:big` functions are wrappers around "bfac" in Math::BigInt with a bit of arithmetic between. Also the `bperm` function accepts an additional boolean to indicate repetition.

The student versions exist to illustrate the computation "in the raw" as it were. To see these computations in action, Use The Source, Luke.

# NAME

Math::Counting - Combinatorial counting operations

# FUNCTIONS

## factorial

`  \$f = factorial(\$n);`

Return the number of arrangements of n, notated as `n!`.

This function employs the algorithmically elegant "student" version using real arithmetic.

## bfact

`  \$f = bfact(\$n);`

Return the value of the function "bfac" in Math::BigInt, which is the "Right Way To Do It."

## permutation

`  \$p = permutation(\$n, \$k);`

Return the number of arrangements, without repetition, of k elements drawn from a set of n elements, using the "student" version.

## bperm

`  \$p = bperm(\$n, \$k, \$r);`

Return the computations:

```  n^k           # with repetition
n! / (n-k)!   # without repetition```

## bderange()

"A derangement is a permutation in which none of the objects appear in their "natural" (i.e., ordered) place." -- wolfram under "SEE ALSO"

Return the computation:

`  !n = n! * ( sum (-1)^k/k! for k=0 to n )`

## combination

`  \$c = combination(\$n, \$k);`

Return the number of ways to choose k elements from a set of n elements, without repetition.

This is algorithm expresses the "student" version.

## bcomb

`  \$c = bcomb(\$n, \$k, \$r);`

Return the combination computations:

```  (n+k-1)! / k!(n-1)!   # with repetition
n! / k!(n-k)!         # without repetition```

# TO DO

Allow specification of the math processor to use.

Provide the gamma function for the factorial of non-integer numbers?

"bfac" in Math::BigInt

Higher Order Perl by Mark Jason Dominus (http://hop.perl.plover.com).

Mastering Algorithms with Perl by Orwant, Hietaniemi & Macdonald (http://www.oreilly.com/catalog/maperl).

http://www.mathsisfun.com/combinatorics/combinations-permutations-calculator.html

http://mathworld.wolfram.com/Derangement.html

Naturally, there are a plethora of combinatorics packages available, take your pick:

# CREDITS

Special thanks to:

* Paul Evans

* Mike Pomraning

* Petar Kaleychev

* Dana Jacobsen

# AUTHOR

Gene Boggs <gene@cpan.org>