Настройка диагностических сообщений об ошибках в крупных проектах Mathematica

Ответ 1

YAsI - Еще одна (глупая?) идея...

Перечитайте свой вопрос...

<я > Тогда идея состоит в том, чтобы отключить все сообщения об ошибках Mathematica и внедрить проверки типов и сообщения об ошибках в каждой функции и модуле.

Найдено следующее:

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

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

[email protected][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

заключение... Прерывает первое сообщение и оставляет "разумную" трассировку стека. "Разумный" означает "Должен быть улучшен".

Но это совершенно неинтрузивно!

Ответ 2

Чтобы заставить мяч прокатиться здесь, есть одна идея, с которой я играл; создание псевдоэтажа.

Сначала создайте глобальную переменную theStack={}, а затем в каждом Function или Module начните с AppendTo[theStack,"thisFuncName"] и закончите с [email protected]. Предполагая умеренную (~ несколько десятков) глубину вызовов функций, это не должно создавать значительных накладных расходов.

Затем выполните свою собственную проверку ввода/ошибки и используйте [email protected];Abort[]; для ошибок.

Уточнения этого метода могут включать:

• Выясните способ динамического получения этого "thisFuncionName", чтобы AppendTo[] можно было превратить в идентичный вызов функции для всех Functions и Module.
• Использование Message[] Вместо Print[].
• Нажатие других важных переменных/информации о состоянии на theStack.

Ответ 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->", [email protected]}]; 
         [email protected][a]; Abort[]];
        theStack = [email protected];
        Return[ss])
      ]]};
v[x_, y_]\[CircleMinus]  ([email protected] 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

Ответ 4

Предложение об извлечении стека, возможно, что-то, что полагается на Trace?

Пример использования Trace ниже, от Chris Chiasson. Этот код сохраняет дерево оценки 1 + Sin [x + y] + Tan [x + y] в ~/temp/msgStream.m

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

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

Чтобы ответить на вопрос Samsdram, приведенный ниже код (также от Криса) дает дерево оценки выражения Mathematica. Вот сообщение из MathGroup с исходным кодом и примерами.

([email protected]# = {HoldAllComplete}) & /@ {traceToTreeAux, toVertex, 
  HoldFormComplete, getAtoms, getAtomsAux}
MakeBoxes[HoldFormComplete[args___], form_] := 
 MakeBoxes[HoldForm[args], form]
edge[{head1_, pos1_, xpr1_}, {head2_, pos2_, xpr2_}] := 
 Quiet[Rule[{head1, [email protected], xpr1}, {head2, 
    [email protected], xpr2}], {Rule::"rhs"}]
getAtomsAux[atom_ /; [email protected]@atom] := 
 Sow[[email protected], getAtomsAux]
getAtomsAux[xpr_] := Map[getAtomsAux, [email protected], Heads -> True]
getAtoms[xpr_] := [email protected][[email protected]][[2]]
toVertex[traceToTreeAux[HoldForm[heldXpr_], pos_]] := toVertex[heldXpr]
toVertex[traceToTreeAux[HoldForm[heldXprs___], pos_]] := 
 [email protected][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[
   [email protected][[email protected], 0, HoldFormComplete], StandardForm],
   pos, ToString[[email protected]@[email protected]{pos}, StandardForm]}
traceToTreeAux[xpr_ /; [email protected]@xpr, ___] := Sequence[]
traceToTreeAux[_HoldForm, ___] := Sequence[]
traceToTreeAux[xpr_, pos_] := 
 With[{lhs = [email protected][xpr, pos], 
   args = HoldComplete @@ [email protected]}, 
  Identity[Sequence][
   ReleaseHold[
    Function[Null, edge[lhs, [email protected]#], HoldAllComplete] /@ args], 
   [email protected]]]
traceToTree[xpr_] := 
 Block[{vertexNumber = -1, vertexNumberFunction, 
   originalTraceExtract}, 
  vertexNumberFunction[arg_] := 
   vertexNumberFunction[arg] = ++vertexNumber; 
  originalTraceExtract[pos_] := 
   Extract[[email protected], pos, HoldFormComplete]; {MapIndexed[
    traceToTreeAux, [email protected], {0, Infinity}]}]
TraceTreeFormPlot[trace_, opts___] := 
  Block[{$traceExpressionToTree = True}, 
   [email protected]{Unprotect, Update}@SparseArray`ExpressionToTree; 
   SparseArray`ExpressionToTree[trace, Infinity] = [email protected]; 
   With[{result = [email protected]@TreeForm[trace, opts]}, 
    [email protected]{Unprotect, Update}@SparseArray`ExpressionToTree; 
    SparseArray`ExpressionToTree[trace, Infinity] =.; 
    [email protected]{Update, Protect, Update}@SparseArray`ExpressionToTree; 
    result]];

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

Ответ 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 дважды, один раз для проверки типа и один раз для реального. Это может быть плохо, если задействован дорогой вызов функции.

Я не понял путь вокруг этой второй проблемы и приветствовал бы предложения на этом фронте. Есть ли продолжение выхода из этой проблемы?

Надеюсь, что это поможет.