我一直在研究检查函数参数的方法。我注意到了
MatrixQ有2个参数，第二个是应用于每个元素的测试。
但ListQ只接受一个论点。 （也出于某种原因，?ListQ没有帮助页面，例如?MatrixQ。
因此，例如，要检查函数的参数是否是数字矩阵，我写
ClearAll[foo]
foo[a_?(MatrixQ[#, NumberQ] &)] := Module[{}, a + 1]
为List做同样的事情会是什么好方法？以下仅检查输入是否为List
ClearAll[foo]
foo[a_?(ListQ[#] &)] := Module[{}, a + 1]
我可以这样做：
ClearAll[foo]
foo[a_?(ListQ[#] && (And @@ Map[NumberQ[#] &, # ]) &)] := Module[{}, a + 1]
以便foo[{1, 2, 3}]可以使用，但foo[{1, 2, x}]不会（假设x是符号）。但在我看来，这是一个复杂的方法。
问题：您是否知道更好的方法来检查参数是否为列表，并检查列表内容是否为Numbers（或Mathematica已知的任何其他头部？）
以及相关问题：在每个参数中添加此类检查会产生哪些主要的运行时性能问题？如果是这样，您是否建议在测试和开发完成后删除这些检查，以便最终程序运行得更快？ （例如，有一个包含所有检查的代码版本，用于开发/测试，以及没有用于生产的版本）。
答案 0 :(得分：13)
您可以以与VectorQ完全类似的方式使用MatrixQ。例如，
f[vector_ /; VectorQ[vector, NumericQ]] := ...
另请注意VectorQ和ListQ之间的两个差异：
普通VectorQ（没有第二个参数）只有在列表中没有元素本身的情况下才会给出（即仅适用于1D结构）
VectorQ会处理SparseArray，而ListQ则不会
我不确定在实践中使用这些对性能的影响，我对此非常好奇。
这是一个天真的基准。我正在比较两个函数：一个只检查参数，但什么都不做，另一个添加两个向量（这是一个非常快速的内置操作，即比这更快的任何东西都可以忽略不计）。我正在使用NumericQ，这是一个比NumberQ更复杂（因此可能更慢）的检查。
In[2]:= add[a_ /; VectorQ[a, NumericQ], b_ /; VectorQ[b, NumericQ]] :=
a + b
In[3]:= nothing[a_ /; VectorQ[a, NumericQ],
b_ /; VectorQ[b, NumericQ]] := Null
打包数组。可以验证检查是恒定时间（此处未显示）。
In[4]:= rr = RandomReal[1, 10000000];
In[5]:= Do[add[rr, rr], {10}]; // Timing
Out[5]= {1.906, Null}
In[6]:= Do[nothing[rr, rr], {10}]; // Timing
Out[6]= {0., Null}
同构非打包数组。检查是线性时间，但非常快。
In[7]:= rr2 = Developer`FromPackedArray@RandomInteger[10000, 1000000];
In[8]:= Do[add[rr2, rr2], {10}]; // Timing
Out[8]= {1.75, Null}
In[9]:= Do[nothing[rr2, rr2], {10}]; // Timing
Out[9]= {0.204, Null}
非同类非打包数组。检查与前一个示例中的时间相同。
In[10]:= rr3 = Join[rr2, {Pi, 1.0}];
In[11]:= Do[add[rr3, rr3], {10}]; // Timing
Out[11]= {5.625, Null}
In[12]:= Do[nothing[rr3, rr3], {10}]; // Timing
Out[12]= {0.282, Null}
基于这个非常简单的例子的结论：
VectorQ经过高度优化，至少在使用常见的第二个参数时。它比例如快得多添加两个向量，这本身就是一个很好的优化操作。VectorQ是常量时间。@Leonid's answer也非常相关，请看。
答案 1 :(得分：11)
关于性能命中（因为您已经回答了第一个问题） - 无论如何，都要进行检查，但是在您的顶级功能中（直接从您的功能用户接收数据。用户也可以另一个独立的模块，由您或其他人撰写）。不要将这些检查放在所有中间函数中，因为这样的检查将是重复的，实际上是不合理的。
修改的
为了解决由@Nasser在评论中提出的中间函数错误的问题：有一种非常简单的技术允许人们在一次点击＆＃34;中打开和关闭模式检查。您可以将模式存储在包中的变量中，这些变量在函数定义之前定义。
以下是一个示例，其中f是顶级函数，而g和h是＆＃34;内部函数＆＃34;。我们定义了两种模式：主要功能和内部功能，如下所示：
Clear[nlPatt,innerNLPatt ];
nlPatt= _?(!VectorQ[#,NumericQ]&);
innerNLPatt = nlPatt;
现在，我们定义我们的功能：
ClearAll[f,g,h];
f[vector:nlPatt]:=g[vector]+h[vector];
g[nv:innerNLPatt ]:=nv^2;
h[nv:innerNLPatt ]:=nv^3;
请注意，模式在定义时中定义，而不是运行时，因此这完全等同于手动编码这些模式。测试完成后，您只需更改一行：从
开始innerNLPatt = nlPatt
到
innerNLPatt = _
并重新加载您的包裹。
最后一个问题是 - 你如何快速找到错误？我在＆＃34中回答了here;而不是返回$Failed，可以使用投掷来引发异常。＆＃34; 和＆ ＃34;元编程和自动化＆＃34; 。
结束编辑
我在我的书here中简要讨论了这个问题。在该示例中，性能损失是在运行时间增加10％的水平上，IMO是可接受的。在目前的情况下，检查更简单，性能损失更小。通常，对于任何计算密集型的函数，正确编写的类型检查仅花费总运行时间的一小部分。
一些有用的技巧：
Condition或PatternTest）。 例如：
randomString[]:=FromCharacterCode@RandomInteger[{97,122},5];
rstest = Table[randomString[],{1000000}];
In[102]:= MatchQ[rstest,{__String}]//Timing
Out[102]= {0.047,True}
In[103]:= MatchQ[rstest,{__?StringQ}]//Timing
Out[103]= {0.234,True}
仅仅因为在后一种情况下使用了PatternTest，检查速度要慢得多，因为模式匹配器会为每个元素调用赋值器，而在第一种情况下，一切都是纯语法的，所有都是在模式匹配器内完成。
MatchQ和其他模式测试函数不会解包某些特殊模式，而且，对于其中一些模式测试函数，检查瞬时< / em>的以下是一个例子：
In[113]:=
test = RandomInteger[100000,1000000];
In[114]:= MatchQ[test,{__?IntegerQ}]//Timing
Out[114]= {0.203,True}
In[115]:= MatchQ[test,{__Integer}]//Timing
Out[115]= {0.,True}
In[116]:= Do[MatchQ[test,{__Integer}],{1000}]//Timing
Out[116]= {0.,Null}
对于VectorQ，MatrixQ和ArrayQ等具有某些谓词（NumericQ）的函数来说，显然也是如此 - 这些测试非常有效。< / p>
例如，我们想测试我们有一个真正的数字矩阵：
In[143]:= rm = RandomInteger[10000,{1500,1500}];
这是最直接和最缓慢的方式：
In[144]:= MatrixQ[rm,NumericQ[#]&&Im[#]==0&]//Timing
Out[144]= {4.125,True}
这更好，因为我们更好地重用了模式匹配器：
In[145]:= MatrixQ[rm,NumericQ]&&FreeQ[rm,Complex]//Timing
Out[145]= {0.204,True}
然而，我们没有利用矩阵的包装性质。这还是更好的：
In[146]:= MatrixQ[rm,NumericQ]&&Total[Abs[Flatten[Im[rm]]]]==0//Timing
Out[146]= {0.047,True}
但是，这不是结束。以下几点接近瞬间：
In[147]:= MatrixQ[rm,NumericQ]&&Re[rm]==rm//Timing
Out[147]= {0.,True}
答案 2 :(得分：3)
由于ListQ只检查头部是List，因此以下是一个简单的解决方案：
foo[a:{___?NumberQ}] := Module[{}, a + 1]