Skip to main content

debugging - How to find out where an error occurs?


I got this error when using Mathematica:



Part::partw: "Part 5 of {{0.637537,0.362463},{0.00038282,0.999617},

{0.0928437,0.907156},{0.0000222833,0.999978}} does not exist."

I know why it is generated, but the problem is my code is so lengthy and I cannot find where it comes from. Is there any syntax in Mathematica by which I can resolve my problem? Thanks.



Answer



Implementation


Here is a better version of my debug function posted here, which would print the stack on the first message generated, and abort the computation. I have used it extensively with great effect in many cases.


This constructs the nested OpenerView from an arbitrary expression:


ClearAll[openerDress];
SetAttributes[openerDress, HoldAll];
openerDress[f_[args___]]:=

  OpenerView[{
    HoldForm[f],
    HoldForm[f]@@Map[openerDress,Unevaluated[{args}]]
  }];
openerDress[x_]:=HoldForm[x];

This uses openerDress to represent stack of execution in a way that is expandable when clicked:


ClearAll[stackPrettify];
stackPrettify[stack : {__HoldForm}] :=
  Column @ {

    Replace[stack, HoldForm[f_[x___]] :> openerDress[f[x]], 1],
    Style[Map[Short, Last[stack], {2}], Red]
  };
stackPrettify[___] := Null;

This is a generator of dynamic environments with redefined functions, encapsulating the Villegas - Gayley technique:


