在大型 Mathematica 项目中设置诊断错误消息

Question

每当我创建一个大型 Mathematica 项目时，我都会遇到这个问题：Preventing avalanche of runtime errors in Mathematica，即 Mathematica 的错误消息是不透明的、陈旧的和大量的。

然后的想法是禁用 Mathematica 自己的所有错误消息，并在每个函数和模块中实现您自己的类型检查和错误消息。但是，我还没有找到一种简单有效的方法来执行此操作并最终得到，例如，某些函数会产生错误 20 次函数调用深度，然后将一整串错误消息一直返回到主程序。

您将如何为此设置一种简单的机制，仅在遇到错误的函数处生成一条错误消息以及函数调用链的简单列表？

编辑：因为它已经出现了几个答案；我特别在寻找关于它产生的输出的轻量级的东西（否则我可以坚持使用 Mathematica 的错误消息）并且显然在计算开销方面也是轻量级的。因此，虽然 Stack 和 Trace 的开销肯定很轻，但它们在复杂项目中的输出解析速度并不快，需要做一些工作来简化它。

Answer 1

YAsI - 又一个（愚蠢的？）想法......

重新阅读您的问题...

然后的想法是禁用 Mathematica 自己的所有错误消息，并在每个函数和模块中实现您自己的类型检查和错误消息。

找到这个：

$MessagePrePrint = ( #; Print[Stack[_][[;; -5]]]; Abort[]) &  

v[x_, y_] := w[x, y];
w[x_, y_] := x/y;

StackComplete@v[1, 0];

During evaluation of In[267]:= {StackComplete[v[1,0]];,
          StackComplete[v[1,0]], v[1,0], w[1,0], 1/0, 1/0, Message[Power::infy,1/0]}

Out[267]= $Aborted

结论...在第一条消息处中止并留下“合理的”堆栈跟踪。 “合理”的意思是“应该改进”。

但它是完全非侵入式的！

Answer 2

让球在这里滚动是我一直在玩弄的一个想法；创建一个伪堆栈。

首先创建一个全局变量theStack={}，然后在每个Function 或Module 中以AppendTo[theStack,"thisFuncName"] 开头并以theStack=Most@theStack 结尾。假设函数调用的深度适中（~几十个），这应该不会增加任何显着的开销。

然后实现您自己的打字/错误检查并在错误上使用Print@theStack;Abort[];。

此方法的改进可能包括：

1. 找出一种动态获取“thisFuncionName”的方法，以便可以将AppendTo[] 转换为对所有Functions 和Module 的相同函数调用。
2. 使用Message[] 而不是Print[]。
3. 在theStack 上推送其他重要变量/状态信息。

Answer 3

尝试实现@Timo 的想法（theStack）

不完整，也许有缺陷，但只是继续思考：

Clear["Global`*"];
funcDef = t_[args___]  \[CircleMinus] a_ :>
   {t["nude", args] := a,
    ReleaseHold[Hold[t[args] :=
       (If[! ValueQ[theStack], theStack = {}];
        AppendTo[theStack, ToString[t]];
        Check[ss = a, Print[{"-TheStack->", Evaluate@theStack}]; 
         Print@Hold[a]; Abort[]];
        theStack = Most@theStack;
        Return[ss])
      ]]};
v[x_, y_]\[CircleMinus]  (Sin@ g[x, y]) /. funcDef;
g[x_, y_]\[CircleMinus]  x/y /. funcDef;
v[2, 3]
v[2, 0]

输出：

Out[299]= Sin[2/3]

During evaluation of In[295]:= Power::infy: Infinite expression 1/0 encountered. >>

During evaluation of In[295]:= {-TheStack->,{v,g}}

During evaluation of In[295]:= Hold[2/0]

Out[300]= $Aborted

Answer 4

提取堆栈的建议，可能依赖于 Trace？

下面是使用 Trace 的示例，来自 Chris Chiasson。此代码将 1 + Sin[x + y] + Tan[x + y] 的评估树保存到 ~/temp/msgStream.m

Developer`ClearCache[];
SetAttributes[recordSteps, HoldAll];
recordSteps[expr_] :=

  Block[{$Output = List@OpenWrite["~/temp/msgStream.m"]}, 
   TracePrint[Unevaluated[expr], _?(FreeQ[#, Off] &), 
    TraceInternal -> True];
   Close /@ $Output;
   Thread[
    Union@Cases[
      ReadList["~/temp/msgStream.m", HoldComplete[Expression]], 
      symb_Symbol /; 
        AtomQ@Unevaluated@symb && 
         Context@Unevaluated@symb === "System`" :> 
       HoldComplete@symb, {0, Infinity}, Heads -> True], 
    HoldComplete]
   ];
recordSteps[1 + Tan[x + y] + Sin[x + y]]

