I am having an issue where the kernel spontaneously quits, deep in a long code that I have used for quite some time without this issue. I've tracked it down to an assignment of the form:

a[[All, All, All, -1]] = b;

Where the left and right hand side are both lists of machine precision complex numbers, both of dimension {2,3,9}, and the left hand side all zeroes. So nothing crazy there, and I can also print both sides before the assignment without issues. Neither is a packed array. Some entries were real rather than complex, but adding 0. I didn't help.

The problem goes away by either of these methods (independently):

  1. use arbitrary precision instead of machine precision
  2. Modify the input so as to make some elements of the left hand side above nonzero (and it matters where)
  3. I said above neither a nor b are packed arrays, but a was constructed from a packed array, i.e. an expression containing Developer`ToPackedArray[c], and changing that to just c also fixes it.

So it seems the issue has to do with packed arrays, as 3 gets rid of that explicitly, 1 indirectly, and 2 perhaps affects whether/how/which part was converted in a packed array in the first place. Also, using On["Packing"], methods 1 and 3 get rid of unpacking warnings (occuring in construction of a, not in the line above itself.), method 2 does not.

Does this make sense? Is there an easy way to check if an expression contains rather than is a packed array? And how to avoid this? Is the rule not to use packed arrays when still assigning to parts of the expression?

  • 3
    $\begingroup$ Catch[expr /. x_?Developer`PackedArrayQ :> Throw[True]]? Not sure about the rest. Code to reproduce the problem may be needed. $\endgroup$
    – Michael E2
    Commented Nov 25, 2020 at 18:06
  • $\begingroup$ @MichaelE2 Thanks, that returns True, but when I try to find all occurrences using Cases[expr,x_?DeveloperPackedArrayQ,All], I don't get anything (nor with the option Heads->True`). Any idea why? $\endgroup$
    – Jansen
    Commented Nov 26, 2020 at 10:26
  • $\begingroup$ I noticed that. The same thing happens with FreeQ. They unpack the packed arrays before scanning for expressions that match the pattern., I suppose they do it because they check all subexpressions from bottom up (at least that’s the order in which Cases returns expressions). ReplaceAll goes top down. ``Reap[expr /. x_?DeveloperPackedArrayQ :> Sow[x]][[2,1]] might be an alternative to Cases. Plus it won’t return subarrays of packed arrays, which I surmise would be desirable. $\endgroup$
    – Michael E2
    Commented Nov 26, 2020 at 13:36
  • 2
    $\begingroup$ Could you post a MCE (minimal crashing example)? $\endgroup$ Commented Nov 26, 2020 at 16:13


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Browse other questions tagged or ask your own question.