DownValuesFunction

コンパイルする際に sym に添付された定義を使う関数を表す．

詳細

DownValuesFunctionはコンパイルされたコードで直接使うことができる．
DownValuesFunctionはFunctionDeclarationで指定されたコンパイルされた宣言で使うことができる．
DownValuesFunction指定は，通常，Typedを使って型注釈を与える．
DownValuesFunctionは，コンパイルされるとシンボル宣言から関数を作成してこれをコンパイルする．
DownValuesFunctionを使う宣言は多様型を使う．
次は，サポートされるパターン構造である．

	_	引数をマッチする
	x_	名前 x に割り当てる引数をマッチする
	_h	頭部が h かどうかマッチする
	x_?test	test[x]を評価するとTrueになるかどうかマッチする
	p/;cond	cond を評価するとTrueになるかどうかマッチする
	Except[p]	p がマッチしないかどうかマッチする
	p₁\|p₂	p_iの一つがマッチするかどうかマッチする
	f[g[p]]	（不活性な式とパックアレーについて）複合式をマッチする
	__,___	（不活性な式について）列をマッチする

例題

すべて開くすべて閉じる

例 (2)

Wolfram Engineで二乗関数を定義する：

Wolfram Language code: square[x_] := x ^ 2

その下向きの値を使って整数型の場合のコンパイルされた関数を作成する：

Wolfram Language code:

funcComp = FunctionCompile[
	Function[Typed[arg, "MachineInteger"], 
	Typed[DownValuesFunction[square], {"MachineInteger"} -> "MachineInteger"][arg]
	]
	]

コンパイルされた関数を整数引数で使う：

Wolfram Language code: funcComp[100]

下向きの値を繰り返すことで累乗関数を定義する：

Wolfram Language code:

factorial[0] = factorial[1] = 1;
factorial[n_] := n * factorial[n - 1]

FunctionDeclarationを使って累乗を整数型の署名とその下向きの値の実装と関連付ける：

Wolfram Language code:

factorialC = FunctionCompile[
	FunctionDeclaration[factorial, Typed[{"MachineInteger"} -> "MachineInteger"]@DownValuesFunction[factorial]
	], 
	Function[Typed[arg, "MachineInteger"], factorial[arg]]
	]

整数入力に対してコンパイルされた関数を呼び出す：

Wolfram Language code: factorialC[10]

スコープ (13)

複数の定義 (1)

同じシンボルに添付された複数の定義を使うことができる：

Wolfram Language code:

f2[x_, y_] /; x > y := y
f2[x_, 2] := x
f2[x_, y_]  := x + y

定義を使う関数をコンパイルする：

Wolfram Language code:

cf = FunctionCompile[Function[{Typed[a1, "MachineInteger"], Typed[a2, "MachineInteger"]}, Typed[DownValuesFunction[f2], {"MachineInteger", "MachineInteger"} -> "MachineInteger"][a1, a2]]]

次は条件を使う定義を呼び出す：

Wolfram Language code: cf[55, 22]

次はリテラルの2を使う定義を呼び出す：

Wolfram Language code: cf[1, 2]

次は，最後のキャッチオール定義を呼び出す：

Wolfram Language code: cf[55, 200]

複数の宣言 (1)

シンボルに添付された定義は異なる型の複数の宣言で使うことができる：

Wolfram Language code: funA[x_, y_] := x + y

異なる型の2つの宣言を行い，それぞれを使う関数をコンパイルする：

Wolfram Language code:

decls = {
	FunctionDeclaration[funA, Typed[{"MachineInteger", "MachineInteger"} -> "MachineInteger"]@
	DownValuesFunction[funA]
	], 
	FunctionDeclaration[funA, 
	Typed[{"Real64", "Real64"} -> "Real64"]@
	DownValuesFunction[funA]
	]
	};
cfs = FunctionCompile[decls, <|
	"int" -> Function[{Typed[a1, "MachineInteger"], Typed[a2, "MachineInteger"]}, 
	funA[a1, a2]
	], 
	"real" -> Function[{Typed[a1, "Real64"], Typed[a2, "Real64"]}, funA[a1, a2]
	]
	|>]