ClearAll[withRedefined];
withRedefined[f_Symbol, extraCondition_, beforeF_, afterF_]:=
  Function[
    code

    ,
    Internal`InheritedBlock[{f},
      Module[{inF, dv = DownValues[f]},
        Unprotect[f];
        DownValues[f]={};
        (call:f[args___]) /; extraCondition[args] && !TrueQ[inF]:=
          Block[{inF = True},
            beforeF[args];
            call;
            afterF[args]

          ];
        DownValues[f] = Join[DownValues[f],dv];
        Protect[f];
      ];
      code
    ]
    ,
    HoldAll
  ];


A couple more of the helper functions:


ClearAll[printStack];
printStack[start_, end_]:=Print[stackPrettify[Take[Stack[_], {start, end}]]];

ClearAll[heldF];
SetAttributes[heldF,  HoldAll];
heldF[body_]:=Function[Null, body, HoldAll];

Finally, this is the actual debugging utility (some formatting imperfections are due to the SE markdown bug regarding the display of symbols containing $):


ClearAll[debug];                        

debug[debugSymbol_Symbol:Message, failConditionFunction_:heldF[True]]:=
  Function[
    code
    ,
    Module[{tag},
      withRedefined[
        debugSymbol,
        heldF[!MatchQ[First[Hold[##]],_$Off]],
        heldF[If[failConditionFunction[##],printStack[6, -9]]],
        heldF[If[failConditionFunction[##], Throw[$Failed,tag]]]

      ][Catch[StackComplete[code],tag]]
    ]
    ,
    HoldAll
  ];

Tests


There are several ways one can use debug. The default one is that it breaks on first Message generated, and prints for you the stack. For example, one may try something like


debug[] @ Sin[Range[10][[1 ;; 15]]]


If you have an access to the source code which you want to debug, and can modify it, you could also use it in the following way:


ClearAll[$debugWrapper]
$debugWrapper[arg_] := arg;

and


debug[$debugWrapper][
  Sin[Part[Range[10], $debugWrapper[ 1 ;; 15]]]
]

In other words, you can wrap a piece of code where you suspect a problem, in some wrapper like $debugWrapper, and then extract the execution stack. You can also set a condition on the first event you want to trigger. For example, the following will only trigger the second event wrapped in $debugWrapper:



debug[
  $debugWrapper, 
  Function[arg, MatchQ[Unevaluated[arg], _Span], HoldAll]
][
   Sin[$debugWrapper@Part[Range[10], 1 ;; 15]];
   Sin[Part[Range[10], $debugWrapper[ 1 ;; 15]]]
]

in which case, only the second event wrapped in $debugWrapper, will be triggered.


Comments

Post a Comment

Popular posts from this blog

mathematical optimization - Minimizing using indices, error: Part::pkspec1: The expression cannot be used as a part specification

I want to use Minimize where the variables to minimize are indices pointing into an array. Here a MWE that hopefully shows what my problem is. vars = u@# & /@ Range[3]; cons = Flatten@ { Table[(u[j] != #) & /@ vars[[j + 1 ;; -1]], {j, 1, 3 - 1}], 1 vec1 = {1, 2, 3}; vec2 = {1, 2, 3}; Minimize[{Total@((vec1[[#]] - vec2[[u[#]]])^2 & /@ Range[1, 3]), cons}, vars, Integers] The error I get: Part::pkspec1: The expression u[1] cannot be used as a part specification. >> Answer Ok, it seems that one can get around Mathematica trying to evaluate vec2[[u[1]]] too early by using the function Indexed[vec2,u[1]] . The working MWE would then look like the following: vars = u@# & /@ Range[3]; cons = Flatten@{ Table[(u[j] != #) & /@ vars[[j + 1 ;; -1]], {j, 1, 3 - 1}], 1 vec1 = {1, 2, 3}; vec2 = {1, 2, 3}; NMinimize[ {Total@((vec1[[#]] - Indexed[vec2, u[#]])^2 & /@ R...
Post a Comment
Read more

functions - Get leading series expansion term?

Given a function f[x] , I would like to have a function leadingSeries that returns just the leading term in the series around x=0 . For example: leadingSeries[(1/x + 2)/(4 + 1/x^2 + x)] x and leadingSeries[(1/x + 2 + (1 - 1/x^3)/4)/(4 + x)] -(1/(16 x^3)) Is there such a function in Mathematica? Or maybe one can implement it efficiently? EDIT I finally went with the following implementation, based on Carl Woll 's answer: lds[ex_,x_]:=( (ex/.x->(x+O[x]^2))/.SeriesData[U_,Z_,L_List,Mi_,Ma_,De_]:>SeriesData[U,Z,{L[[1]]},Mi,Mi+1,De]//Quiet//Normal) The advantage is, that this one also properly works with functions whose leading term is a constant: lds[Exp[x],x] 1 Answer Update 1 Updated to eliminate SeriesData and to not return additional terms Perhaps you could use: leadingSeries[expr_, x_] := Normal[expr /. x->(x+O[x]^2) /. a_List :> Take[a, 1]] Then for your examples: leadingSeries[(1/x + 2)/(4 + 1/x^2 + x), x] leadingSeries[Exp[x], x] leadingSeries[(1/x + 2 + (1 - 1/x...
Post a Comment
Read more

What is and isn't a valid variable specification for Manipulate?

I have an expression whose terms have arguments (representing subscripts), like this: myExpr = A[0] + V[1,T] I would like to put it inside a Manipulate to see its value as I move around the parameters. (The goal is eventually to plot it wrt one of the variables inside.) However, Mathematica complains when I set V[1,T] as a manipulated variable: Manipulate[Evaluate[myExpr], {A[0], 0, 1}, {V[1, T], 0, 1}] (*Manipulate::vsform: Manipulate argument {V[1,T],0,1} does not have the correct form for a variable specification. >> *) As a workaround, if I get rid of the symbol T inside the argument, it works fine: Manipulate[ Evaluate[myExpr /. T -> 15], {A[0], 0, 1}, {V[1, 15], 0, 1}] Why this behavior? Can anyone point me to the documentation that says what counts as a valid variable? And is there a way to get Manpiulate to accept an expression with a symbolic argument as a variable? Investigations I've done so far: I tried using variableQ from this answer , but it says V[1...
Post a Comment
Read more