为了回答 Samsdram 的问题，下面的代码（也来自 Chris）给出了 Mathematica 表达式的评估树。 Here is the post from MathGroup with source code and examples.

(Attributes@# = {HoldAllComplete}) & /@ {traceToTreeAux, toVertex, 
  HoldFormComplete, getAtoms, getAtomsAux}
MakeBoxes[HoldFormComplete[args___], form_] := 
 MakeBoxes[HoldForm[args], form]
edge[{head1_, pos1_, xpr1_}, {head2_, pos2_, xpr2_}] := 
 Quiet[Rule[{head1, vertexNumberFunction@pos1, xpr1}, {head2, 
    vertexNumberFunction@pos2, xpr2}], {Rule::"rhs"}]
getAtomsAux[atom_ /; AtomQ@Unevaluated@atom] := 
 Sow[HoldFormComplete@atom, getAtomsAux]
getAtomsAux[xpr_] := Map[getAtomsAux, Unevaluated@xpr, Heads -> True]
getAtoms[xpr_] := Flatten@Reap[getAtomsAux@xpr][[2]]
toVertex[traceToTreeAux[HoldForm[heldXpr_], pos_]] := toVertex[heldXpr]
toVertex[traceToTreeAux[HoldForm[heldXprs___], pos_]] := 
 toVertex@traceToTreeAux[Sequence[], pos]
(*this code is strong enough to not need the ToString commands,but \
some of the resulting graph vertices give trouble to the graphing \
routines*)
toVertex[
  traceToTreeAux[xpr_, pos_]] := {ToString[
   Short@Extract[Unevaluated@xpr, 0, HoldFormComplete], StandardForm],
   pos, ToString[Short@First@originalTraceExtract@{pos}, StandardForm]}
traceToTreeAux[xpr_ /; AtomQ@Unevaluated@xpr, ___] := Sequence[]
traceToTreeAux[_HoldForm, ___] := Sequence[]
traceToTreeAux[xpr_, pos_] := 
 With[{lhs = toVertex@traceToTreeAux[xpr, pos], 
   args = HoldComplete @@ Unevaluated@xpr}, 
  Identity[Sequence][
   ReleaseHold[
    Function[Null, edge[lhs, toVertex@#], HoldAllComplete] /@ args], 
   ReleaseHold@args]]
traceToTree[xpr_] := 
 Block[{vertexNumber = -1, vertexNumberFunction, 
   originalTraceExtract}, 
  vertexNumberFunction[arg_] := 
   vertexNumberFunction[arg] = ++vertexNumber; 
  originalTraceExtract[pos_] := 
   Extract[Unevaluated@xpr, pos, HoldFormComplete]; {MapIndexed[
    traceToTreeAux, Unevaluated@xpr, {0, Infinity}]}]
TraceTreeFormPlot[trace_, opts___] := 
  Block[{$traceExpressionToTree = True}, 
   Through@{Unprotect, Update}@SparseArray`ExpressionToTree; 
   SparseArray`ExpressionToTree[trace, Infinity] = traceToTree@trace; 
   With[{result = ToExpression@ToBoxes@TreeForm[trace, opts]}, 
    Through@{Unprotect, Update}@SparseArray`ExpressionToTree; 
    SparseArray`ExpressionToTree[trace, Infinity] =.; 
    Through@{Update, Protect, Update}@SparseArray`ExpressionToTree; 
    result]];

TraceTreeFormPlot[Trace[Tan[x] + Sin[x] - 2*3 - 55]]

Answer 5

也许我们一直在想这个。如果我们只是稍微调整一下参数的模式匹配会怎么样。例如，如果我们修改函数以检查数字数量并添加一些代码以在失败时打印错误。例如，

 TypeNumeric[x_] :=   If[! NumericQ[Evaluate[x]],
 Print["error at "]; Print[Stack[]];    Print["Expression "]; Print[x];    Print["Did   
 not return a numeric value"];Return[False], 
 (*Else*)
 Return[True];] 
 SetAttributes[TypeNumeric, HoldAll];

第 2 步：如果你有一个函数 f[x_] 需要一个数字量，只需用标准模式测试编写它就可以了

Input:
f[x_?TypeNumeric] := Sqrt[x]
f[Log[y]]
f[Log[5]]
Output:
error at 
{f}
Expression 
Log[y]
Did not return a numeric value
f[Log[y]]

Sqrt[Log[5]]

我相信这会起作用，并且它使健壮的类型检查变得像编写一两个函数一样简单。问题是这可能非常低效，因为此代码对表达式 x 求值两次，一次用于类型检查，一次用于真实。如果涉及昂贵的函数调用，这可能会很糟糕。

我还没有想出解决第二个问题的方法，并欢迎在这方面提出建议。延续是解决这个问题的方法吗？

希望这会有所帮助。