整数のケースを呼び出す：

Wolfram Language code: cfs["int"][2, 3]

実数のケースを呼び出す：

Wolfram Language code: cfs["real"][2.5, 3.25]

多形宣言 (1)

シンボルに添付された定義は多様型で宣言することができる：

Wolfram Language code: funB[x_, y_] := x + y

多様型の宣言を作り，これを異なる型に使用する関数をコンパイルする：

Wolfram Language code:

decl = FunctionDeclaration[ funB, Typed[ForAllType[t, {t, t} -> t]]@DownValuesFunction[funB]];
cfs = FunctionCompile[ {decl}, <|"int" -> Function[{Typed[a1, "MachineInteger"], Typed[a2, "MachineInteger"]}, funB[a1, a2]], "real" -> Function[{Typed[a1, "Real64"], Typed[a2, "Real64"]}, funB[a1, a2]]|>]

整数のケースを呼び出す：

Wolfram Language code: cfs["int"][2, 3]

実数のケースを呼び出す：

Wolfram Language code: cfs["real"][2.5, 3.25]

再帰呼出し (1)

シンボル定義を使う関数宣言はそれ自身を呼び出すことができる：

Wolfram Language code:

fact[0] := 1
fact[n_] := n * fact[n - 1]

宣言を行い，それを使う関数をコンパイルする：

Wolfram Language code:

decl = FunctionDeclaration[fact, Typed[{"MachineInteger"} -> "MachineInteger"]@DownValuesFunction[fact]];
cf = FunctionCompile[{decl}, Function[{Typed[a1, "MachineInteger"]}, fact[a1]]]

関数を呼び出す：

Wolfram Language code: cf[10]

無名のパターン (1)

パターンの引数には名前は必要ない：

Wolfram Language code: unnamedPattern[_] := "noName"

定義を使う関数をコンパイルする：

Wolfram Language code:

cf = FunctionCompile[Function[{Typed[a1, "MachineInteger"]}, Typed[ DownValuesFunction[unnamedPattern], {"MachineInteger"} -> "String"][a1]]]

異なる値で関数を呼び出す：

Wolfram Language code: cf[1]

繰り返されるパターン (1)

定義に同じ名前が複数回使われている場合，呼び出されたときに名前が値が同じである必要がある：

Wolfram Language code:

repeatedPattern[x_, x_] := {x}
repeatedPattern[x_, y_] := {x, y}

定義を使う関数をコンパイルする：

Wolfram Language code:

cf = FunctionCompile[Function[{Typed[a1, "MachineInteger"], Typed[a2, "MachineInteger"]}, Typed[DownValuesFunction[repeatedPattern], {"MachineInteger", "MachineInteger"} -> "PackedArray"::["MachineInteger", 1]][a1, a2]]]

異なる値で関数を呼び出す：

Wolfram Language code: cf[1, 2]

同じ値で関数を呼び出すと，同じ値については定義が使われる：

Wolfram Language code: cf[3, 3]

頭部のマッチ (1)

パターンは頭部にマッチするように書くことができる：

Wolfram Language code:

headMatch[x_Real] := "Real"
headMatch[x_] := "NotReal"

これを使う多形宣言を作成する：

Wolfram Language code: decl = FunctionDeclaration[headMatch, Typed[ForAllType["e", {"e"} -> "String"]]@DownValuesFunction[headMatch]];

頭部と一致しない引数でこの宣言を使う関数をコンパイルする：

Wolfram Language code: cf = FunctionCompile[{decl}, Function[{Typed[a1, "MachineInteger"]}, headMatch[a1]]];

この関数を整数で呼び出し，頭部と一致しない定義を使用する：

Wolfram Language code: cf[1]

頭部と一致しない引数でこの宣言を使う関数をコンパイルする：

Wolfram Language code: cf = FunctionCompile[{decl}, Function[{Typed[a1, "Real64"]}, headMatch[a1]]];

この関数を実数で呼び出し，頭部と一致する定義を使う：

Wolfram Language code: cf[1.5]

パターンテスト (1)

コンパイルされたパターンはPatternTestを使うことができる：

