Dokumentation - Server Grundfunktionen (public)

Primzahlen & Teilbarkeit

static math::primeFactor ($integer $n = 0)

`$n`	Zahl, die zerlegt werden soll

führt eine Primfaktorzerlegung durch und gibt die Primfaktoren aufsteigend sortiert als array zurück


    math::primeFactor(200); // [2, 2, 2, 5, 5]

static math::isPrime ($integer $n = 0)

`$n`	Zahl, die geprüft werden soll

prüft ob eine ganze Zahl ab 2 eine Primzahl ist; schließt gerade Zahlen > 2 sofort aus und prüft ungerade Teiler bis √n; Rückgabe von true oder false


    math::isPrime(17); // true

    math::isPrime(200); // false

static math::prime ([$integer $n = 100])

`$n`	optional; Zahl als Obergrenze; default ist 100

gibt ein array aller Primzahlen von 2 bis zur angegebenen Zahl $n zurück


    math::prime(30); // [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

static math::ggT ($array $numbers = null)

$numbers ein array mit ganzzahligen Werten

bildet den größten gemeinsamen Teiler (ggT) aller Zahlen und gibt diesen als integer zurück; im Fehlerfall null


    math::ggT([50, 25]); // 25

static math::kgV ($array $numbers = null)

$numbers ein array mit ganzzahligen Werten

bildet das kleinste gemeinsame Vielfache (kgV) aller Zahlen und gibt dieses als integer zurück; im Fehlerfall null


    math::kgV([50, 25]); // 50

static math::facul ([$integer $n = 10])

`$n`	optional; Zahl, von welcher die Fakultät errechnet wird; default ist 10

berechnet die Fakultät der eingegebenen Zahl als integer; im Fehlerfall null


    math::facul(5); // 120

Römische Zahlen

static math::numberToRoman ([$integer $num = 10])

$num optional; positive Zahl, die umgewandelt werden soll; default ist 10

wandelt eine dezimale Zahl in eine römische Zahl als string um; im Fehlerfall null


    math::numberToRoman(14); // 'XIV'

static math::romanToNumber ([$string $roman = 'IV'])

$roman optional; römische Zahl als string; default ist 'IV'

wandelt eine römische Zahl in eine Dezimalzahl um und gibt diese als integer zurück; im Fehlerfall null


    math::romanToNumber('XIV'); // 14

Zahlensysteme

static math::decimalToBase ($integer $int, $array $input)

`$int`	Dezimalzahl, die umgewandelt werden soll
`$input`	Definition des Zahlensystems als array, z. B. für Binär `[0, 1]`, für Hexadezimal `['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F']`

wandelt eine Dezimalzahl in ein definiertes Zahlensystem um und gibt das Ergebnis als string zurück; im Fehlerfall null


    math::decimalToBase(55, [0, 1]); // '110111'

static math::baseToDecimal ($string $inputValue, $array $input)

`$inputValue`	Zahl oder Zeichenkette des Zahlensystems, die umgewandelt werden soll
`$input`	Definition des Zahlensystems als array, z. B. für Binär `[0, 1]`

wandelt eine Zahl eines definierten Zahlensystems in eine Dezimalzahl um und gibt diese als integer zurück; im Fehlerfall null


    math::baseToDecimal('110111', [0, 1]); // 55

static math::validateInput ($array $input)

$input Definition des Zahlensystems als array, das auf Eindeutigkeit und Präfixkonflikte geprüft werden soll

prüft ob das Zahlensystem-Array $input gültig definiert ist; Rückgabe von true oder false


    math::validateInput(['A_', 'A']); // true

    math::validateInput(['A', 'A_']); // false (Präfixkonflikt)

Kombinatorik & Mengen

static math::cartesianProduct ($array $set = null[, $integer $n = null])

`$set`	Eingabemenge oder Array von mehreren Mengen `[[1, 2], ['A', 'B']]`
`$n`	optional; Anzahl der Wiederholungen bei Potenzierung ($A^n$)

berechnet das kartesische Produkt; unterstützt zwei Modi: Potenzierung einer einzelnen Menge ($A^n$) mit Angabe von $n oder das Kombinieren mehrerer unterschiedlicher Mengen bei $n = null; gibt alle Kombinationen als mehrdimensionales array zurück, im Fehlerfall null


    // Modus 1: A^n (Potenzierung einer Menge)

    math::cartesianProduct([0, 1], 2);

    // Rückgabe: [[0, 0], [0, 1], [1, 0], [1, 1]]


    // Modus 2: Mehrere Mengen kombinieren (n = null)

    math::cartesianProduct([['S', 'M'], ['rot', 'blau']]);

    // Rückgabe: [['S', 'rot'], ['S', 'blau'], ['M', 'rot'], ['M', 'blau']]

static math::combinations ($array $set = null, $integer $k = null)

`$set`	Grundmenge der Elemente als array
`$k`	Anzahl der zu wählenden Elemente (ohne Zurücklegen)

erzeugt alle echten Kombinationen von $k Elementen aus einer Menge ohne Zurücklegen (z. B. Lotto „6 aus 49“); die Reihenfolge spielt keine Rolle; gibt alle Kombinationen als array zurück, im Fehlerfall null


    math::combinations([1, 2, 3, 4], 2);

    // Rückgabe: [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]

static math::removeDuplicates ($array $items = null)

$items mehrdimensionales Array, dessen Teil-Arrays bereinigt werden sollen

entfernt Duplikate aus einer Liste von Teil-Arrays unabhängig von der Reihenfolge der Elemente (unter Verwendung von O(1)-Hash-Keys); gibt ein bereinigtes array zurück, im Fehlerfall null


    math::removeDuplicates([[1, 2], [2, 1], [1, 3]]);

    // Rückgabe: [[1, 2], [1, 3]]