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

Question

每当我创建一个大型 Mathematica 项目时，我都会遇到这个问题： 防止 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 和 Functions 的相同函数调用。代码>模块。
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 表达式的求值树。 这是来自 MathGroup 的帖子，其中包含源代码和示例。

(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 求值两次，一次用于类型检查，一次用于实数。如果涉及昂贵的函数调用，这可能会很糟糕。

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

希望这有帮助。