Wolfram Language code:

patternTest[x_ ? EvenQ] := {0, x}
patternTest[x_] := {1, x}

定義を使う関数をコンパイルする：

Wolfram Language code:

cf = FunctionCompile[Function[{Typed[a1, "MachineInteger"]}, Typed[DownValuesFunction[patternTest], {"MachineInteger"} -> "PackedArray"::["MachineInteger", 1]][a1]]];

入力は偶数である：

Wolfram Language code: cf[2]

出力は奇数である：

Wolfram Language code: cf[21]

Condition (1)

コンパイルされたパターンはConditionを使うことができる：

Wolfram Language code:

conditionPattern[x_, y_] /; x > y := {y, x}
conditionPattern[x_, y_] := {x, y}

定義を使う関数をコンパイルする：

Wolfram Language code:

cf = FunctionCompile[Function[{Typed[a1, "MachineInteger"], Typed[a2, "MachineInteger"]}, Typed[DownValuesFunction[conditionPattern], {"MachineInteger", "MachineInteger"} -> "PackedArray"::["MachineInteger", 1]][a1, a2]]];

入力の引数は順になっている：

Wolfram Language code: cf[1, 2]

入力の引数が順になっていないので，出力では逆順になっている：

Wolfram Language code: cf[7, 3]

Except (1)

コンパイルされたパターンはExceptを使うことができる：

Wolfram Language code:

exceptPattern[Except[y_ ? EvenQ]] := {y, 0}
exceptPattern[y_] := {y}

宣言を行い，これを使う関数をコンパイルする：

Wolfram Language code:

cf = FunctionCompile[Function[{Typed[a1, "MachineInteger"]}, Typed[DownValuesFunction[exceptPattern], {"MachineInteger"} -> "PackedArray"::["MachineInteger", 1]][a1]]];

引数が偶数なので，最初の定義は使われない：

Wolfram Language code: cf[20]

引数が奇数なので，最初の定義が使われる：

Wolfram Language code: cf[3]

Wolfram Language code:

exceptPattern2[y : Except[_ ? EvenQ, y_ /; y > 20]] := {y, 0}
exceptPattern2[y_] := {y}

定義を使う関数をコンパイルする：

Wolfram Language code:

cf = FunctionCompile[Function[{Typed[a1, "MachineInteger"]}, Typed[DownValuesFunction[exceptPattern2], {"MachineInteger"} -> "PackedArray"::["MachineInteger", 1]][a1]]];

引数が偶数で20より大きいので，最初の定義は使われない：

Wolfram Language code: cf[24]

引数が奇数で20より大きいので，最初の定義が使われる：

Wolfram Language code: cf[25]

引数は奇数だが20より小さいので，最初の定義は使われない：

Wolfram Language code: cf[3]

Alternatives (1)

コンパイルされたパターンはAlternativesを使うことができる：

Wolfram Language code: alternativesPattern[x : (_Integer | _Real)] := x

宣言を行う：

Wolfram Language code:

decl = FunctionDeclaration[alternativesPattern, Typed[ForAllType["e", {"e"} -> "e"]]@DownValuesFunction[alternativesPattern]];

宣言を使う関数をコンパイルする：

Wolfram Language code: cf = FunctionCompile[{decl}, Function[{Typed[a1, "MachineInteger"]}, alternativesPattern[a1]]];

この関数は入力をマッチするので，結果が生成される：

Wolfram Language code: cf[1]

宣言を使う別の型の関数をコンパイルする：

Wolfram Language code: cf = FunctionCompile[{decl}, Function[{Typed[a1, "Real64"]}, alternativesPattern[a1]]];

この関数も入力をマッチするので，結果が生成される：

Wolfram Language code: cf[1.5]

複合パターン (1)

コンパイルでは，"InertExpression"や"PackedArray"等の特定の型の複合パターンがサポートされる：

Wolfram Language code:

compoundPattern[{x_, y_}] := x[y]
compoundPattern[x_] := x

定義を使う関数をコンパイルする：

Wolfram Language code:

cf = FunctionCompile[Function[{Typed[a1, "InertExpression"]}, Typed[DownValuesFunction[compoundPattern], {"InertExpression"} -> "InertExpression"][a1]]];

この関数は入力をマッチするので，結果が生成される：

Wolfram Language code: cf[{f, x}]

関数を使うために別の型で関数をコンパイルする：

Wolfram Language code: cf[{a, b, c}]

列 (1)

コンパイルでは，"InertExpression"の一連の特定のパターンがサポートされる：

Wolfram Language code:

sequencePattern[{x_, y__}] := x[y]
sequencePattern[_] := InertExpression[$Failed]

宣言を行い，これを使う関数をコンパイルする：

Wolfram Language code:

cf = FunctionCompile[Function[{Typed[a1, "InertExpression"]}, Typed[DownValuesFunction[sequencePattern], {"InertExpression"} -> "InertExpression"][a1]]];

列は平坦化される：

Wolfram Language code: cf[{f, x, y, z}]

列を含むパターンがマッチしないので，失敗が返される：

Wolfram Language code: cf[{f}]

パターンは，任意の式の型の複合頭部を持つことができる：

Wolfram Language code:

sequencePattern2[f[x_, {__, x_}]] := x
sequencePattern2[_] := InertExpression[$Failed]

Wolfram Language code:

cf = FunctionCompile[Function[{Typed[a1, "InertExpression"]}, Typed[DownValuesFunction[sequencePattern2], {"InertExpression"} -> "InertExpression"][a1]]];

これはマッチする：

Wolfram Language code: cf[f[g, {1, 2, 3, 4, g}]]

これはマッチしない：

Wolfram Language code: cf[f[g, {1, 2, 3, 4, h}]]

アプリケーション (1)

シンボル定義 (1)

シンボル定義を使う宣言は，宣言が複数回使われる場合に便利である：

Wolfram Language code:

restrictFlow[ x_, y_] := 
	Module[{z}, 
	  z = 1 - 1 / (x + I y) ^ 2;
	  {{x, y}, {Re[z], -Im[z]}}
	]

シンボルを参照するFunctionDeclaration：

Wolfram Language code:

decl = FunctionDeclaration[restrictFlow, Typed[{"Real64", "Real64"} -> "PackedArray"::["Real64", 2]]@DownValuesFunction[restrictFlow]];

このシンボルを使う関数：

Wolfram Language code:

func = Function[{Typed[x0, "Real64"], Typed[x1, "Real64"], Typed[y0, "Real64"], Typed[y1, "Real64"]}, Table[Flatten[ Table[{restrictFlow[x + d / 4, y], restrictFlow[x + d / 4, -y]}, {x, x0, x1}, {y, y0, y1}], 2] , {d, 0, 3, 0.3}]];

関数用にコンパイルされたコード：

Wolfram Language code: cf = FunctionCompile[decl, func]

Wolfram Language code: data = cf[-7, 5, 0.5, 3];

作成されたデータに基づくベクトルプロット：

Wolfram Language code: ListVectorPlot[First[data]]

コンパイルされたバージョンの方がはるかに速い：

Wolfram Language code: func[-7, 5, 0.5, 3];//RepeatedTiming

Wolfram Language code: cf[-7, 5, 0.5, 3];//RepeatedTiming

出力のアニメーション：

Wolfram Language code: Animate[ListVectorPlot[Part[data, i]], {i, 1, Length[data], 1}, SaveDefinitions -> True, AnimationRunning -> False]

考えられる問題 (5)

更新 (1)

DownValuesFunctionはコンパイルを実行する際に使用された定義を使う：

Wolfram Language code: testFun[x_] := x ^ 2

Wolfram Language code:

func = Function[Typed[arg, "MachineInteger"], Typed[DownValuesFunction[testFun], {"MachineInteger"} -> "MachineInteger"][arg]];
funcComp = FunctionCompile[func];

Wolfram Language code: funcComp[10]

Wolfram Language code: testFun[x_] := x ^ 3

結果はコンパイルが終了すると所定の定義を使う：

Wolfram Language code: funcComp[10]

定義の制約 (1)

すべてのケースに適用される定義がなければ，エラーケースが追加される：

