#Mathjs

Math.js ist eine funktionsreiche Mathematik-Bibliothek für JavaScript und Node.js.

#Funktionsreferenz

#Ausdrücke

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
compile	Analysieren und Kompilieren eines Ausdrucks (verantwortlich für die Analyse, gibt kein direktes Ergebnis zurück).	compile('2 + 3')	Ausdruck (Zeichenfolge)	{}
evaluate	Berechnen eines Ausdrucks und Rückgabe des Ergebnisses.	evaluate('2 + 3')	Ausdruck (Zeichenfolge), Geltungsbereich (optional)	5
help	Abrufen der Dokumentation für eine Funktion oder einen Datentyp.	help('evaluate')	Suchbegriff (Zeichenfolge)	{ "name": "evaluate", "category": "Excodession", "syntax": [ "evaluate(excodession)", "evaluate(excodession, scope)", "evaluate([expr1, expr2, expr3, ...])", "evaluate([expr1, expr2, expr3, ...], scope)" ], "description": "Evaluate an excodession or an array with excodessions.", "examples": [ "evaluate(\"2 + 3\")", "evaluate(\"sqrt(16)\")", "evaluate(\"2 inch to cm\")", "evaluate(\"sin(x * pi)\", { \"x\": 1/2 })", "evaluate([\"width=2\", \"height=4\",\"width*height\"])" ], "seealso": [], "mathjs": "Help"}
parser	Erstellen eines Parsers für benutzerdefinierte Operationen.	parser()	Keine	{}

#Algebra

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
derivative	Ableiten eines Ausdrucks nach einer angegebenen Variablen.	derivative('x^2', 'x')	Ausdruck (Zeichenfolge oder Knoten), Variable (Zeichenfolge)	{ "mathjs": "OperatorNode", "op": "*", "fn": "multiply", "args": [ { "mathjs": "ConstantNode", "value": 2 }, { "mathjs": "SymbolNode", "name": "x" } ], "implicit": false, "isPercentage": false}
leafCount	Zählen der Blattknoten (Symbole oder Konstanten) in einem Ausdrucksbaum.	leafCount('x^2 + y')	Ausdruck (Zeichenfolge oder Knoten)	3
lsolve	Lösen eines linearen Gleichungssystems mittels Vorwärtssubstitution.	lsolve([[1,2],[3,4]], [5,6])	L (Array oder Matrix), b (Array oder Matrix)	[ [ 5 ], [ -2.25 ]]
lsolveAll	Finden aller Lösungen eines linearen Gleichungssystems mittels Vorwärtssubstitution.	lsolveAll([[1,2],[3,4]], [5,6])	L (Array oder Matrix), b (Array oder Matrix)	[ [ [ 5 ], [ -2.25 ] ]]
lup	Durchführung einer LU-Zerlegung mit teilweiser Pivotisierung.	lup([[1,2],[3,4]])	A (Array oder Matrix)	{ "L": [ [ 1, 0 ], [ 0.3333333333333333, 1 ] ], "U": [ [ 3, 4 ], [ 0, 0.6666666666666667 ] ], "p": [ 1, 0 ]}
lusolve	Lösen eines linearen Gleichungssystems A*x = b, wobei A eine n×n-Matrix ist.	lusolve([[1,2],[3,4]], [5,6])	A (Array oder Matrix), b (Array oder Matrix)	[ [ -3.9999999999999987 ], [ 4.499999999999999 ]]
qr	Berechnung der QR-Zerlegung einer Matrix.	qr([[1,2],[3,4]])	A (Array oder Matrix)	{ "Q": [ [ 0.316227766016838, 0.9486832980505138 ], [ 0.9486832980505138, -0.316227766016838 ] ], "R": [ [ 3.162277660168379, 4.427188724235731 ], [ 0, 0.6324555320336751 ] ]}
rationalize	Umwandeln eines rationalisierbaren Ausdrucks in einen rationalen Bruch.	rationalize('1/(x+1)')	Ausdruck (Zeichenfolge oder Knoten)	{ "mathjs": "OperatorNode", "op": "/", "fn": "divide", "args": [ { "mathjs": "ConstantNode", "value": 1 }, { "mathjs": "OperatorNode", "op": "+", "fn": "add", "args": [ { "mathjs": "SymbolNode", "name": "x" }, { "mathjs": "ConstantNode", "value": 1 } ], "implicit": false, "isPercentage": false } ], "implicit": false, "isPercentage": false}
resolve	Ersetzen von Symbolen in einem Ausdruck durch Werte aus dem bereitgestellten Geltungsbereich.	resolve('x + y', {x:2, y:3})	Ausdruck (Zeichenfolge oder Knoten), Geltungsbereich (Objekt)	{ "mathjs": "OperatorNode", "op": "+", "fn": "add", "args": [ { "mathjs": "ConstantNode", "value": 2 }, { "mathjs": "ConstantNode", "value": 3 } ], "implicit": false, "isPercentage": false}
simplify	Vereinfachen eines Ausdrucksbaums (Zusammenfassen ähnlicher Terme usw.).	simplify('2x + 3x')	Ausdruck (Zeichenfolge oder Knoten)	{ "mathjs": "OperatorNode", "op": "*", "fn": "multiply", "args": [ { "mathjs": "ConstantNode", "value": 5 }, { "mathjs": "SymbolNode", "name": "x" } ], "implicit": false, "isPercentage": false}
simplifyCore	Durchführung einer One-Pass-Vereinfachung, oft in leistungskritischen Szenarien verwendet.	simplifyCore('x+x')	Ausdruck (Zeichenfolge oder Knoten)	{ "mathjs": "OperatorNode", "op": "+", "fn": "add", "args": [ { "mathjs": "SymbolNode", "name": "x" }, { "mathjs": "SymbolNode", "name": "x" } ], "implicit": false, "isPercentage": false}
slu	Berechnung einer dünnbesetzten LU-Zerlegung mit vollständiger Pivotisierung.	slu(sparse([[4,3], [6, 3]]), 1, 0.001)	A (Array oder Matrix), Zerlegungsreihenfolge (Zeichenfolge), Schwellenwert (Zahl)	{ "L": { "mathjs": "SparseMatrix", "values": [ 1, 1.5, 1 ], "index": [ 0, 1, 1 ], "ptr": [ 0, 2, 3 ], "size": [ 2, 2 ] }, "U": { "mathjs": "SparseMatrix", "values": [ 4, 3, -1.5 ], "index": [ 0, 0, 1 ], "ptr": [ 0, 1, 3 ], "size": [ 2, 2 ] }, "p": [ 0, 1 ], "q": [ 0, 1 ]}
symbolicEqual	Prüfen, ob zwei Ausdrücke im symbolischen Sinne gleich sind.	symbolicEqual('x+x', '2x')	Ausdruck 1 (Zeichenfolge oder Knoten), Ausdruck 2 (Zeichenfolge oder Knoten)	true
usolve	Lösen eines linearen Gleichungssystems mittels Rückwärtssubstitution.	usolve([[1,2],[0,1]], [3,4])	U (Array oder Matrix), b (Array oder Matrix)	[ [ -5 ], [ 4 ]]
usolveAll	Finden aller Lösungen eines linearen Gleichungssystems mittels Rückwärtssubstitution.	usolveAll([[1,2],[0,1]], [3,4])	U (Array oder Matrix), b (Array oder Matrix)	[ [ [ -5 ], [ 4 ] ]]

