Wolfram 语言与系统参考资料中心

DownValuesFunction

DownValuesFunction[sym]

表示一个函数，在编译时使用附加于 sym 的定义.

范例

打开所有单元关闭所有单元

基本范例 (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]

调用最后的 catchall 定义：

Wolfram Language code: cf[55, 200]

多个声明 (1)

附加在一个符号上的定义可以在多个不同类型的声明中使用：

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

进行两项不同类型的声明，并编译使用它们的函数：

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]

条件 (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]]]

不支持 Verbatim 模式：

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

	_	匹配一个参数
	x_	匹配名称被设为 x 的参数
	_h	若标头为 h 则匹配
	x_?test	若 test[x] 的结果为 True 则匹配
	p/;cond	若 cond 的结果为 True 则匹配
	Except[p]	若 p 不匹配则匹配
	p₁\|p₂	若 p_i 之一匹配则匹配
	f[g[p]]	匹配复合表达式（用于惰性表达式和压缩数组）
	__,___	匹配一个序列（用于惰性表达式）

DownValuesFunction

更多信息

范例

基本范例 (2)

范围 (13)

多个定义 (1)

多个声明 (1)

多态声明 (1)

递归调用 (1)

未命名模式 (1)

重复的模式 (1)

匹配标头 (1)

模式测试 (1)

条件 (1)

Except (1)

Alternatives (1)

复合模式 (1)

序列 (1)

应用 (1)

符号定义 (1)

可能存在的问题 (5)

更新 (1)

定义限制 (1)

类型一致性 (1)

不支持的模式 (1)

序列模式 (1)

参见

技术笔记

相关指南

历史

文本

CMS

APA

BibTeX

BibLaTeX