Wolfram Language code:

fun1[x_ ? Positive]  := 
    x

Wolfram Language code:

decl = FunctionDeclaration[fun1, Typed[{"Integer64"} -> "Integer64"]@DownValuesFunction[fun1]];
funcComp = FunctionCompile[decl, Function[Typed[arg, "Integer64"], fun1[arg]]]

次は問題なく動作する：

Wolfram Language code: funcComp[10]

次は，エラーケースをトリガする：

Wolfram Language code: funcComp[-10]

型の一貫性 (1)

パターン定義のすべてのブランチは同じ型を返す必要がある：

Wolfram Language code:

fun10[x_ /; x > 10]  := 
    True
fun10[x_]  := 
    10

Wolfram Language code:

decl = FunctionDeclaration[fun10, Typed[{"Integer64"} -> "Integer64"]@DownValuesFunction[fun10]];
FunctionCompile[decl, Function[Typed[arg, "Integer64"], fun10[arg]]]

パターン定義のすべてのブランチは，引数に対してコンパイルされる必要がある：

Wolfram Language code:

fun11[x_ /; x > 1]  := 
    Sin[x]
	
fun11[x_]  := 
    x

これはコンパイルされる：

Wolfram Language code:

decl = FunctionDeclaration[fun11, Typed[{"Real64"} -> "Real64"]@DownValuesFunction[fun11]];
FunctionCompile[decl, Function[Typed[arg, "Real64"], fun11[arg]]]

これはコンパイルされない：

Wolfram Language code:

decl = FunctionDeclaration[fun11, Typed[{"Integer64"} -> "Integer64"]@DownValuesFunction[fun11]];
FunctionCompile[decl, Function[Typed[arg, "Integer64"], fun11[arg]]]

サポートされていないパターン (1)

任意のパターンはサポートされていない：

Wolfram Language code:

fun5[x_, y_ : 10]  := 
    x

Wolfram Language code:

decl = FunctionDeclaration[fun5, Typed[{"Integer64"} -> "Integer64"]@DownValueFunction[fun5]];
FunctionCompile[decl, Function[Typed[arg, "Integer64"], fun5[arg]]]

ホールドされたパターンはサポートされていない：

Wolfram Language code:

fun8[HoldPattern[y_]]  := 
    x

Wolfram Language code:

decl = FunctionDeclaration[fun8, Typed[{"Integer64"} -> "Integer64"]@DownValuesFunction[fun8]];
FunctionCompile[decl, Function[Typed[arg, "Integer64"], fun8[arg]]]

逐語的なパターンはサポートされていない：

Wolfram Language code:

fun9[Verbatim[y_]]  := 
    x

Wolfram Language code:

decl = FunctionDeclaration[fun9, Typed[{"Integer64"} -> "Integer64"]@DownValuesFunction[fun9]];
FunctionCompile[decl, Function[Typed[arg, "Integer64"], fun9[arg]]]

列パターン (1)

列パターンは多形宣言をサポートしない：

Wolfram Language code: fun10[{x_, y__}] := x[y]

多形宣言を行う．コンパイルにはこれは使えない：

Wolfram Language code:

decl = FunctionDeclaration[fun10, Typed[ ForAllType["e", {"e"} -> "e"]]@DownValuesFunction[fun10]];
FunctionCompile[{decl}, Function[{Typed[a1, "InertExpression"]}, fun10[a1]]];

Top

DownValuesFunction

詳細

例題

例 (2)

スコープ (13)

複数の定義 (1)

複数の宣言 (1)

多形宣言 (1)

再帰呼出し (1)

無名のパターン (1)

繰り返されるパターン (1)

頭部のマッチ (1)

パターンテスト (1)

Condition (1)

Except (1)

Alternatives (1)

複合パターン (1)

列 (1)

アプリケーション (1)

シンボル定義 (1)

考えられる問題 (5)

更新 (1)

定義の制約 (1)

型の一貫性 (1)

サポートされていないパターン (1)

列パターン (1)

関連項目

テクニカルノート

関連するガイド

履歴

テキスト

CMS

APA

BibTeX

BibLaTeX