DumpSave for the forgetful

Question

A few weeks ago I created a big matrix, and in order not to have to recreate it, I stored it using DumpSave["file.mx", variable]. Now I want to read it back in and so I use <<file.mx. It appears to work fine and to load the file (which takes a few moments because it is 54 MB in size). Now the problem: I have forgotten what I called the matrix, that is, what name variable I used in when I saved it. My generating command is unfortunately not around any more. Is there any way of figuring out what my variable was called or more directly, how to access my data now that it is loaded?

Answer 1

I think you can use Names["Global`*"] to get the name:

a = RandomReal[{0, 1}, 10];
SetDirectory[$TemporaryDirectory];
DumpSave["1.mx", a];

Quit[]

SetDirectory[$TemporaryDirectory];
<< 1.mx
Names["Global`*"]

(*{"a"}*)

Answer 2

If you use Import/Export to load/save .mx files, instead of DumpSave, then the variable does not get embedded in the file, and you can assign it to any variable of choice in the new session.

x = RandomReal[1, {100, 100}];
Export["~/tmp.mx", x];
y = Import["~/tmp.mx"];
x == y
(* True *)

Answer 3

Method 1: Enable messages for new symbols and load MX file

The following code will load MX file and show a General::newsym message for each newly created symbol.

On[General::newsym]; (* enable message for each new symbol *)
Off[General::stop];  (* prevent stop after 3 messages *)
Get["file.mx"];      (* load MX file *)
On[General::stop];
Off[General::newsym];

Advantage: This method shows new symbols in all contexts, not only in Global. This is useful if you don't know the context of the variables stored in the MX file.

Disadvantage: Only newly created symbols will be reported. If a symbol is already defined in your current Mathematica session and MX file updates/redefines this symbol, then no message will be shown.

Method 2: Load MX file and save new symbols into a List

If you want to save the names of newly created symbols into a list, you can use the $NewSymbol handler. The following function (based on this post by @Leonid Shifrin) will load an MX file and return a list of newly created symbols including their contexts:

newSymbols[mxfile_] := Module[
    {tag},
    Block[
        {$NewSymbol=Sow[#2<>#1, tag]&},
        Reap[Get[mxfile],tag][[2]]
        ]
    ]

This method has the same advantages and disadvantages as Method 1.

Method 3: Use auxiliary kernel to inspect the contents of MX file

This method will be helpful if you want to know which symbols are defined by MX symbols, but don't want to load MX file into your current session.

You can start a fresh auxiliary kernel, load MX file there, save a list of newly created symbols, and quit auxiliary kernel.

This algorithm can also be automated:

(* newKernelEvaluate starts a fresh auxiliary kernel, evaluates expr, *)
(* quits auxiliary kernel, and returns the result of evaluation. *)
ClearAll[newKernelEvaluate];
Attributes[newKernelEvaluate] = HoldAll;
newKernelEvaluate[expr_] := Module[
    {link, result},
    link = LinkLaunch[First@$CommandLine <> " -mathlink -noprompt"];
    LinkWrite[link, Unevaluated@EvaluatePacket@expr];
    result = LinkRead@link;
    LinkClose@link;
    Replace[result, ReturnPacket@x_ :> x]
    ];

ClearAll[getSymbolsDefinedInMX];
getSymbolsDefinedInMX[mxfile_] := Module[
    {tag},
    With[{mymxfile=mxfile},
        newKernelEvaluate[
            Block[
                {$NewSymbol=Sow[#2<>#1, tag]&},
                Reap[Get[mymxfile],tag][[2]]
                ]
            ]
        ]
    ];

You can now run getSymbolsDefinedInMX["file.mx"] to get a list of symbols defined in this MX, without actually loading any symbols in the current session.

This method will detect almost all symbols defined by MX. Only redefinitions of built-in symbols will not be detected.

Note

If you spot System`Private`ConvertersPrivateDumpSymbol among the symbols which are created by your MX file, then this MX file was created using Export["file.mx", someExpression] (see the answer of R.M. above). In this case you can just use someVariable = Import["file.mx"].