AI翻訳通知
このドキュメントはAIによって翻訳されました。正確な情報については英語版をご参照ください。
Mathjs
Math.js は、JavaScript および Node.js 用の多機能な数学ライブラリです。
関数リファレンス
式 (Expressions)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| compile | 式を解析してコンパイルします（解析のみを行い、結果を直接返しません）。 | compile('2 + 3') | 式（文字列） | {} |
| evaluate | 式を評価して結果を返します。 | evaluate('2 + 3') | 式（文字列）、スコープ（オプション） | 5 |
| help | 関数やデータ型の使用説明を取得します。 | help('evaluate') | 検索キーワード（文字列） | { "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 | カスタム操作用のパーサーを作成します。 | parser() | なし | {} |
代数計算 (Algebra)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| derivative | 指定された変数について式の導関数を求めます。 | derivative('x^2', 'x') | 式（文字列または Node）、変数（文字列） | { "mathjs": "OperatorNode", "op": "*", "fn": "multiply", "args": [ { "mathjs": "ConstantNode", "value": 2 }, { "mathjs": "SymbolNode", "name": "x" } ], "implicit": false, "isPercentage": false} |
| leafCount | 式ツリー内のリーフノード（記号または定数）の数をカウントします。 | leafCount('x^2 + y') | 式（文字列または Node） | 3 |
| lsolve | 前進代入法を用いて連立一次方程式を解きます。 | lsolve([[1,2],[3,4]], [5,6]) | L（配列または行列）、b（配列または行列） | [ [ 5 ], [ -2.25 ]] |
| lsolveAll | 前進代入法を用いて連立一次方程式のすべての解を求めます。 | lsolveAll([[1,2],[3,4]], [5,6]) | L（配列または行列）、b（配列または行列） | [ [ [ 5 ], [ -2.25 ] ]] |
| lup | 部分ピボット選択による行列のLU分解を実行します。 | lup([[1,2],[3,4]]) | A（配列または行列） | { "L": [ [ 1, 0 ], [ 0.3333333333333333, 1 ] ], "U": [ [ 3, 4 ], [ 0, 0.6666666666666667 ] ], "p": [ 1, 0 ]} |
| lusolve | 連立一次方程式 A*x = b を解きます（A は n×n 行列）。 | lusolve([[1,2],[3,4]], [5,6]) | A（配列または行列）、b（配列または行列） | [ [ -3.9999999999999987 ], [ 4.499999999999999 ]] |
| qr | 行列のQR分解を計算します。 | qr([[1,2],[3,4]]) | A（配列または行列） | { "Q": [ [ 0.316227766016838, 0.9486832980505138 ], [ 0.9486832980505138, -0.316227766016838 ] ], "R": [ [ 3.162277660168379, 4.427188724235731 ], [ 0, 0.6324555320336751 ] ]} |
| rationalize | 有理化可能な式を有理分数に変換します。 | rationalize('1/(x+1)') | 式（文字列または Node） | { "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 | 式の中の記号を指定されたスコープの値で置換します。 | resolve('x + y', {x:2, y:3}) | 式（文字列または Node）、スコープ（オブジェクト） | { "mathjs": "OperatorNode", "op": "+", "fn": "add", "args": [ { "mathjs": "ConstantNode", "value": 2 }, { "mathjs": "ConstantNode", "value": 3 } ], "implicit": false, "isPercentage": false} |
| simplify | 式ツリーを簡略化します（同類項のまとめなど）。 | simplify('2x + 3x') | 式（文字列または Node） | { "mathjs": "OperatorNode", "op": "*", "fn": "multiply", "args": [ { "mathjs": "ConstantNode", "value": 5 }, { "mathjs": "SymbolNode", "name": "x" } ], "implicit": false, "isPercentage": false} |
| simplifyCore | 1パスの簡略化を実行します。パフォーマンスが重視されるケースでよく使用されます。 | simplifyCore('x+x') | 式（文字列または Node） | { "mathjs": "OperatorNode", "op": "+", "fn": "add", "args": [ { "mathjs": "SymbolNode", "name": "x" }, { "mathjs": "SymbolNode", "name": "x" } ], "implicit": false, "isPercentage": false} |
| slu | 完全ピボット選択による疎行列のLU分解を計算します。 | slu(sparse([[4,3], [6, 3]]), 1, 0.001) | A（配列または行列）、順序（文字列）、閾値（数値） | { "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 | 2つの式が記号的に等しいかどうかをチェックします。 | symbolicEqual('x+x', '2x') | 式1（文字列または Node）、式2（文字列または Node） | true |
| usolve | 後退代入法を用いて連立一次方程式を解きます。 | usolve([[1,2],[0,1]], [3,4]) | U（配列または行列）、b（配列または行列） | [ [ -5 ], [ 4 ]] |
| usolveAll | 後退代入法を用いて連立一次方程式のすべての解を求めます。 | usolveAll([[1,2],[0,1]], [3,4]) | U（配列または行列）、b（配列または行列） | [ [ [ -5 ], [ 4 ] ]] |
算術計算 (Arithmetic)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| abs | 数値の絶対値を計算します。 | abs(-3.2) | x（数値、複素数、配列、または行列） | 3.2 |
| add | 2つ以上の値を加算します (x + y)。 | add(2, 3) | x, y, ...（数値、配列、または行列） | 5 |
| cbrt | 数値の立方根を計算します。オプションですべての立方根を返すことも可能です。 | cbrt(8) | x（数値または複素数）、allRoots（真偽値、オプション） | 2 |
| ceil | 正の無限大方向へ切り上げます（複素数の場合は実部と虚部を個別に処理します）。 | ceil(3.2) | x（数値、複素数、配列、または行列） | 4 |
| cube | 値の3乗を計算します (xxx)。 | cube(3) | x（数値、複素数、配列、または行列） | 27 |
| divide | 2つの値を除算します (x / y)。 | divide(6, 2) | x（数値、配列、または行列）、y（数値、配列、または行列） | 3 |
| dotDivide | 2つの行列または配列の要素ごとの除算を行います。 | dotDivide([6,8],[2,4]) | x（配列または行列）、y（配列または行列） | [ 3, 2] |
| dotMultiply | 2つの行列または配列の要素ごとの乗算を行います。 | dotMultiply([2,3],[4,5]) | x（配列または行列）、y（配列または行列） | [ 8, 15] |
| dotPow | 要素ごとに x^y を計算します。 | dotPow([2,3],[2,3]) | x（配列または行列）、y（配列または行列） | [ 4, 27] |
| exp | e^x を計算します。 | exp(1) | x（数値、複素数、配列、または行列） | 2.718281828459045 |
| expm1 | e^x - 1 を計算します。 | expm1(1) | x（数値または複素数） | 1.718281828459045 |
| fix | 0の方向へ丸めます（切り捨て）。 | fix(3.7) | x（数値、複素数、配列、または行列） | 3 |
| floor | 負の無限大方向へ切り捨てます。 | floor(3.7) | x（数値、複素数、配列、または行列） | 3 |
| gcd | 2つ以上の数値の最大公約数を求めます。 | gcd(8, 12) | a, b, ...（数値または BigNumber） | 4 |
| hypot | 引数の二乗和の平方根を計算します（ピタゴラスの定理）。 | hypot(3, 4) | a, b, ...（数値または BigNumber） | 5 |
| invmod | a の b を法とする乗法逆元を計算します。 | invmod(3, 11) | a, b（数値または BigNumber） | 4 |
| lcm | 2つ以上の数値の最小公倍数を求めます。 | lcm(4, 6) | a, b, ...（数値または BigNumber） | 12 |
| log | オプションで底を指定して対数を計算します。 | log(100, 10) | x（数値または複素数）、base（数値または複素数、オプション） | 2 |
| log10 | 数値の常用対数（底10）を計算します。 | log10(100) | x（数値または複素数） | 2 |
| log1p | ln(1 + x) を計算します。 | log1p(1) | x（数値または複素数） | 0.6931471805599453 |
| log2 | 数値の2を底とする対数を計算します。 | log2(8) | x（数値または複素数） | 3 |
| mod | x ÷ y の剰余を計算します (x mod y)。 | mod(8,3) | x, y（数値または BigNumber） | 2 |
| multiply | 2つ以上の値を乗算します (x * y)。 | multiply(2, 3) | x, y, ...（数値、配列、または行列） | 6 |
| norm | 数値、ベクトル、または行列のノルムを計算します（pの指定が可能）。 | norm([3,4]) | x（配列または行列）、p（数値または文字列、オプション） | 5 |
| nthRoot | 数値の n 乗根（主根）を計算します。 | nthRoot(16, 4) | a（数値、BigNumber、または複素数）、root（数値、オプション） | 2 |
| nthRoots | 数値のすべての n 乗根を計算します（複素数解を含む場合があります）。 | nthRoots(1,3) | x（数値または複素数）、root（数値） | [ { "mathjs": "Complex", "re": 1, "im": 0 }, { "mathjs": "Complex", "re": -0.4999999999999998, "im": 0.8660254037844387 }, { "mathjs": "Complex", "re": -0.5000000000000004, "im": -0.8660254037844384 }] |
| pow | x の y 乗を計算します。 | pow(2, 3) | x（数値、複素数、配列、または行列）、y（数値、複素数、配列、または行列） | 8 |
| round | 指定した小数点以下の桁数に四捨五入します。 | round(3.14159, 2) | x（数値、複素数、配列、または行列）、n（数値、オプション） | 3.14 |
| sign | 数値の符号（-1、0、または 1）を返します。 | sign(-3) | x（数値、BigNumber、または複素数） | -1 |
| sqrt | 数値の平方根を計算します。 | sqrt(9) | x（数値、複素数、配列、または行列） | 3 |
| square | 値の2乗を計算します (x*x)。 | square(3) | x（数値、複素数、配列、または行列） | 9 |
| subtract | 一方の値からもう一方の値を減算します (x - y)。 | subtract(8, 3) | x, y（数値、配列、または行列） | 5 |
| unaryMinus | 値に単項マイナス演算（符号反転）を適用します。 | unaryMinus(3) | x（数値、複素数、配列、または行列） | -3 |
| unaryPlus | 単項プラス演算を適用します（通常、値は変化しません）。 | unaryPlus(-3) | x（数値、複素数、配列、または行列） | -3 |
| xgcd | 2つの数値の拡張最大公約数を計算します。 | xgcd(8, 12) | a, b（数値または BigNumber） | { "mathjs": "DenseMatrix", "data": [ 4, -1, 1 ], "size": [ 3 ]} |
ビット演算 (Bitwise)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| bitAnd | ビット単位の論理積 (AND) を行います (x & y)。 | bitAnd(5, 3) | x, y（数値または BigNumber） | 1 |
| bitNot | ビット単位の論理否定 (NOT) を行います (~x)。 | bitNot(5) | x（数値または BigNumber） | -6 |
| bitOr | ビット単位の論理和 (OR) を行います (x | y)。 | bitOr(5, 3) | x, y（数値または BigNumber） | 7 |
| bitXor | ビット単位の排他的論理和 (XOR) を行います (x ^ y)。 | bitXor(5, 3) | x, y（数値または BigNumber） | 6 |
| leftShift | x を y ビット左シフトします (x << y)。 | leftShift(5, 1) | x, y（数値または BigNumber） | 10 |
| rightArithShift | x の算術右シフトを行います (x >> y)。 | rightArithShift(5, 1) | x, y（数値または BigNumber） | 2 |
| rightLogShift | x の論理右シフトを行います (x >>> y)。 | rightLogShift(5, 1) | x, y（数値または BigNumber） | 2 |
組合せ論 (Combinatorics)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| bellNumbers | n 個の区別可能な要素の分割数を計算します。 | bellNumbers(3) | n（数値） | 5 |
| catalan | n 番目のカタラン数を計算します。 | catalan(5) | n（数値） | 42 |
| composition | n を k 個のパーツに分割する構成数を計算します。 | composition(5, 3) | n, k（数値） | 6 |
| stirlingS2 | n 個のラベル付きアイテムを k 個の空でない部分集合に分割する方法の数（第二種スターリング数）を計算します。 | stirlingS2(5, 3) | n, k（数値） | 25 |
複素数 (Complex Numbers)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| arg | 複素数の偏角（フェーズ）を計算します。 | arg(complex('2 + 2i')) | x（複素数または数値） | 0.785398163 |
| conj | 共役複素数を計算します。 | conj(complex('2 + 2i')) | x（複素数または数値） | { "mathjs": "Complex", "re": 2, "im": -2} |
| im | 複素数の虚部を返します。 | im(complex('2 + 3i')) | x（複素数または数値） | 3 |
| re | 複素数の実部を返します。 | re(complex('2 + 3i')) | x（複素数または数値） | 2 |
幾何学 (Geometry)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| distance | N次元空間における2点間のユークリッド距離を計算します。 | distance([0,0],[3,4]) | point1（配列）、point2（配列） | 5 |
| intersect | 2本の直線（2D/3D）または直線と平面（3D）の交点を求めます。 | intersect([0,0],[2,2],[0,2],[2,0]) | 直線1の端点、直線2の端点、... | [ 1, 1] |
論理演算 (Logic)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| and | 論理積 (AND) を行います。 | and(true, false) | x, y（真偽値または数値） | false |
| not | 論理否定 (NOT) を行います。 | not(true) | x（真偽値または数値） | false |
| or | 論理和 (OR) を行います。 | or(true, false) | x, y（真偽値または数値） | true |
| xor | 排他的論理和 (XOR) を行います。 | xor(1, 0) | x, y（真偽値または数値） | true |
行列 (Matrix)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| column | 行列から指定された列を返します。 | column([[1,2],[3,4]], 1) | value（行列または配列）、index（数値） | [ [ 1 ], [ 3 ]] |
| concat | 指定された次元に沿って複数の行列/配列を結合します。 | concat([1,2], [3,4], [5,6]) | a, b, c, ...（配列または行列）、dim（数値、オプション） | [ 1, 2, 3, 4, 5, 6] |
| count | 行列、配列、または文字列の要素数をカウントします。 | count([1,2,3,'hello']) | x（配列、行列、または文字列） | 4 |
| cross | 2つの3次元ベクトルの外積を計算します。 | cross([1,2,3], [4,5,6]) | x, y（長さ3の配列または行列） | [ -3, 6, -3] |
| ctranspose | 行列の共役転置を計算します。 | ctranspose([[1,2],[3,4]]) | x（行列または配列） | [ [ 1, 3 ], [ 2, 4 ]] |
| det | 行列の行列式を計算します。 | det([[1,2],[3,4]]) | x（行列または配列） | -2 |
| diag | 対角行列を作成するか、行列の対角成分を抽出します。 | diag([1,2,3]) | X（配列または行列） | [ [ 1, 0, 0 ], [ 0, 2, 0 ], [ 0, 0, 3 ]] |
| diff | 指定された次元に沿って隣接する要素間の差分を計算します。 | diff([1,4,9,16]) | arr（配列または行列）、dim（数値、オプション） | [ 3, 5, 7] |
| dot | 2つのベクトルの内積を計算します。 | dot([1,2,3],[4,5,6]) | x, y（配列または行列） | 32 |
| eigs | 正方行列の固有値と（オプションで）固有ベクトルを計算します。 | eigs([[1,2],[3,4]]) | x（行列または配列）、codec（数値、オプション） | { "values": [ -0.37228132326901653, 5.372281323269014 ], "eigenvectors": [ { "value": -0.37228132326901653, "vector": [ -4.505883335311908, 3.091669772938812 ] }, { "value": 5.372281323269014, "vector": [ 0.4438641329939267, 0.9703494293791691 ] } ]} |
| expm | 行列指数関数 e^A を計算します。 | expm([[1,0],[0,1]]) | x（行列または配列） | { "mathjs": "DenseMatrix", "data": [ [ 2.7182818284590424, 0 ], [ 0, 2.7182818284590424 ] ], "size": [ 2, 2 ]} |
| fft | N次元高速フーリエ変換を計算します。 | fft([1,2,3,4]) | arr（配列または行列） | [ { "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 | （未サポート）テスト関数を使用して配列または1次元行列をフィルタリングします。 | filter(['23', 'foo', '100', '55', 'bar'], /[0-9]+/) | x（配列または行列）、test（関数） | [ "23", "100", "55"] |
| flatten | 多次元の行列または配列を1次元に平坦化します。 | flatten([[1,2],[3,4]]) | x（配列または行列） | [ 1, 2, 3, 4] |
| forEach | （未サポート）行列/配列の各要素を反復処理し、コールバックを呼び出します。 | forEach([1,2,3], val => console.log(val)) | x（配列または行列）、callback（関数） | undefined |
| getMatrixDataType | 行列または配列内のすべての要素のデータ型（'number'、'Complex' など）を検査します。 | getMatrixDataType([[1,2.2],[3,'hello']]) | x（配列または行列） | mixed |
| identity | n x n（または m x n）の単位行列を作成します。 | identity(3) | n（数値）または [m, n]（配列） | { "mathjs": "DenseMatrix", "data": [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], "size": [ 3, 3 ]} |
| ifft | N次元逆高速フーリエ変換を計算します。 | ifft([1,2,3,4]) | arr（配列または行列） | [ { "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 | 正方行列の逆行列を計算します。 | inv([[1,2],[3,4]]) | x（行列または配列） | [ [ -2, 1 ], [ 1.5, -0.5 ]] |
| kron | 2つの行列またはベクトルのクロネッカー積を計算します。 | kron([[1,1],[0,1]], [[2,0],[0,2]]) | x, y（行列または配列） | [ [ 2, 0, 2, 0 ], [ 0, 2, 0, 2 ], [ 0, 0, 2, 0 ], [ 0, 0, 0, 2 ]] |
| map | 各要素にコールバックを適用して、新しい配列/行列を作成します。 | map([1,2,3], val => val * val) | x（配列または行列）、callback（関数） | [ 1, 4, 9] |
| matrixFromColumns | ベクトルを個別の列として結合し、密行列を作成します。 | matrixFromColumns([1,4],[2,5],[3,6]) | ...arr（配列または行列） | [ [ 1, 2, 3 ], [ 4, 5, 6 ]] |
| matrixFromFunction | （未サポート）各インデックスに対して関数を評価することで行列を構築します。 | matrixFromFunction([5], i => math.random()) | size（配列）、fn（関数） | a random vector |
| matrixFromRows | ベクトルを個別の行として結合し、密行列を作成します。 | matrixFromRows([1,2,3],[4,5,6]) | ...arr（配列または行列） | [ [ 1, 2, 3 ], [ 4, 5, 6 ]] |
| ones | 指定された次元の全要素が1の行列を作成します。 | ones(2, 3) | m, n, p...（数値） | { "mathjs": "DenseMatrix", "data": [ [ 1, 1, 1 ], [ 1, 1, 1 ] ], "size": [ 2, 3 ]} |
| partitionSelect | パーティション選択を用いて k 番目に小さい要素を返します。 | partitionSelect([3,1,4,2], 2) | x（配列または行列）、k（数値） | 3 |
| pinv | 行列のムーア・ペンローズ擬似逆行列を計算します。 | pinv([[1,2],[2,4]]) | x（行列または配列） | [ [ 0.04000000000000001, 0.08000000000000002 ], [ 0.08000000000000002, 0.16000000000000003 ]] |
| range | start から end までの数値配列を作成します（step はオプション）。 | range(1, 5, 2) | start（数値）、end（数値）、step（数値、オプション） | { "mathjs": "DenseMatrix", "data": [ 1, 3 ], "size": [ 2 ]} |
| reshape | 配列/行列を指定された次元に再形成します。 | reshape([1,2,3,4,5,6], [2,3]) | x（配列または行列）、sizes（配列） | [ [ 1, 2, 3 ], [ 4, 5, 6 ]] |
| resize | 行列を新しい次元にリサイズします。不足分はデフォルト値（指定された場合）で埋められます。 | resize([1,2,3], [5], 0) | x（配列または行列）、size（配列）、defaultValue（オプション） | [ 1, 2, 3, 0, 0] |
| rotate | 1x2 ベクトルを反時計回りに回転させるか、1x3 ベクトルを指定された軸の周りに回転させます。 | rotate([1, 0], Math.PI / 2) | w（配列または行列）、theta（数値[, 軸]） | [ 6.123233995736766e-17, 1] |
| rotationMatrix | 指定された角度（ラジアン）の 2x2 回転行列を作成します。 | rotationMatrix(Math.PI / 2) | theta（数値） | { "mathjs": "DenseMatrix", "data": [ [ 6.123233995736766e-17, -1 ], [ 1, 6.123233995736766e-17 ] ], "size": [ 2, 2 ]} |
| row | 行列から指定された行を返します。 | row([[1,2],[3,4]], 1) | value（行列または配列）、index（数値） | [ [ 3, 4 ]] |
| size | 行列、配列、またはスカラーのサイズ（次元）を計算します。 | size([[1,2,3],[4,5,6]]) | x（配列、行列、または数値） | [ 2, 3] |
| sort | 行列または配列を昇順でソートします。 | sort([3,1,2]) | x（配列または行列） | [ 1, 2, 3] |
| sqrtm | 正方行列の主平方根を計算します。 | sqrtm([[4,0],[0,4]]) | A（行列または配列） | [ [ 2.000000000000002, 0 ], [ 0, 2.000000000000002 ]] |
| squeeze | 行列の内部または外部にあるサイズ1の次元を削除します。 | squeeze([[[1],[2],[3]]]) | x（行列または配列） | [ 1, 2, 3] |
| subset | 行列または文字列の部分集合を取得または置換します。 | subset([[1, 2], [3, 4]], index(1, 1),2) | x（行列、配列、または文字列）、index（インデックス）、replacement（オプション） | [ [ 2, 2 ], [ 3, 4 ]] |
| trace | 正方行列のトレース（対角成分の和）を計算します。 | trace([[1,2],[3,4]]) | x（行列または配列） | 5 |
| transpose | 行列を転置します。 | transpose([[1,2],[3,4]]) | x（行列または配列） | [ [ 1, 3 ], [ 2, 4 ]] |
| zeros | 指定された次元の全要素が0の行列を作成します。 | zeros(2, 3) | m, n, p...（数値） | { "mathjs": "DenseMatrix", "data": [ [ 0, 0, 0 ], [ 0, 0, 0 ] ], "size": [ 2, 3 ]} |
確率 (Probability)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| combinations | n 個から k 個を順序を考慮せずに選ぶ組み合わせの数を計算します。 | combinations(5, 2) | n（数値）、k（数値） | 10 |
| combinationsWithRep | 重複を許す組み合わせの数を計算します。 | combinationsWithRep(5, 2) | n（数値）、k（数値） | 15 |
| factorial | 整数 n の階乗 n! を計算します。 | factorial(5) | n（整数） | 120 |
| gamma | ガンマ関数の近似値を計算します。 | gamma(5) | n（数値） | 24 |
| kldivergence | 2つの分布間のKLダイバージェンスを計算します。 | kldivergence([0.1, 0.9], [0.2, 0.8]) | x（配列または行列）、y（配列または行列） | 0.036690014034750584 |
| lgamma | ガンマ関数の対数を計算します。 | lgamma(5) | n（数値） | 3.178053830347945 |
| multinomial | カウントの集合から多項係数を計算します。 | multinomial([1, 2, 3]) | a（配列） | 60 |
| permutations | n 個から k 個を選ぶ順列の数を計算します。 | permutations(5, 2) | n（数値）、k（数値、オプション） | 20 |
| pickRandom | 1次元配列から1つ以上のランダムな値を選択します。 | pickRandom([10, 20, 30]) | 配列 | 20 |
| random | 一様分布のランダムな数値を返します。 | random(1, 10) | 最小値（オプション）、最大値（オプション） | 3.6099423753668143 |
| randomInt | 一様分布のランダムな整数を返します。 | randomInt(1, 10) | 最小値（オプション）、最大値（オプション） | 5 |
有理数・比較 (Rational Numbers)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| compare | 2つの値を比較し、-1、0、または 1 を返します。 | compare(2, 3) | x, y（任意の型） | -1 |
| compareNatural | 任意の値を自然で再現可能な順序で比較します。 | compareNatural('2', '10') | x, y（任意の型） | -1 |
| compareText | 2つの文字列を辞書順で比較します。 | compareText('apple', 'banana') | x（文字列）、y（文字列） | -1 |
| deepEqual | 2つの行列/配列の要素が等しいかどうかを再帰的に比較します。 | deepEqual([[1, 2]], [[1, 2]]) | x（配列/行列）、y（配列/行列） | true |
| equal | 2つの値が等しいかどうかをテストします。 | equal(2, 2) | x, y（任意の型） | true |
| equalText | 2つの文字列が同一かどうかをテストします。 | equalText('hello', 'hello') | x（文字列）、y（文字列） | true |
| larger | x が y より大きいかどうかをチェックします。 | larger(3, 2) | x, y（数値または BigNumber） | true |
| largerEq | x が y 以上かどうかをチェックします。 | largerEq(3, 3) | x, y（数値または BigNumber） | true |
| smaller | x が y より小さいかどうかをチェックします。 | smaller(2, 3) | x, y（数値または BigNumber） | true |
| smallerEq | x が y 以下かどうかをチェックします。 | smallerEq(2, 2) | x, y（数値または BigNumber） | true |
| unequal | 2つの値が等しくないかどうかをチェックします。 | unequal(2, 3) | x, y（任意の型） | true |
集合 (Sets)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| setCartesian | 2つ（またはそれ以上）の集合の直積（デカルト積）を生成します。 | setCartesian([1, 2], [3, 4]) | set1（配列）、set2（配列） | [ [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 2, 4 ]] |
| setDifference | 2つの集合の差集合（set1 にはあるが set2 にはない要素）を返します。 | setDifference([1, 2, 3], [2]) | set1（配列）、set2（配列） | [ 1, 3] |
| setDistinct | （多重）集合内のユニークな要素を返します。 | setDistinct([1, 2, 2, 3]) | set（配列） | [ 1, 2, 3] |
| setIntersect | 2つ（またはそれ以上）の集合の積集合を返します。 | setIntersect([1, 2], [2, 3]) | set1（配列）、set2（配列） | [ 2] |
| setIsSubset | set1 が set2 の部分集合であるかどうかをチェックします。 | setIsSubset([1, 2], [1, 2, 3]) | set1（配列）、set2（配列） | true |
| setMultiplicity | 多重集合内に要素が何回出現するかをカウントします。 | setMultiplicity(2, [1, 2, 2, 3]) | element（任意の型）、set（配列） | 2 |
| setPowerset | （多重）集合のべき集合（すべての部分集合）を返します。 | setPowerset([1, 2]) | set（配列） | [ [], [ 1 ], [ 2 ], [ 1, 2 ]] |
| setSize | （多重）集合内のすべての要素をカウントします。 | setSize([1, 2, 3]) | set（配列） | 3 |
| setSymDifference | 2つ（またはそれ以上）の集合の対称差を返します。 | setSymDifference([1, 2], [2, 3]) | set1（配列）、set2（配列） | [ 1, 3] |
| setUnion | 2つ（またはそれ以上）の集合の和集合を返します。 | setUnion([1, 2], [2, 3]) | set1（配列）、set2（配列） | [ 1, 3, 2] |
特殊関数 (Special)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| erf | 有理チェビシェフ近似を用いて誤差関数を計算します。 | erf(0.5) | 入力 x（数値） | 0.5204998778130465 |
統計 (Statistics)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| cumsum | リストまたは行列の累積和を計算します。 | cumsum([1, 2, 3, 4]) | [ 1, 3, 6, 10] | |
| mad | 中央絶対偏差 (MAD) を計算します。 | mad([1, 2, 3, 4]) | 1 | |
| max | リストまたは行列の最大値を返します。 | max([1, 2, 3]) | 3 | |
| mean | 平均値を計算します。 | mean([2, 4, 6]) | 4 | |
| median | 中央値を計算します。 | median([1, 2, 3, 4, 5]) | 3 | |
| min | リストまたは行列の最小値を返します。 | min([1, 2, 3]) | 1 | |
| mode | 最頻値（最も頻繁に出現する値）を計算します。 | mode([1, 2, 2, 3]) | [ 2] | |
| prod | リストまたは行列内のすべての数値の積を計算します。 | prod([1, 2, 3, 4]) | 24 | |
| quantileSeq | 確率 prob における分位数を計算します。 | quantileSeq([1, 2, 3, 4], 0.25) | 1.75 | |
| std | データの標準偏差を計算します。 | std([1, 2, 3, 4]) | 1.2909944487358056 | |
| sum | リストまたは行列内のすべての数値の和を計算します。 | sum([1, 2, 3]) | 6 | |
| variance | データの分散を計算します。 | variance([1, 2, 3, 4]) | 1.6666666666666667 |
文字列 (Strings)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| bin | 数値を2進数形式でフォーマットします。 | bin(13) | 13 | |
| format | 任意の値を指定された精度で文字列としてフォーマットします。 | format(123.456, 2) | 120 | |
| hex | 数値を16進数形式でフォーマットします。 | hex(255) | 255 | |
| oct | 数値を8進数形式でフォーマットします。 | oct(64) | 64 | |
| 文字列テンプレートに複数の値を挿入します。 | print('x = $x, y = $y', {x: 3, y: 4}, 2) | x = 3, y = 4 |
三角関数 (Trigonometry)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| acos | 逆余弦 (arccosine) を計算します。 | acos(0.5) | 1.0471975511965979 | |
| acosh | 逆双曲線余弦 (inverse hyperbolic cosine) を計算します。 | acosh(2) | 1.3169578969248166 | |
| acot | 逆余接 (arccotangent) を計算します。 | acot(1) | 0.7853981633974483 | |
| acoth | 逆双曲線余接 (inverse hyperbolic cotangent) を計算します。 | acoth(2) | 0.5493061443340548 | |
| acsc | 逆余割 (arccosecant) を計算します。 | acsc(2) | 0.5235987755982989 | |
| acsch | 逆双曲線余割 (inverse hyperbolic cosecant) を計算します。 | acsch(2) | 0.48121182505960347 | |
| asec | 逆正割 (arcsecant) を計算します。 | asec(2) | 1.0471975511965979 | |
| asech | 逆双曲線正割 (inverse hyperbolic secant) を計算します。 | asech(0.5) | 1.3169578969248166 | |
| asin | 逆正弦 (arcsine) を計算します。 | asin(0.5) | 0.5235987755982989 | |
| asinh | 逆双曲線正弦 (inverse hyperbolic sine) を計算します。 | asinh(1.5) | 1.1947632172871094 | |
| atan | 逆正接 (arctangent) を計算します。 | atan(1) | 0.7853981633974483 | |
| atan2 | 2つの引数を持つ逆正接を計算します。 | atan2(1, 2) | 0.4636476090008061 | |
| atanh | 逆双曲線正接 (inverse hyperbolic tangent) を計算します。 | atanh(0.5) | 0.5493061443340548 | |
| cos | x の余弦 (cosine) を計算します。 | cos(0.5) | 0.8775825618903728 | |
| cosh | x の双曲線余弦 (hyperbolic cosine) を計算します。 | cosh(0.5) | 1.1276259652063807 | |
| cot | x の余接 (cotangent) を計算します。 | cot(0.5) | 1.830487721712452 | |
| coth | x の双曲線余接 (hyperbolic cotangent) を計算します。 | coth(0.5) | 2.163953413738653 | |
| csc | x の余割 (cosecant) を計算します。 | csc(0.5) | 2.085829642933488 | |
| csch | x の双曲線余割 (hyperbolic cosecant) を計算します。 | csch(0.5) | 1.9190347513349437 | |
| sec | x の正割 (secant) を計算します。 | sec(0.5) | 1.139493927324549 | |
| sech | x の双曲線正割 (hyperbolic secant) を計算します。 | sech(0.5) | 0.886818883970074 | |
| sin | x の正弦 (sine) を計算します。 | sin(0.5) | 0.479425538604203 | |
| sinh | x の双曲線正弦 (hyperbolic sine) を計算します。 | sinh(0.5) | 0.5210953054937474 | |
| tan | x の正接 (tangent) を計算します。 | tan(0.5) | 0.5463024898437905 | |
| tanh | x の双曲線正接 (hyperbolic tangent) を計算します。 | tanh(0.5) | 0.46211715726000974 |
単位 (Units)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| to | 数値を指定された単位に変換します。 | to(unit('2 inch'), 'cm') | { "mathjs": "Unit", "value": 5.08, "unit": "cm", "fixcodefix": true} |
ユーティリティ (Utilities)
| 関数 | 定義 | 例 | パラメータ | 期待される結果 |
|---|---|---|---|---|
| clone | 入力値をディープコピーします。 | clone([1, 2, 3]) | [ 1, 2, 3] | |
| hasNumericValue | 入力に数値が含まれているかどうかをチェックします。 | hasNumericValue('123') | true | |
| isInteger | 入力が整数かどうかをチェックします。 | isInteger(3.0) | true | |
| isNaN | 入力が NaN かどうかをチェックします。 | isNaN(NaN) | true | |
| isNegative | 入力が負の数かどうかをチェックします。 | isNegative(-5) | true | |
| isNumeric | 入力が数値かどうかをチェックします。 | isNumeric('123') | false | |
| isPositive | 入力が正の数かどうかをチェックします。 | isPositive(2) | true | |
| isPrime | 入力が素数かどうかをチェックします。 | isPrime(7) | true | |
| isZero | 入力が 0 かどうかをチェックします。 | isZero(0) | true | |
| numeric | 入力を数値型（number、BigNumber など）に変換します。 | numeric('123') | 123 | |
| typeOf | 入力値の型名を返します。 | typeOf([1, 2, 3]) | Array |