# DiscreteMathToolkit

## General

Category
Free
Tag
Mathematics
Min SDK
1 (Android 1.0)
Registered
May 7, 2017
Favorites
4
https://github.com/MarcinMoskala/KotlinDiscreteMathToolkit
MathParser
MathFu
MathView
kotlin-math
Calc

Language
Kotlin
Version
N/A
Created
Apr 5, 2017
Updated
Jul 2, 2020 (Retired)
Owner
Marcin Moskała (MarcinMoskala)
Contributors
2
Activity
Generate
Source code

# DiscreteMathToolkit

Set of extensions for Kotlin that provides Discrete Math functionalities as an Kotlin extension functions.

To stay current with news about library

# Permutations

```setOf(1, 2, 3).permutations() // {[1, 2, 3], [2, 1, 3], [3, 2, 1], [1, 3, 2], [2, 3, 1], [3, 1, 2]}
setOf(1, 2, 3).permutationsNumber() // 6
listOf(1, 2, 2).permutations() // {[1, 2, 2], [2, 1, 2], [2, 2, 1]}
listOf(1, 2, 2).permutationsNumber() // 3```

More examples here

# Combinations

```setOf(1, 2, 3, 4).combinations(3) // { {1, 2, 3}, {1, 2, 4}, {1, 4, 3}, {4, 2, 3} }
setOf(1, 2, 3, 4).combinationNumber(3) // 4

setOf(1, 2, 3, 4).combinationsWithRepetitions(2) // [{1=2}, {1=1, 2=1}, {1=1, 3=1}, {1=1, 4=1}, {2=2}, {2=1, 3=1}, {2=1, 4=1}, {3=2}, {3=1, 4=1}, {4=2}]
setOf(1, 2, 3, 4).combinationsWithRepetitionsNumber(2) // 10```

More examples here and here

# Powerset

Powerset of any set S is the set of all subsets of S, including the empty set and S itself.

```setOf(1, 2, 3).powerset() // { {}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3} }
setOf(1, 2, 3).powersetSize() // 8```

# Product

Product is the result of multiplying.

```(3..4).product() // 12
listOf(10, 10, 10).product() // 1000```

More examples here.

# Factorial

Factorian of n (n!) is a product of all positive integers less than or equal to n.

```3.factorial() // 6L
10.factorial() // 3628800L
20.factorial() // 2432902008176640000L```

More examples here.

# Numbers divisible and non-divisible by

```(1..1000).countNonDivisiveBy(2) // 500
(1..1000).countNonDivisiveBy(3) // 777
(1..1000).countNonDivisiveBy(2, 6, 13) // 462
(1..1000).countNonDivisiveBy(3, 7, 11) // 520

(1..1000).countDivisiveBy(2) // 500
(1..1000).countDivisiveBy(3) // 333
(1..1000).countDivisiveBy(2, 6, 13) // 538
(1..1000).countDivisiveBy(3, 7, 11) // 480```

More examples here.

# Splits of sets and numbers

In Descrete Math there are two functions used to count number of splits: S(n, k) - Stirling function - number of splits of n different elements to k groups P(n, k) - number of splits of n identical elements to k groups

```(1..n).toSet().splitsNumber(1) // 1
(1..n).toSet().splitsNumber(n) // 1
setOf(1, 2, 3).splitsNumber(2) // 3
setOf(1, 2, 3, 4).splitsNumber(2) // 7
setOf(1, 2, 3, 4, 5).splitsNumber(3) // 25
setOf(1, 2, 3, 4, 5, 6, 7).splitsNumber(4) // 350
setOf(1, 2, 3).splits(2) // { { {1, 2}, {3} },{ {1, 3}, {2} },{ {3, 2}, {1} } }```

More examples here

```n.splitsNumber(1) // 1
n.splitsNumber(n) // 1
7.splitsNumber(4) // 3
11.splitsNumber(4) // 11
9.splitsNumber(5) // 5
13.splitsNumber(8) // 7```

More examples here

# Iterable multiplication

Multiplication of iterables returns iterable with pairs of each possible connections of elements from first and iterable:

```listOf(1, 2) * listOf("A", "B") // returns List<Pair<Int, String>>
// [(1, "A"), (1, "B"), (2, "A"), (2, "B")]
listOf('a', 'b') * listOf(1, 2) * listOf("A", "B") // returns List<Triple<Char, Int, String>>
// [
//    ('a', 1, "A"), ('a', 1, "B"),
//    ('a', 2, "A"), ('a', 2, "B"),
//    ('b', 1, "A"), ('b', 1, "B"),
//    ('b', b, "A"), ('b', 2, "B")
// ] ```

More examples here.

# Cartesian product of lists

Similar to iterable multiplication but produces sequence of lists:

```listOf('A', 'B', 'C', D).cartesianProduct(listOf('x', 'y')) // returns List<List<Char>>
// [
//     ['A', 'x'],
//     ['A', 'y'],
//     ['B', 'x'],
//     ['B', 'y'],
//     ['C', 'x'],
//     ['C', 'y'],
//     ['D', 'x'],
//     ['D', 'y']
// ]
listOf(0, 1).cartesianProduct(repeat = 2) // returns List<List<Int>>
// [
//     [0, 0],
//     [0, 1],
//     [1, 0],
//     [1, 1]
// ]
listOf(1, 2).cartesianProduct(listOf("ABC")) // returns List<List<Any>>
// [
//     [1, "ABC"],
//     [2, "ABC"]
// ]```

More examples here.

# Java support

Library is fully supporting usage from Java. All functions can be used as static function of DiscreteMath. For example:

```DiscreteMath.permutationsNumber(set)
DiscreteMath.permutationsNumber(list)
DiscreteMath.factorial(10) // 3628800L```

Returned list and sets are Java standard lists and sets. More examples of Java usage here.

# Install

`compile "com.marcinmoskala:DiscreteMathToolkit:1.0.3"`

Maven:

``````<dependency>
<groupId>com.marcinmoskala</groupId>
<artifactId>DiscreteMathToolkit</artifactId>
<version>1.0.3</version>
</dependency>
``````

``````Copyright 2017 Marcin Moskała