#Arithmetik

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
abs	Berechnung des Absolutwerts einer Zahl.	abs(-3.2)	x (Zahl, komplexe Zahl, Array oder Matrix)	3.2
add	Addieren von zwei oder mehr Werten (x + y).	add(2, 3)	x, y, ... (Zahl, Array oder Matrix)	5
cbrt	Berechnung der Kubikwurzel einer Zahl, optional Rückgabe aller Kubikwurzeln.	cbrt(8)	x (Zahl oder komplexe Zahl), allRoots (Boolean, optional)	2
ceil	Aufrunden in Richtung positiv unendlich (bei komplexen Zahlen werden Real- und Imaginärteil separat gerundet).	ceil(3.2)	x (Zahl, komplexe Zahl, Array oder Matrix)	4
cube	Berechnung des Kubikwerts eines Wertes (xxx).	cube(3)	x (Zahl, komplexe Zahl, Array oder Matrix)	27
divide	Dividieren zweier Werte (x / y).	divide(6, 2)	x (Zahl, Array oder Matrix), y (Zahl, Array oder Matrix)	3
dotDivide	Elementweise Division zweier Matrizen oder Arrays.	dotDivide([6,8],[2,4])	x (Array oder Matrix), y (Array oder Matrix)	[ 3, 2]
dotMultiply	Elementweise Multiplikation zweier Matrizen oder Arrays.	dotMultiply([2,3],[4,5])	x (Array oder Matrix), y (Array oder Matrix)	[ 8, 15]
dotPow	Elementweise Potenzierung x^y.	dotPow([2,3],[2,3])	x (Array oder Matrix), y (Array oder Matrix)	[ 4, 27]
exp	Berechnung von e^x.	exp(1)	x (Zahl, komplexe Zahl, Array oder Matrix)	2.718281828459045
expm1	Berechnung von e^x - 1.	expm1(1)	x (Zahl oder komplexe Zahl)	1.718281828459045
fix	Runden in Richtung Null (Abschneiden).	fix(3.7)	x (Zahl, komplexe Zahl, Array oder Matrix)	3
floor	Runden in Richtung negativ unendlich.	floor(3.7)	x (Zahl, komplexe Zahl, Array oder Matrix)	3
gcd	Berechnung des größten gemeinsamen Teilers von zwei oder mehr Zahlen.	gcd(8, 12)	a, b, ... (Zahl oder BigNumber)	4
hypot	Berechnung der Quadratwurzel der Summe der Quadrate der Argumente (Satz des Pythagoras).	hypot(3, 4)	a, b, ... (Zahl oder BigNumber)	5
invmod	Berechnung des modularen multiplikativen Inversen von a modulo b.	invmod(3, 11)	a, b (Zahl oder BigNumber)	4
lcm	Berechnung des kleinsten gemeinsamen Vielfachen von zwei oder mehr Zahlen.	lcm(4, 6)	a, b, ... (Zahl oder BigNumber)	12
log	Berechnung des Logarithmus mit optionaler Basis.	log(100, 10)	x (Zahl oder komplexe Zahl), base (optional, Zahl oder komplexe Zahl)	2
log10	Berechnung des Logarithmus zur Basis 10 einer Zahl.	log10(100)	x (Zahl oder komplexe Zahl)	2
log1p	Berechnung von ln(1 + x).	log1p(1)	x (Zahl oder komplexe Zahl)	0.6931471805599453
log2	Berechnung des Logarithmus zur Basis 2 einer Zahl.	log2(8)	x (Zahl oder komplexe Zahl)	3
mod	Berechnung des Rests von x ÷ y (x mod y).	mod(8,3)	x, y (Zahl oder BigNumber)	2
multiply	Multiplizieren von zwei oder mehr Werten (x * y).	multiply(2, 3)	x, y, ... (Zahl, Array oder Matrix)	6
norm	Berechnung der Norm einer Zahl, eines Vektors oder einer Matrix mit optionalem p.	norm([3,4])	x (Array oder Matrix), p (Zahl oder Zeichenfolge, optional)	5
nthRoot	Berechnung der n-ten Wurzel (Hauptwurzel) einer Zahl.	nthRoot(16, 4)	a (Zahl, BigNumber oder komplexe Zahl), root (optional, Zahl)	2
nthRoots	Berechnung aller n-ten Wurzeln einer Zahl, potenziell inklusive komplexer Lösungen.	nthRoots(1,3)	x (Zahl oder komplexe Zahl), root (Zahl)	[ { "mathjs": "Complex", "re": 1, "im": 0 }, { "mathjs": "Complex", "re": -0.4999999999999998, "im": 0.8660254037844387 }, { "mathjs": "Complex", "re": -0.5000000000000004, "im": -0.8660254037844384 }]
pow	Berechnung von x^y.	pow(2, 3)	x (Zahl, komplexe Zahl, Array oder Matrix), y (Zahl, komplexe Zahl, Array oder Matrix)	8
round	Runden auf eine angegebene Anzahl von Dezimalstellen.	round(3.14159, 2)	x (Zahl, komplexe Zahl, Array oder Matrix), n (optional, Zahl)	3.14
sign	Berechnung des Vorzeichens eines Wertes (-1, 0 oder 1).	sign(-3)	x (Zahl, BigNumber oder komplexe Zahl)	-1
sqrt	Berechnung der Quadratwurzel einer Zahl.	sqrt(9)	x (Zahl, komplexe Zahl, Array oder Matrix)	3
square	Berechnung des Quadrats einer Zahl (x*x).	square(3)	x (Zahl, komplexe Zahl, Array oder Matrix)	9
subtract	Subtrahieren zweier Zahlen (x - y).	subtract(8, 3)	x, y (Zahl, Array oder Matrix)	5
unaryMinus	Durchführung einer unären Negation (Vorzeichenumkehr).	unaryMinus(3)	x (Zahl, komplexe Zahl, Array oder Matrix)	-3
unaryPlus	Durchführung einer unären Plus-Operation (normalerweise keine Änderung).	unaryPlus(-3)	x (Zahl, komplexe Zahl, Array oder Matrix)	-3
xgcd	Berechnung des erweiterten größten gemeinsamen Teilers zweier Zahlen.	xgcd(8, 12)	a, b (Zahl oder BigNumber)	{ "mathjs": "DenseMatrix", "data": [ 4, -1, 1 ], "size": [ 3 ]}

