[[...]] - Part リストの要素取り出し
- {a, b, c}[[1]] -> Part[{a, b, c}, 1] -> a == First[{a, b, c}] - リストの第1要素
- {a, b, c, d}[[-1]] == Last[{a, b, c, d}] -> d - 末尾から数えた第1要素
- {{a1, a2}, {b1, b2}, {c1, c2}}[[3]][[2]] == {{a1, a2}, {b1, b2}, {c1, c2}}[[3, 2]] == Part[list, 3, 2] -> c2
;; - Span スパン
- {a, b, c, d}[[2 ;; 3]] -> {b,c}

関数型プログラミング

& - Function 純関数
#, #n, #name - Slot 引数
##, ##n - SlotSequence 引数リスト
- (# + 2)& -> Function[a, a+2]
- (#1 * #2)& -> Function[{a, b}, a * b]
- f[##]& -> Function[args, f @@ args] -> f

関数のリストへの適用

/@ - Map 写像
- f /@ {a, b, c} -> {f[a], f[b], f[c]}
@@, @@@ - Apply 適用
- f @@ {a, b, c, d} -> f[a, b, c, d]
- f @@@ {{{1, 2}, 3}, 4, 5} -> {f[{1, 2}, 3], 4, 5}

Wolfram言語のシンタックス

短縮形

@ - Prefix 前置記法
- f @ x -> f[x]
// - Postfix 後置記法
- {a, b, c} // f -> f[{a, b, c}]
- {a, b, c} // f @@ ## & -> f[a, b, c]

プログラムシンタックス

; - CompoundExpression 重文 - 逐次実行。Scheme のbegin的な。
- f[1]; f[2]; f[3]
(*, *) - 範囲コメント、ネスト可能。行コメントは無いorz
- If[a > b,(*then*) p,(*else*) q]
- コンテクストメニューから、「コメント化／非コメント化」が可能
` - コンテキストマーク
- オブジェクトは「context`short」のような正式名称をもつ
- Package` - パッケージ名の末尾にもバッククォート ` が付く
<< - Get 読み込み
- <<file - file 読み込み
- <<package` - パッケージpackageをロードする

セッションシンタックス

%n, %, %% - Out 出力 - 先の出力結果を利用できる。
- %23 -> Out[23]
- % - 1番最後の出力
- %%,%%%,... - 最後から2番目、3番目、...の出力

文字列操作

<> - StringJoin 文字列結合
- "My" <> "Name" <> "Is" -> "MyNameIs"

行列の操作

. - Dot ドット積
- 非可換積の表現にも用いられる。FeynCalc などで
⨯ - Cross 外積

数値の精度

`, `` - 数の末尾にバッククォート`を付けることで、数字の精度、確度を指定する
- 123.456` - 機械精度
- 123.456`200 - 任意精度（この場合は200桁精度）の数
- 123.456``200 - 任意精度（この場合は200桁確度）の数
^^ - 底^^数 の形式で、数の底を指定した表記が出来る
- 2^^101 -> 5
- 16^^FFFF -> 65535

連想

<|, |> - Association 連装
- <|key₁->val₁, key₂->val₂, …|>
assoc[key] - 連想 assoc からキー key の値を取り出す
- <|a -> b, c -> d|>[a] -> b
[[…]] - Part
- <|a -> b, c -> d|>[[Key[a]]] -> b - 連想に [[…]](Part) でアクセスするときは、キーのKeyラップが必要。
- <|"a" -> b, "c" -> d|>[["a"]] -> b - キーが文字列の時は、Key は省略可

式

式の構造

FullForm - 式を（構文による省略記法なしに）完全な形式で表示する
- FullForm[a + b*c] -> Plus[a,Times[b,c]]
TreeForm - 式をツリー形式で表示する
- TreeForm[a + (b*c)^d/e] ->
Head - 式の頭部を返す。Scheme の car, Haskell の head 的な？
- Head[f[a, b]] -> f
- アトミックな式に対しては型名を返す。
  - Map[Head, {1, 0.1, 1 + I, "text", a}] -> {Integer, Real, Complex, String, Symbol}
Length - 式の要素数を返す
- {f[a], f[a, b, c], {a, b, c, d}} // Map[Length, #] & -> {1,3,4}
Level - 式の、与えられたレベルにある全要素をリストにして返す。
Depth - 式の最大深度を返す
- 式の最大深度=ツリー形式で式を表したときの階数=式の任意の要素を指定するのに必要な次数+1
- Depth[{a, {b}}] -> 3
- {a, {b, c}} // TreeForm ->
チュートリアル：式の木構造

式の判定

等号と不等号

Equal, ==
Unequal, !=, ≠
SameQ, ===
UnsameQ, =!=
Less, <
Greater, >
LessEqual, <=, ≤
GreaterEqual, >=, ≥
Between
- Between [x, {min, max}] - min ≤ x ≤ max ? と等価
- Between [x, {min₁, max₁}, {min₂, max₂}, …] - ∃_i (min_i ≤ x ≤ max_i) ? と等価

論理結合

数の特性

NumberQ - 明白な「数」（例えば Integer, Real, Complex, Rational 型）についてのみ真 True を返す
MachineNumberQ
NumericQ
IntegerQ
EvenQ - 偶数
OddQ - 奇数
PrimeQ - 素数
CoprimeQ - 与えられた数が互いに素である場合に真 True を返す
AlgebraicIntegerQ - （主係数が 1 である）代数的数であるかを返す
- 「主係数が 1」と限定しているので、$x^2-2=0$の解である $\sqrt{2}$ は代数的数であると判定するが、$2x^2-1=0$ の解である $1/\sqrt{2}$ は代数的数であるとは見做されない。
  - AlgebraicNumberDenominator を使用せよ
Positive - 式が正のときに限り真 True を返す
Negative - 負
NonPositive - 非正
NonNegative - 非負
PossibleZeroQ - 記号的処理によりゼロであると判定されたときに限り真 True を返す
- 一般的に式がゼロであるかを問う「0-認識問題」は難しいので、これは限定されたテストを行っているだけである。

式の原子要素

AtomQ - 式が原子要素か否か

シンボル：シンボルの扱い

Symbol - 与えた文字列の名前のシンボルを返す
SymbolName - 与えたシンボルの名前を返す
- Clear[x]; SymbolName[x] -> "x"
Context - 現行のコンテキスト名を返す
- Context[] -> "Global"`
Names

手続き型プログラミング

ループ構文

Do - 与えられた範囲で変数を動かしながら式を繰り返す
- Module[{tmp = 0}, Do[tmp += i, {i, 1, 10}]; tmp] -> 55
While - While [test, body] - Whileループ
- Module[{tmp = 1}, While[tmp < 100, tmp *= 2]; tmp] -> 128
For - For [start, test, incr, body] - Forループ
- For[i = 0, i < 4, i++, Print[i]]

フロー制御

Return - 最も内側の制御構造から脱出し、与えられた式 (or Null) を返す
- f[] := Module[{}, Return[1]; Print[2]]; f[] -> 1
- Module[{tmp}, tmp = Do[Return[i], {i, 1, 2}]; -tmp] -> -1
Break
Continue
Goto
Label
Throw
Catch
Check - 投げられるメッセージをキャッチする
Abort - Abort [] - 評価を中断する
Pause - 与えられた秒数だけ停止する

スコープ構文

With - 局所定数を定義する。
- With [{x=x₀, y=y₀, …}, expr]
Module - 局所変数を定義する（レキシカルスコープ）
- Module [{x, y, …}, expr]
- Module [{x=x₀, …}, expr]
Block - 局所変数を定義する（ダイナミックスコープ）
- Block [{x, y, …}, expr]
- Block [{x=x₀, …}, expr]
参考ページ：Mathematica の With と Module と Block - ヒューリンクス（HULINKS）ブログ

リスト操作

リストの構築

Range - 数字の連続リストを返す
- Range[4.5] -> {1,2,3,4}
- Range[x, x + 4] -> {x,x+1,x+2,x+3,x+4} - デフォルト刻み幅は 1
- Range[1, 3, 0.5] -> {1.,1.5,2.,2.5,3.}
- Range[x, x - 4, -1] -> {x,x-1,x-2,x-3,x-4}
- Sin[\[Pi]*Range[0, 1/2, 1/6]] -> {0, 1/2, Sqrt[3]/2, 1}
  - これはとても高速なリストの生成法らしい。See here.
Table - 変数を動かしながら得た要素をリストを生成
Array - 与えられた関数を要素に適用したリストを生成
Tuples - 直積集合を生成
Subsets - 可能なすべての部分集合（巾集合）を生成
Reap - 収穫 - 引数内で撒かれた（Sowされた）要素を順に拾ってリストで返す
Sow - 撒く - 収穫 (Reap) されるよう、要素を撒く（Sowする）
- Reap[Do[If[PrimeQ[i], Sow[i]], {i, 1, 10}]] -> {Null,{2,3,5,7}}
  - 個々で返値のリストの第1要素は、Do の返値の Null
- Reap[Sow[1, "o"]; Sow[2, "t"]; Sow[3, "t"]; Sow[4, "f"]; Sow[5, "f"], {"a", "f", "t"}][[2]] -> {{}, {4,5}, {2,3}}
- Reap[Do[Sow[i, Mod[i, 3]], {i, 1, 10}], {1, 2}][[2]] -> {{1,4,7,10}, {2,5,8}}
  - Sowで要素にタグ付けして、Reap でタグ分けしたリストを得られる。便利。
  - タグは数字でも文字でもシンボルでもなんでも良い。

リストの要素

First - 第1要素
- First[{a, b, c}] -> a
Last - 最終要素
- Last[{a, b, c}] -> c
Rest - Scheme の cdr, Haskell の tail 的な？
- Rest[{a, b, c}] -> {b, c}
Most - 最終要素を取り除いたリスト
- Most[{a, b, c, d}] -> {a,b,c}
Take - 与えられた範囲にある部分リスト取り出し
- Take[{a, b, c, d, e}, 3] -> {a, b, c} - 先頭から 3 個
- Take[{a, b, c, d, e}, -2] -> {d, e} - 終端から 2 個
- Take[{a, b, c, d, e}, {2, 4}] -> {b, c, d} - 先頭から 2 番目から 4 番目まで
- Take[{a, b, c, d, e}, {2, 5, 2}] -> {b, d}
Drop - 与えられた範囲にある要素を除外したリストを返す
TakeDrop - TakeしたリストとDropしたリストのペアを返す
TakeWhile - 頭からリストを走査し、与えた述語が真を返し続ける間の部分リストを返す

選択

Select - 与えられた述語が真 True を返す要素を集めた部分リストを返す
- Select[{1, 2, 4, 7, 6, 2}, EvenQ] -> {2, 4, 6, 2}
SelectFirst - 与えられた述語が真を返す最初の要素を返す
- 見つからない場合、Missing["NotFound"] を返す
Cases - 与えられたパターンとマッチする要素を集めた部分リストを返す
FirstCase - 与えられたパターンとマッチする最初の要素を返す
Pick - 与えられた「選択」リストを照会し、もう一方のリストの対応要素を取り出す
DeleteCases
BinLists
Count - 与えられたパターンとマッチする要素の数を返す
DeleteDuplicates - 重複要素を取り除いた新しいリストを返す
Nothing - リストから自動的に取り除かれる要素を返す
- {a, b, Nothing, c, d, Nothing} -> {a, b, c, d}
- {a, b, c, d} /. c -> Nothing -> {a, b, d}

リストの並べ替えと再構築

Flatten - リストをフラット化
- Flatten[{a, {b, c}, {d, e, f}}] -> {a, b, c, d, e, f}
Partition - リストを要素数等で分割した部分リストのリストを返す
- Partition[{a, b, c, d, e, f, g}, 2] -> {{a, b}, {c, d}, {e, f}}
  - 余ったgは取り除かれていることに注意
Join - リストを連結
- Join[{a, b}, {1, 2, 3}, {x, y}] -> {a, b, 1, 2, 3, x, y}
Catenate - リストに含まれるリストを連結
- Catenate[{{1, 2}, {3}, {4, {5}}}] -> {1, 2, 3, 4, {5}}
Sort - リストをソート
ReverseSort - リストを逆順にソート
Transpose - リストを転置
- Transpose[{{a, b, c}, {1, 2, 3}}] -> {{a, 1}, {b, 2}, {c, 3}}
- {list, Range[Length[list]]}//Transpose - こうすることで、リストlistの要素と位置のペアのリストを簡単に作ることが出来る。
- 結構重要なので覚えておこう。

関数のリストへの適用

Map (/@) - 関数を適用したリストを返す
- Map[f, {a, b, c}] == f /@ {a, b, c} -> {f(a),f(b),f(c)}
Scan - リストを走査
- Scan [f, expr]
- Module[{tmp = 1}, Scan[(tmp += #) &, {1, 2, 3}]; tmp] -> 7
- Return を使わない限り、Null を返す。
MapThread - 複数のリスト（のリスト）を取り、その要素を順にとって与えられた関数の写像を与える
- MapThread[f, {{a, b, c}, {x, y, z}, {1, 2, 3}}] -> {f[a,x,1], f[b,y,2], f[c,z,3]}
BlockMap - リストの連続する要素を与えられた数だけまとめたリストにして、与えられた関数に渡した写像を返す
- BlockMap[f, Range[6], 2] -> {f[{1,2}], f[{3,4}], f[{5,6}]}
- BlockMap[f, Range[4], 2, 1] -> {f[{1,2}], f[{2,3}], f[{3,4}]}
ArrayFilter - 与えられた範囲にある要素を全てまとめたリストにして、与えられた関数に渡した写像を返す
- ArrayFilter[f, Range[3], 1] -> {f[{1,1,2}], f[{1,2,3}], f[{2,3,3}]}
FoldList

リストの述語

AllTrue - 与えられたリストの要素が全て、与えられた述語に対し真 True を返すときに限り真 True を返す
- AllTrue[{1, 2, 3}, PrimeQ] -> False
- AllTrue[{2, 3, 5}, PrimeQ] -> True
AnyTrue - 与えられたリストの要素のいずれかが、与えられた述語に対し真 True を返すときに限り真 True を返す
NoneTrue - 与えられたリストの要素が全て、与えられた述語に対し偽 False を返すときに限り真 True を返す

データの配列の操作

構造配列分析：リストへの数学的およびカウント操作

Length - リストの要素数を返す
- Length[{a, b, c, d}] -> 4
Total - リストの要素の総和を返す
- Total[{a, b, c, d}] -> a + b + c + d
Accumulate - リストの要素を順に累積していったリストを返す
- Accumulate[{a, b, c}] -> {a, a+b, a+b+c}
Differences - リストの要素の逐次差分リストを返す。返値リストの長さは引数リストより1減る。
- Differences[{a, b, c}] -> {b-a, c-b}
Ratios - リストの要素の逐次比率リストを返す。返値リストの長さは引数リストより1減る。
- Ratios[{a, b, c}] -> {b/a, c/b}
Fold
- Fold[f, x, {a, b, c}] -> f[f[f[x, a], b], c]
- Fold[f, {a, b, c}] -> f[f[a, b], c]
Min - リストの最小値
Max - リストの最大値

配列の部分 > リストの要素

ベクトル操作

Dot, . - ベクトル、行列、テンソルのドット積を与える
- {a, b}.{x, y} -> a x + b y
Cross, ⨯ - 外積（クロス積）を与える
- {a, b, c}⨯{x, y, z} - {b z - c y,c x - a z,a y - b x}
Norm - ノルム

数値データ

Mean - リストの平均値
- {1, 2, 3, 4} // Mean -> 5/2

曲線のフィットと近似の関数

FindFit - データとパラメータを交えた関数形を与え、最もフィットするパラメータ集合を返す
- FindFit[data, expr, pars,vars]
- FindFit[data, {expr, cons}, pars, vars] - cons はパラメータの制約条件
Fit - データに対し与えられた項の線型重ね合わせに対するフィッティング行い、係数を返す
LeastSquares - 最小二乗問題を解く
Interpolation - 与えられたデータから補間関数を作成する
- InterpolationOrder - 補間次数を指定する。
- PeriodicInterpolation - 周期関数であることを指定する。
ListInterpolation
FunctionInterpolation
InterpolatingFunction
InterpolatingPolynomial

スプライン

スプラインオブジェクト

BezierFunction
etc...

ピーク解析

FindPeaks - ピークを検出し、その位置と値のペアのリスト {{x₁, y₁}, {x₁, y₂}, …} を返す
- FindPeaks [data] - 与える data の形式は、値のリスト {y₁, y₂, …} 等

Module[
 {values = {2, 1, 3, 5, 6, 6, 4, 3, 2, 4, 7, 3, 2, 4, 2, 2, 1},
  peaks},
 peaks = FindPeaks[values];
 ListLinePlot[values, Epilog -> {Red, PointSize[0.04], Point[peaks]}] // Print;
 ]

EstimatedBackground - 与えられたデータのバックグラウンド値を推定する
- EstimatedBackground [data]

記号式を求める

FindFormula

微積分

Limit - 極限を求める
- Limit[Sin[x]/x, x -> 0] -> 1
- Direction - 極限を上から -1 取るか、下から取るか 1 を指示するオプション。デフォルトでは上から。
  - {Limit[1/x, x -> 0, Direction -> 1], Limit[1/x, x -> 0, Direction -> -1]} -> {+∞, -∞}

離散微積分

Sum, ∑ - 変数を動かし、その結果の総和を返す
- Sum[i^2, {i, 1, 10}] -> 385
Product -

初等関数

組合せ関数

Binomial - 二項係数 ${n \choose r}$, 繰り返しを許さない組合せ ${}_n C_m$
Pochhammer - 繰り返しを許さない順列 ${}_n P_m$. 複素関数でもある。

数値関数

数値的評価と精度

N - （0 以外の）与えられた式を型 Real または型 Complex へと変換する
- N [expr]
- N [expr, n] - n 桁精度で変換
- N[0] -> 0.

数の表現

内部表現

フーリエ (Fourier) 解析

離散フーリエ変換

Fourier - 離散フーリエ変換
- $v_s = \frac{1}{\sqrt{n}} \sum_{r=1}^n u_r e^{\frac{2\pi}{n} i(r-1)(s-1)}$ - 長さ n のリスト u_r に対する離散フーリエ変換結果 v_s
InverseFourier - 離散逆フーリエ変換
- $u_r = \frac{1}{\sqrt{n}} \sum_{s=1}^n v_s e^{\frac{-2\pi}{n} i(r-1)(s-1)}$ - 長さ n のリスト v_s に対する離散逆フーリエ変換結果 u_r

統計的データ解析

ランダムサンプリング：乱数の生成

RandomInteger
RandomReal
- RandomReal [] - 区間[0,1]の一様乱数
- RandomReal [{x_min, x_max}]
- RandomReal [x_max]
etc,...
RandomVariate - 与えられた確率分布に従う疑似乱数、またはそのリストを返す
- RandomVariate[UniformDistribution[]] -> 0.406173
- RandomVariate[NormalDistribution[], 10^5]//Histogram
RandomPoint - 与えられた領域に一様に分布する疑似乱数、またはそのリストを返す
etc,...
SeedRandom - 疑似乱数の種を与える
- SeedRandom [n] - 乱数の種 n は数字でも文字でもなんでも良い
- SeedRandom [Method->"method"] - 疑似乱数生成アルゴリズムを指定することも出来る
BlockRandom - 乱数生成のための内部状態を局所化する
- {BlockRandom[{BlockRandom[RandomReal[]], RandomReal[]}], RandomReal[]} -> {{0.876171, 0.876171}, 0.876171}

パラメトリック統計分布

NormalDistribution - 正規分布
UniformDistribution - 一様分布
GeometricDistribution - 幾何分布
- RandomInteger[GeometricDistribution[2/3], 12000] // Histogram - 得られる変数が 1 増加するごとに 1-2/3 = 1/3 となることが分かる。

並列計算

Parallelize
ParallelTry - 並列計算し、最初に得た結果を返す

計算の設定とブロードキャスト

ParallelEvaluate - 与えた式を全並列サブカーネルで評価し、結果をリストにして返す
- ParallelEvaluate [expr]
- ParallelEvaluate[$KernelID] -> {1,2,3,4}

並列計算の設定

データの並列化

並行性制御：並行性

並行評価

並列計算の設定

$KernelCount - 現在起動中のサブカーネルの数
Kernels - 現在起動中の並列サブカーネルのリスト
$KernelID - 呼出された並列サブカーネルのID
- ParallelDo[Print[$KernelID, ":", i], {i, 1, 6}]

マルチプロセッサおよびマルチコアの計算

Compile
- Compile [{x₁, x₂, …}, expr]
- Compile [{{x₁, t₁}, …}, expr] - （引数の）型指定。ここで t_i は _Integer, _Real, _Complex, True | False
- Compile [{{x₁, t₁, n₁}, …}, expr] - （引数の）リスト型指定。x_i が t_i 型の n_i 次元配列であることを宣言する。
- Compile [vars, expr, {{p₁, pt₁}, …}] - （本体の）型指定。式 expr に現れる部分式 p_i が、pt_i 型であることを宣言する
- Compile[{{a, False | True}}, !a] // #[True] & -> False
- Parallelization - Compileのオプション。並列可能にすべきかを指定する

調整とデバッグ

Monitor - 更新される変数の値をリアルタイムに追跡、表示する
- Block[{tmp = 0}, Monitor[Do[Pause[0.5]; tmp += i, {i, 10}], tmp]]
EvaluationData
Echo - 中間結果を表示する。ラベルを付けたりも出来る。
- Echo [expr] - expr を表示し、expr を返す
- Echo [expr, label] - expr に label のラベルを付けて表示し、expr を返す
- Echo [expr, label, f] - f[expr] に label のラベルを付けて表示し、expr を返す
EchoFunction - Echo の演算子型
- EchoFunction [f][expr]
- EchoFunction [label, f][expr]
PrintTemporary - 与えられた式を、入力行が評価中の間だけ表示する。
- PrintTemporary["evaluating now..."]; Pause[2]; "Done."
Dialog

アサーション

Assert - アサーション
- Assert [test]
- Assert [test, tag]
- On[Assert] しないと機能しないので注意
$AssertFunction - アサーションに失敗した場合に呼出される関数

メッセージ

Quiet - 与えられた式を「静かに」評価する（メッセージを表示しない）
Off - メッセージの表示を大域的に抑制にする
- Off [symbol::tag]
- Off ["name"]
On - メッセージの表示をオンにする

時間の測定と最適化

TimeConstrained - 与えられた時間だけ、式の評価を行う
- TimeConstrained [expr, t]
- TimeConstrained [expr, t, failexpr]

メモリの計測と最適化

ByteCount
MemoryConstrained - 指示された量以上のメモリが要求された場合に処理を中断する
MemoryInUse - 現在使用中のメモリ量

時間測定

Timing - 与えられた式を評価し、そのCPUタイム（秒）と評価結果をリストにして返す
RepeatedTiming - くり返し実行し、平均CPUタイム（秒）と評価結果をリストにして返す
AbsoluteTiming - 実際の経過時間版

時間取得

TimeUsed - 現行のWolframシステムが起動してからの秒数
SessionTime
AbsoluteTime
$TimeUnit - 記録される時間の最小幅を秒で返す

プロット

オプション

プロット

グラフィック

ImageSize - 横幅、高さ等サイズを指定

グラフィックス指示子

線と矢印

AbsoluteThickness - 線の絶対的太さを指定
- Plot[x^2, {x,0,5}, PlotStyle->AbsoluteThickness[0.5]]

ユーザインターフェース構成とレイアウト

注釈構造>>コントロールオブジェクト

Slider
ProgressIndicator - インジケーターを与える
- ProgressIndicator [x] - 区間[0,1]における x の進捗状況を表示
- ProgressIndicator [Dynamic[x]]
- ProgressIndicator [x, {xmin, xmax}]

インタラクティブな操作

Manipulate
- Manipulate [expr, {u, u_min, u_max}]
- Manipulate [expr, {u, u_min, u_max, du}]
- Manipulate [expr, {{u,u_init}, u_min, u_max, …}]
- Manipulate[Plot[Sin[x (1 + a x)], {x, 0, 6}], {a, 0, 2}]

開発者ユーティリティパッケージ Developer`

Needs["Developer"]`

パックアレー関数

ToPackedArray - 可能な場合、与えられたリストの内部表現をパックアレーにする
- ToPackedArray [expr]
- ToPackedArray [expr, type] - 可能な type は Integer,Real, Complex 等
- Range[0, 10] // ToPackedArray
FromPackedArray - パックアレーを非パックアレーへと変換する。非パックアレーが与えられた場合はそのまま返す。
PackedArrayQ - 与えられたリストの内部表現がパックアレーであるか否か
- 確認できる型は Integer, Real, Complex のいずれか。
On["Packing"] - パックアレーがアンパックされるときに警告を発する

その他リンク

入出力の表記法 - FullForm, InputForm, OutputForm, StandardForm
数の型
SymbolicCユーザガイド

パフォーマンス

メモ化

hirax.net::お気楽・超簡単なMathematicaのメモ化（memoization）関数作成テクニック

In[39]:= AbsoluteTiming[Module[{fib},
  fib[1] = 1;
  fib[2] = 1;
  fib[n_] := fib[n - 1] + fib[n - 2];
  fib[30]]]

Out[39]= {1.40604,832040}

In[41]:= AbsoluteTiming[Module[{fib},
  fib[1] = 1;
  fib[2] = 1;
  fib[n_] := fib[n] = fib[n - 1] + fib[n - 2];
  fib[30]]]

Out[41]= {0.000204,832040}

メモ

why ParallelMapThread does not exist?

You get articles that match your needs
You can efficiently read back useful information
You can use dark theme

What you can do with signing up