Mathematica

Mathematica 覚書

Mathematica の本家サイトの構成が微妙に使いにくいので、自分用メモ。
チートシート的な。

Wolfram言語のシンタックス

記号

検索しにくい記号が沢山ある。コードを読むために片っ端からメモ。

割当て

異なるシンボルへの定義式の関連付け』を要確認

  • = - Set 代入
  • := - SetDelayed 遅延代入(下向き)
    • f[x_]:=x^2
  • /:~= - TagSet タグ代入
  • /:~:= - TagSetDelayed タグ付き遅延代入
  • ^= - UpSet 上向き代入
  • ^:= - UpSetDelayed (上向き)遅延代入
  • =. - Unset 割当て解除
  • /:~=. - TagUnset タグ付き割当て解除

規則

規則の表現
  • -> - Rule 置換規則
    • (a + y) /. a -> x -> x + y
    • {x, y} /. {x -> 1, y -> 2} -> {1, 2}
  • :> - RuleDelayed
規則の適用
  • /. - ReplaceAll 置換
  • //. - ReplaceRepeated

パターン

基本のパターンオブジェクト
複合パターン
パターンの制限
  • /; - Condition 条件
  • ? - PatternTest
    • p?test
パターンのデフォルト

リストの要素

  • [[...]] - 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 連装
    • <|key1->val1, key2->val2, …|>
  • 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] -> 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 -> {a, {b, c}} // TreeForm
  • チュートリアル:式の木構造

式の判定

等号と不等号

論理結合

数の特性

  • 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 - 与えられた秒数だけ停止する

スコープ構文

リスト操作

リストの構築

  • 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 - 頭からリストを走査し、与えた述語が真を返し続ける間の部分リストを返す

関連

  • UpTo - 範囲の最大個数を指定する
    • Take[{a, b}, 8] - これはエラーを返す(与えられたリストに2(<8)つしか要素が無いため)
    • Take[{a, b}, UpTo[8]] -> {a, b}

選択

  • 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

スプライン

スプラインオブジェクト

ピーク解析

  • FindPeaks - ピークを検出し、その位置と値のペアのリスト {{x1, y1}, {x1, y2}, …} を返す
    • FindPeaks [data] - 与える data の形式は、値のリスト {y1, y2, …}
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]

記号式を求める

微積分

  • 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 のリスト ur に対する離散フーリエ変換結果 vs
  • InverseFourier - 離散逆フーリエ変換
    • $u_r = \frac{1}{\sqrt{n}} \sum_{s=1}^n v_s e^{\frac{-2\pi}{n} i(r-1)(s-1)}$ - 長さ n のリスト vs に対する離散逆フーリエ変換結果 ur

統計的データ解析

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

  • RandomInteger
  • RandomReal
    • RandomReal [] - 区間[0,1]の一様乱数
    • RandomReal [{xmin, xmax}]
    • RandomReal [xmax]
  • 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}

パラメトリック統計分布

並列計算

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

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

並列計算の設定

データの並列化

並行性制御:並行性

並行評価

並列計算の設定

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

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

  • Compile
    • Compile [{x1, x2, …}, expr]
    • Compile [{{x1, t1}, …}, expr] - (引数の)型指定。ここで ti_Integer, _Real, _Complex, True | False
    • Compile [{{x1, t1, n1}, …}, expr] - (引数の)リスト型指定。xiti 型の ni 次元配列であることを宣言する。
    • Compile [vars, expr, {{p1, pt1}, …}] - (本体の)型指定。式 expr に現れる部分式 pi が、pti 型であることを宣言する
    • 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] - exprlabel のラベルを付けて表示し、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]

メモリの計測と最適化

時間測定

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

時間取得

プロット

オプション

プロット

グラフィック

  • 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, umin, umax}]
    • Manipulate [expr, {u, umin, umax, du}]
    • Manipulate [expr, {{u,uinit}, umin, umax, …}]
    • Manipulate[Plot[Sin[x (1 + a x)], {x, 0, 6}], {a, 0, 2}]

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

  • Needs["Developer"]`

パックアレー関数

  • ToPackedArray - 可能な場合、与えられたリストの内部表現をパックアレーにする
    • ToPackedArray [expr]
    • ToPackedArray [expr, type] - 可能な typeInteger,Real, Complex
    • Range[0, 10] // ToPackedArray
  • FromPackedArray - パックアレーを非パックアレーへと変換する。非パックアレーが与えられた場合はそのまま返す。
  • PackedArrayQ - 与えられたリストの内部表現がパックアレーであるか否か

    • 確認できる型は Integer, Real, Complex のいずれか。
  • On["Packing"] - パックアレーがアンパックされるときに警告を発する

その他リンク

パフォーマンス

メモ化

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}

メモ