#Bitweise Operationen

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
bitAnd	Bitweises UND für zwei Werte (x & y).	bitAnd(5, 3)	x, y (Zahl oder BigNumber)	1
bitNot	Bitweise Negation eines Wertes (~x).	bitNot(5)	x (Zahl oder BigNumber)	-6
bitOr	Bitweises ODER für zwei Werte (x | y).	bitOr(5, 3)	x, y (Zahl oder BigNumber)	7
bitXor	Bitweises EXKLUSIV-ODER für zwei Werte (x ^ y).	bitXor(5, 3)	x, y (Zahl oder BigNumber)	6
leftShift	Linksschieben der Binärbits von x um y Stellen (x << y).	leftShift(5, 1)	x, y (Zahl oder BigNumber)	10
rightArithShift	Arithmetisches Rechtsschieben der Binärbits von x (x >> y).	rightArithShift(5, 1)	x, y (Zahl oder BigNumber)	2
rightLogShift	Logisches Rechtsschieben der Binärbits von x (x >>> y).	rightLogShift(5, 1)	x, y (Zahl oder BigNumber)	2

#Kombinatorik

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
bellNumbers	Berechnung der Anzahl aller Partitionen von n unterscheidbaren Elementen.	bellNumbers(3)	n (Zahl)	5
catalan	Berechnung der n-ten Catalan-Zahl für verschiedene kombinatorische Strukturen.	catalan(5)	n (Zahl)	42
composition	Berechnung der Anzahl der Möglichkeiten, n in k Teile zu zerlegen.	composition(5, 3)	n, k (Zahl)	6
stirlingS2	Berechnung der Anzahl der Möglichkeiten, n markierte Elemente in k nicht-leere Teilmengen zu partitionieren (Stirling-Zahlen zweiter Art).	stirlingS2(5, 3)	n, k (Zahl)	25

#Komplexe Zahlen

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
arg	Berechnung des Arguments (Phase) einer komplexen Zahl.	arg(complex('2 + 2i'))	x (komplexe Zahl oder Zahl)	0.785398163
conj	Berechnung der konjugiert komplexen Zahl.	conj(complex('2 + 2i'))	x (komplexe Zahl oder Zahl)	{ "mathjs": "Complex", "re": 2, "im": -2}
im	Abrufen des Imaginärteils einer komplexen Zahl.	im(complex('2 + 3i'))	x (komplexe Zahl oder Zahl)	3
re	Abrufen des Realteils einer komplexen Zahl.	re(complex('2 + 3i'))	x (komplexe Zahl oder Zahl)	2

#Geometrie

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
distance	Berechnung des euklidischen Abstands zwischen zwei Punkten im N-dimensionalen Raum.	distance([0,0],[3,4])	point1 (Array), point2 (Array)	5
intersect	Finden des Schnittpunkts zweier Linien (2D/3D) oder einer Linie und einer Ebene (3D).	intersect([0,0],[2,2],[0,2],[2,0])	Start- und Endpunkte der Linie 1, Start- und Endpunkte der Linie 2, ...	[ 1, 1]

#Logik

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
and	Durchführung einer logischen UND-Verknüpfung.	and(true, false)	x, y (Boole'sche Werte oder Zahlen)	false
not	Durchführung einer logischen NICHT-Operation.	not(true)	x (Boole'scher Wert oder Zahl)	false
or	Durchführung einer logischen ODER-Verknüpfung.	or(true, false)	x, y (Boole'sche Werte oder Zahlen)	true
xor	Durchführung einer logischen EXKLUSIV-ODER-Verknüpfung.	xor(1, 0)	x, y (Boole'sche Werte oder Zahlen)	true

#Matrix

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
column	Rückgabe einer angegebenen Spalte aus einer Matrix.	column([[1,2],[3,4]], 1)	value (Matrix oder Array), index (Zahl)	[ [ 1 ], [ 3 ]]
concat	Verketten mehrerer Matrizen/Arrays entlang einer angegebenen Dimension.	concat([1,2], [3,4], [5,6])	a, b, c, ... (Array oder Matrix), dim (Zahl, optional)	[ 1, 2, 3, 4, 5, 6]
count	Zählen der Anzahl der Elemente in einer Matrix, einem Array oder einer Zeichenfolge.	count([1,2,3,'hello'])	x (Array, Matrix oder Zeichenfolge)	4
cross	Berechnung des Kreuzprodukts zweier 3D-Vektoren.	cross([1,2,3], [4,5,6])	x, y (Array oder Matrix der Länge 3)	[ -3, 6, -3]
ctranspose	Berechnung der konjugiert transponierten Matrix.	ctranspose([[1,2],[3,4]])	x (Matrix oder Array)	[ [ 1, 3 ], [ 2, 4 ]]
det	Berechnung der Determinante einer Matrix.	det([[1,2],[3,4]])	x (Matrix oder Array)	-2
diag	Erstellen einer Diagonalmatrix oder Extrahieren der Diagonale einer Matrix.	diag([1,2,3])	X (Array oder Matrix)	[ [ 1, 0, 0 ], [ 0, 2, 0 ], [ 0, 0, 3 ]]
diff	Berechnung der Differenz zwischen benachbarten Elementen entlang einer Dimension.	diff([1,4,9,16])	arr (Array oder Matrix), dim (Zahl, optional)	[ 3, 5, 7]
dot	Berechnung des Skalarprodukts zweier Vektoren.	dot([1,2,3],[4,5,6])	x, y (Array oder Matrix)	32
eigs	Berechnung der Eigenwerte und (optional) Eigenvektoren einer quadratischen Matrix.	eigs([[1,2],[3,4]])	x (Matrix oder Array), codec (numerisch, optional)	{ "values": [ -0.37228132326901653, 5.372281323269014 ], "eigenvectors": [ { "value": -0.37228132326901653, "vector": [ -4.505883335311908, 3.091669772938812 ] }, { "value": 5.372281323269014, "vector": [ 0.4438641329939267, 0.9703494293791691 ] } ]}
expm	Berechnung der Matrix-Exponentialfunktion e^A.	expm([[1,0],[0,1]])	x (Matrix oder Array)	{ "mathjs": "DenseMatrix", "data": [ [ 2.7182818284590424, 0 ], [ 0, 2.7182818284590424 ] ], "size": [ 2, 2 ]}
fft	Berechnung der N-dimensionalen schnellen Fourier-Transformation.	fft([1,2,3,4])	arr (Array oder Matrix)	[ { "mathjs": "Complex", "re": 10, "im": 0 }, { "mathjs": "Complex", "re": -2, "im": 2 }, { "mathjs": "Complex", "re": -2, "im": 0 }, { "mathjs": "Complex", "re": -1.9999999999999998, "im": -2 }]
filter	(Noch nicht unterstützt) Filtern eines Arrays oder einer 1D-Matrix mit einer Testfunktion.	filter(['23', 'foo', '100', '55', 'bar'], /[0-9]+/)	x (Array oder Matrix), test (Funktion)	[ "23", "100", "55"]
flatten	Flachdrücken einer mehrdimensionalen Matrix oder eines Arrays in eine Dimension.	flatten([[1,2],[3,4]])	x (Array oder Matrix)	[ 1, 2, 3, 4]
forEach	(Noch nicht unterstützt) Iterieren über jedes Element einer Matrix/eines Arrays und Ausführen eines Callbacks.	forEach([1,2,3], val => console.log(val))	x (Array oder Matrix), callback (Funktion)	undefined
getMatrixDataType	Überprüfen des Datentyps aller Elemente einer Matrix oder eines Arrays, z. B. 'number' oder 'Complex'.	getMatrixDataType([[1,2.2],[3,'hello']])	x (Array oder Matrix)	mixed
identity	Erstellen einer n x n (oder m x n) Einheitsmatrix.	identity(3)	n (Zahl) oder [m, n] (Array)	{ "mathjs": "DenseMatrix", "data": [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], "size": [ 3, 3 ]}
ifft	Berechnung der N-dimensionalen inversen schnellen Fourier-Transformation.	ifft([1,2,3,4])	arr (Array oder Matrix)	[ { "mathjs": "Complex", "re": 2.5, "im": 0 }, { "mathjs": "Complex", "re": -0.5, "im": -0.5 }, { "mathjs": "Complex", "re": -0.5, "im": 0 }, { "mathjs": "Complex", "re": -0.49999999999999994, "im": 0.5 }]
inv	Berechnung der Inversen einer quadratischen Matrix.	inv([[1,2],[3,4]])	x (Matrix oder Array)	[ [ -2, 1 ], [ 1.5, -0.5 ]]
kron	Berechnung des Kronecker-Produkts zweier Matrizen oder Vektoren.	kron([[1,1],[0,1]], [[2,0],[0,2]])	x, y (Matrix oder Array)	[ [ 2, 0, 2, 0 ], [ 0, 2, 0, 2 ], [ 0, 0, 2, 0 ], [ 0, 0, 0, 2 ]]
map	Erstellen eines neuen Arrays/einer neuen Matrix durch Anwenden eines Callbacks auf jedes Element.	map([1,2,3], val => val * val)	x (Array oder Matrix), callback (Funktion)	[ 1, 4, 9]
matrixFromColumns	Kombinieren mehrerer Vektoren als separate Spalten zu einer dichten Matrix.	matrixFromColumns([1,4],[2,5],[3,6])	...arr (Array oder Matrix)	[ [ 1, 2, 3 ], [ 4, 5, 6 ]]
matrixFromFunction	(Noch nicht unterstützt) Erzeugen einer Matrix durch Auswertung einer Funktion für jeden Index.	matrixFromFunction([5], i => math.random())	size (Array), fn (Funktion)	ein Zufallsvektor
matrixFromRows	Kombinieren mehrerer Vektoren als separate Zeilen zu einer dichten Matrix.	matrixFromRows([1,2,3],[4,5,6])	...arr (Array oder Matrix)	[ [ 1, 2, 3 ], [ 4, 5, 6 ]]
ones	Erstellen einer Matrix mit Einsen für die angegebenen Dimensionen.	ones(2, 3)	m, n, p... (Zahlen)	{ "mathjs": "DenseMatrix", "data": [ [ 1, 1, 1 ], [ 1, 1, 1 ] ], "size": [ 2, 3 ]}
partitionSelect	Rückgabe des k-ten kleinsten Elements aus einem Array oder einer 1D-Matrix basierend auf der Partition-Selection-Methode.	partitionSelect([3,1,4,2], 2)	x (Array oder Matrix), k (Zahl)	3
pinv	Berechnung der Moore-Penrose-Pseudoinversen einer Matrix.	pinv([[1,2],[2,4]])	x (Matrix oder Array)	[ [ 0.04000000000000001, 0.08000000000000002 ], [ 0.08000000000000002, 0.16000000000000003 ]]
range	Erzeugen eines Zahlen-Arrays von Start bis Ende (Schrittweite optional).	range(1, 5, 2)	start (Zahl), end (Zahl), step (Zahl, optional)	{ "mathjs": "DenseMatrix", "data": [ 1, 3 ], "size": [ 2 ]}
reshape	Umformen eines Arrays/einer Matrix in die angegebenen Dimensionen.	reshape([1,2,3,4,5,6], [2,3])	x (Array oder Matrix), sizes (Array)	[ [ 1, 2, 3 ], [ 4, 5, 6 ]]
resize	Ändern der Größe einer Matrix auf neue Dimensionen, fehlende Elemente können mit einem Standardwert gefüllt werden.	resize([1,2,3], [5], 0)	x (Array oder Matrix), size (Array), defaultValue (optional)	[ 1, 2, 3, 0, 0]
rotate	Drehen eines 1x2-Vektors gegen den Uhrzeigersinn um einen Winkel oder Drehen eines 1x3-Vektors um eine Achse.	rotate([1, 0], Math.PI / 2)	w (Array oder Matrix), theta (Zahl[, Achse])	[ 6.123233995736766e-17, 1]
rotationMatrix	Erstellen einer 2x2-Rotationsmatrix für einen gegebenen Winkel in Radiant.	rotationMatrix(Math.PI / 2)	theta (Zahl)	{ "mathjs": "DenseMatrix", "data": [ [ 6.123233995736766e-17, -1 ], [ 1, 6.123233995736766e-17 ] ], "size": [ 2, 2 ]}
row	Rückgabe einer angegebenen Zeile aus einer Matrix.	row([[1,2],[3,4]], 1)	value (Matrix oder Array), index (Zahl)	[ [ 3, 4 ]]
size	Berechnung der Größe (Dimensionen) einer Matrix, eines Arrays oder eines Skalars.	size([[1,2,3],[4,5,6]])	x (Array, Matrix oder Zahl)	[ 2, 3]
sort	Sortieren einer Matrix oder eines Arrays in aufsteigender Reihenfolge.	sort([3,1,2])	x (Array oder Matrix)	[ 1, 2, 3]
sqrtm	Berechnung der Hauptquadratwurzel einer quadratischen Matrix.	sqrtm([[4,0],[0,4]])	A (Matrix oder Array)	[ [ 2.000000000000002, 0 ], [ 0, 2.000000000000002 ]]
squeeze	Entfernen von inneren und äußeren Singleton-Dimensionen aus einer Matrix.	squeeze([[[1],[2],[3]]])	x (Matrix oder Array)	[ 1, 2, 3]
subset	Abrufen oder Ersetzen einer Teilmenge einer Matrix oder einer Zeichenfolge.	subset([[1, 2], [3, 4]], index(1, 1),2)	x (Matrix, Array oder Zeichenfolge), index (Index), replacement (optional)	[ [ 2, 2 ], [ 3, 4 ]]
trace	Berechnung der Spur (Summe der Diagonalelemente) einer quadratischen Matrix.	trace([[1,2],[3,4]])	x (Matrix oder Array)	5
transpose	Transponieren einer Matrix.	transpose([[1,2],[3,4]])	x (Matrix oder Array)	[ [ 1, 3 ], [ 2, 4 ]]
zeros	Erstellen einer Matrix mit Nullen für die angegebenen Dimensionen.	zeros(2, 3)	m, n, p... (Zahlen)	{ "mathjs": "DenseMatrix", "data": [ [ 0, 0, 0 ], [ 0, 0, 0 ] ], "size": [ 2, 3 ]}

#Wahrscheinlichkeit

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
combinations	Berechnung der Anzahl ungeordneter Kombinationen von k Elementen aus n.	combinations(5, 2)	n (Zahl), k (Zahl)	10
combinationsWithRep	Berechnung der Anzahl der Kombinationen mit Wiederholung.	combinationsWithRep(5, 2)	n (Zahl), k (Zahl)	15
factorial	Berechnung der Fakultät einer Ganzzahl n.	factorial(5)	n (Ganzzahl)	120
gamma	Approximation der Gamma-Funktion.	gamma(5)	n (Zahl)	24
kldivergence	Berechnung der KL-Divergenz zwischen zwei Verteilungen.	kldivergence([0.1, 0.9], [0.2, 0.8])	x (Array oder Matrix), y (Array oder Matrix)	0.036690014034750584
lgamma	Berechnung des Logarithmus der Gamma-Funktion (erweiterte Approximation).	lgamma(5)	n (Zahl)	3.178053830347945
multinomial	Berechnung des Multinomialkoeffizienten basierend auf einer Menge von Zählungen.	multinomial([1, 2, 3])	a (Array)	60
permutations	Berechnung der Anzahl geordneter Permutationen von k Elementen aus n.	permutations(5, 2)	n (Zahl), k (Zahl, optional)	20
pickRandom	Zufällige Auswahl eines oder mehrerer Werte aus einem 1D-Array.	pickRandom([10, 20, 30])	Array	20
random	Abrufen einer gleichmäßig verteilten Zufallszahl.	random(1, 10)	Minimum (optional), Maximum (optional)	3.6099423753668143
randomInt	Abrufen einer gleichmäßig verteilten Zufallsganszahl.	randomInt(1, 10)	Minimum (optional), Maximum (optional)	5

#Vergleiche

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
compare	Vergleichen zweier Werte, gibt -1, 0 oder 1 zurück.	compare(2, 3)	x, y (beliebiger Typ)	-1
compareNatural	Vergleichen beliebiger Werte in natürlicher, wiederholbarer Reihenfolge.	compareNatural('2', '10')	x, y (beliebiger Typ)	-1
compareText	Lexikographischer Vergleich zweier Zeichenfolgen.	compareText('apple', 'banana')	x (Zeichenfolge), y (Zeichenfolge)	-1
deepEqual	Elementweiser Vergleich zweier Matrizen/Arrays auf Gleichheit.	deepEqual([[1, 2]], [[1, 2]])	x (Array/Matrix), y (Array/Matrix)	true
equal	Prüfen, ob zwei Werte gleich sind.	equal(2, 2)	x, y (beliebiger Typ)	true
equalText	Prüfen, ob zwei Zeichenfolgen identisch sind.	equalText('hello', 'hello')	x (Zeichenfolge), y (Zeichenfolge)	true
larger	Prüfen, ob x größer als y ist.	larger(3, 2)	x, y (Zahl oder BigNumber)	true
largerEq	Prüfen, ob x größer oder gleich y ist.	largerEq(3, 3)	x, y (Zahl oder BigNumber)	true
smaller	Prüfen, ob x kleiner als y ist.	smaller(2, 3)	x, y (Zahl oder BigNumber)	true
smallerEq	Prüfen, ob x kleiner oder gleich y ist.	smallerEq(2, 2)	x, y (Zahl oder BigNumber)	true
unequal	Prüfen, ob zwei Werte ungleich sind.	unequal(2, 3)	x, y (beliebiger Typ)	true

#Mengen

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
setCartesian	Erzeugen des kartesischen Produkts zweier (oder mehrerer) Mengen.	setCartesian([1, 2], [3, 4])	Erste Menge (Array), zweite Menge (Array)	[ [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 2, 4 ]]
setDifference	Erzeugen der Differenzmenge zweier Mengen (Elemente in Menge 1, aber nicht in Menge 2).	setDifference([1, 2, 3], [2])	Erste Menge (Array), zweite Menge (Array)	[ 1, 3]
setDistinct	Abrufen der eindeutigen Elemente einer (Multi-)Menge.	setDistinct([1, 2, 2, 3])	Menge (Array)	[ 1, 2, 3]
setIntersect	Erzeugen der Schnittmenge zweier (oder mehrerer) Mengen.	setIntersect([1, 2], [2, 3])	Erste Menge (Array), zweite Menge (Array)	[ 2]
setIsSubset	Prüfen, ob Menge 1 eine Teilmenge von Menge 2 ist.	setIsSubset([1, 2], [1, 2, 3])	Erste Menge (Array), zweite Menge (Array)	true
setMultiplicity	Zählen, wie oft ein Element in einer Multimenge vorkommt.	setMultiplicity(2, [1, 2, 2, 3])	Element (beliebiger Typ), Menge (Array)	2
setPowerset	Erzeugen der Potenzmenge (alle Teilmengen) einer (Multi-)Menge.	setPowerset([1, 2])	Menge (Array)	[ [], [ 1 ], [ 2 ], [ 1, 2 ]]
setSize	Zählen aller Elemente in einer (Multi-)Menge.	setSize([1, 2, 3])	Menge (Array)	3
setSymDifference	Erzeugen der symmetrischen Differenz zweier (oder mehrerer) Mengen (Elemente, die nur in einer der Mengen vorkommen).	setSymDifference([1, 2], [2, 3])	Erste Menge (Array), zweite Menge (Array)	[ 1, 3]
setUnion	Erzeugen der Vereinigungsmenge zweier (oder mehrerer) Mengen.	setUnion([1, 2], [2, 3])	Erste Menge (Array), zweite Menge (Array)	[ 1, 3, 2]

#Spezial

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
erf	Berechnung der Fehlerfunktion mittels einer rationalen Tschebyscheff-Approximation.	erf(0.5)	Eingabewert x (Zahl)	0.5204998778130465

#Statistik

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
cumsum	Berechnung der kumulativen Summe einer Liste oder Matrix.	cumsum([1, 2, 3, 4])		[ 1, 3, 6, 10]
mad	Berechnung der mittleren absoluten Abweichung (Median Absolute Deviation).	mad([1, 2, 3, 4])		1
max	Rückgabe des Maximalwerts einer Liste oder Matrix.	max([1, 2, 3])		3
mean	Berechnung des Mittelwerts.	mean([2, 4, 6])		4
median	Berechnung des Medians.	median([1, 2, 3, 4, 5])		3
min	Rückgabe des Minimalwerts einer Liste oder Matrix.	min([1, 2, 3])		1
mode	Berechnung des Modalwerts (häufigster Wert).	mode([1, 2, 2, 3])		[ 2]
prod	Berechnung des Produkts aller Zahlen in einer Liste oder Matrix.	prod([1, 2, 3, 4])		24
quantileSeq	Berechnung des Quantils an der Position prob in einer Liste oder Matrix.	quantileSeq([1, 2, 3, 4], 0.25)		1.75
std	Berechnung der Standardabweichung der Daten.	std([1, 2, 3, 4])		1.2909944487358056
sum	Berechnung der Summe aller Zahlen in einer Liste oder Matrix.	sum([1, 2, 3])		6
variance	Berechnung der Varianz der Daten.	variance([1, 2, 3, 4])		1.6666666666666667

#Zeichenfolgen

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
bin	Formatieren einer Zahl als Binärwert.	bin(13)		13
format	Umwandeln eines beliebigen Typs in eine Zeichenfolge mit angegebener Präzision.	format(123.456, 2)		120
hex	Formatieren einer Zahl als Hexadezimalwert.	hex(255)		255
oct	Formatieren einer Zahl als Oktalwert.	oct(64)		64
print	Einfügen mehrerer Werte in eine Zeichenfolgen-Vorlage.	print('x = $x, y = $y', {x: 3, y: 4}, 2)		x = 3, y = 4

#Trigonometrie

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
acos	Berechnung des Arkuskosinus.	acos(0.5)		1.0471975511965979
acosh	Berechnung des Areakosinus Hyperbolicus.	acosh(2)		1.3169578969248166
acot	Berechnung des Arkuskotangens.	acot(1)		0.7853981633974483
acoth	Berechnung des Areakotangens Hyperbolicus.	acoth(2)		0.5493061443340548
acsc	Berechnung des Arkuskosekans.	acsc(2)		0.5235987755982989
acsch	Berechnung des Areakosekans Hyperbolicus.	acsch(2)		0.48121182505960347
asec	Berechnung des Arkussekans.	asec(2)		1.0471975511965979
asech	Berechnung des Areasekans Hyperbolicus.	asech(0.5)		1.3169578969248166
asin	Berechnung des Arkussinus.	asin(0.5)		0.5235987755982989
asinh	Berechnung des Areasinus Hyperbolicus.	asinh(1.5)		1.1947632172871094
atan	Berechnung des Arkustangens.	atan(1)		0.7853981633974483
atan2	Berechnung des Arkustangens mit zwei Argumenten.	atan2(1, 2)		0.4636476090008061
atanh	Berechnung des Areatangens Hyperbolicus.	atanh(0.5)		0.5493061443340548
cos	Berechnung des Kosinus von x.	cos(0.5)		0.8775825618903728
cosh	Berechnung des Kosinus Hyperbolicus von x.	cosh(0.5)		1.1276259652063807
cot	Berechnung des Kotangens von x.	cot(0.5)		1.830487721712452
coth	Berechnung des Kotangens Hyperbolicus von x.	coth(0.5)		2.163953413738653
csc	Berechnung des Kosekans von x.	csc(0.5)		2.085829642933488
csch	Berechnung des Kosekans Hyperbolicus von x.	csch(0.5)		1.9190347513349437
sec	Berechnung des Sekans von x.	sec(0.5)		1.139493927324549
sech	Berechnung des Sekans Hyperbolicus von x.	sech(0.5)		0.886818883970074
sin	Berechnung des Sinus von x.	sin(0.5)		0.479425538604203
sinh	Berechnung des Sinus Hyperbolicus von x.	sinh(0.5)		0.5210953054937474
tan	Berechnung des Tangens von x.	tan(0.5)		0.5463024898437905
tanh	Berechnung des Tangens Hyperbolicus von x.	tanh(0.5)		0.46211715726000974

#Einheiten

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
to	Umrechnen eines numerischen Wertes in eine angegebene Einheit.	to(unit('2 inch'), 'cm')		{ "mathjs": "Unit", "value": 5.08, "unit": "cm", "fixcodefix": true}

#Allgemein

Funktion	Definition	Beispielaufruf	Parameter	Erwartetes Ergebnis
clone	Erstellen einer tiefen Kopie des Eingabewerts.	clone([1, 2, 3])		[ 1, 2, 3]
hasNumericValue	Prüfen, ob die Eingabe einen numerischen Wert enthält.	hasNumericValue('123')		true
isInteger	Prüfen, ob die Eingabe eine Ganzzahl ist.	isInteger(3.0)		true
isNaN	Prüfen, ob die Eingabe NaN (Not a Number) ist.	isNaN(NaN)		true
isNegative	Prüfen, ob die Eingabe eine negative Zahl ist.	isNegative(-5)		true
isNumeric	Prüfen, ob die Eingabe ein numerischer Typ ist.	isNumeric('123')		false
isPositive	Prüfen, ob die Eingabe eine positive Zahl ist.	isPositive(2)		true
isPrime	Prüfen, ob die Eingabe eine Primzahl ist.	isPrime(7)		true
isZero	Prüfen, ob die Eingabe 0 ist.	isZero(0)		true
numeric	Umwandeln des Eingabewerts in einen spezifischen numerischen Typ (z. B. number, BigNumber usw.).	numeric('123')		123
typeOf	Rückgabe des Typnamens des Eingabewerts.	typeOf([1, 2, 3])		Array