32
Short answer
The local variables of the form varname$... are used by the system, and it is unwise to use symbols with such names as local variables.
With, like many other lexical scoping constructs, performs excessive renamings, often even in cases where it isn't strictly necessary. This probably has to do with efficiency - full analysis may be more costly.
...
31
You can select which kernel is used by your notebook from the menu item Evaluation -> Notebook's Kernel. By default you will probably only have one kernel called Local available. If your Mathematica license allows for it (typically licenses allow for two simultaneous kernels on a machine), you can add new kernels by selecting the Evaluation -> Kernel ...
29
What was saved was the content of sol, which happens to contain the solution to your equation (you explicitly set it to that), and therefore is certainly sufficient for your plot.
Saving Kernel state however would involve saving things like the random seed, so the following would give the same output twice (using a hypothetical function SaveKernelState and ...
29
There is an easy way to keep your data in the notebook itself and NOT to save them in external file - using Compress. As @Leonid says here and I already mentioned this before in this answer for similar case with Interpolation function. Start from some output you need:
sol = NDSolve[{D[u[t, x], t] == D[u[t, x], x, x], u[0, x] == 0,
u[t, 0] == Sin[t], u[t,...
29
You should consider using the sandbox functionality. You can create a subkernel and put it in sandbox mode this way:
link = LinkLaunch[First[$CommandLine]<> " -wstp -noicon"];
LinkWrite[link, Unevaluated@EvaluatePacket[Developer`StartProtectedMode[]]];
You can then interact with this subkernel using the standard LinkWrite and LinkRead functions. If ...
27
There are two processes running. The first process is the FrontEnd. The FrontEnd receives your keypresses and renders text and plots. The second process is the Kernel. The Kernel receives commands to perform calculations, stores the states of variables, and does pretty much all the calculating.
When you press Alt-., the FrontEnd immediately receives ...
26
Since one may not always accurately predict when MemoryContrained is needed, I recommend setting up a watch-dog task. Belisarius described how to do this here in answer to my question. I will reproduce it below as answers that are merely links are discouraged.
In Mathematica 8 you could start a memory watchdog, something along
the lines of:
...
25
As people have figured out in the comments, this was a quite deliberate decision on our part. One which I can take a significant amount of credit/responsibility/blame for.
First a little bit about the extra kernel. The kernel is enabled using a password which causes it to run in Wolfram Player mode. It runs using the same binary as the regular kernel, ...
21
To access the errors, you need to invoke the Front End directly from the kernel. In effect, you end up telling the kernel to tell the FE to tell the kernel to do something, so that the FE can report any errors it finds. The method I use is
ClearAll[getFrontEndErrors];
SetAttributes[getFrontEndErrors, HoldAllComplete];
getFrontEndErrors[expr_] :=
Block[{...
20
Here is the method I outlined. I'll illustrate on a small example where we split matrix into top and bottom halves.
In[794]:= SeedRandom[1111];
halfsize = 3;
mat = RandomInteger[{-4, 4}, {2*halfsize, 10}]
Out[796]= {{-3, -1, 3, -3, 3, 3, 3, 3, 4, 2}, {3, 3, -3, 0, 0,
1, -2, -4, 0, -1}, {-3, 4, 3, 0, -2, 4, 3, -2, -2, -2}, {2, 2, 4,
0, -4, 4, -1, -4, ...
20
You could launch a different kernel and use that to run the computation. You will be controlling this "slave kernel" from another Mathematica session. This will allow you to script even quitting and restarting the slave kernel.
Using parallel tools
This is simpler and I recommend trying this approach first.
Launch a single kernel:
kernel = ...
19
The option to save a variable, a value, in a notebook, that I find simple and deserves a chance is to store them in the notebook's tagging rules. You can compress it if you want, or you can autoload it through an initialization cell or through the NotebookDynamicExpression too.
The core is this:
r = RandomReal[{-1, 1}, 1000000];
CurrentValue[InputNotebook[]...
19
You need to daemonize your script:
nohup math -script test.txt 0<&- &>/dev/null &
Now this will run as a background process with no output captured. If your script does indeed produce output, just replace /dev/null with the filename.
In order to daemonize something you need to disconnect all the
automatically connected streams (stdin, ...
16
This can be relatively easily done using extremely useful $FrontEnd option "ClearEvaluationQueueOnKernelQuit" introduced by Chris Degnen.
Usage
Print @ $SessionID
quitAndEvaluate[
Print @ $SessionID
]
25183094379509806957
25183094575602627552
quitAndEvaluate[] will restart kernel without aby additional tasks. It may be useful if you want to ...
16
I have been solving exactly the same problem about 2 years ago (http://community.wolfram.com/groups/-/m/t/125587?p_p_auth=aZGMz5bs). Students are uploading piece of Mathematica (Wolfram Language) code which is run by a testing script (in Mathematica) and the results are compared with a reference solution.
To prevent the students to run potentially dangerous ...
16
The kernel crashes due to stack overflow. It is not safe to recurse too deeply. Increasing $RecursionLimit to values that are too great (and actually recursing that deep) risks a crash.
(So yes, in a way it's due to insufficient memory, but it has nothing to do with memoization. It is due to insufficient stack space.)
From the documentation:
On most ...
15
Does running Quit[] do what you want?
15
In addition to Mr.Wizard's answer.
In many cases it is very practical to stop the evaluation when the actual amount of free physical memory in your system becomes less than specified threshold. You can get the amount of free physical memory very efficiently via NETLink call to GlobalMemoryStatusEx function of kernel32.dll (which is available both under 32 ...
15
In addition to assigning to In, the Mathematica main loop assigns the input to InString before it is parsed as an expression. You can then retrieve InString[1] and parse the result with ToExpression, wrapping it in Defer to prevent it from evaluating immediately:
In[5]:= ToExpression[InString[1], StandardForm, Defer]
Out[5]= Round[SessionTime[]]
You can ...
15
There is a setting in Mathematica that controls whether it can access the internet. Go to Preferences -> Internet Connectivity and uncheck "Allow the Wolfram System to access the Internet". Disabling this will disable some features that depend on internet access, such as Wolfram|Alpha queries.
This setting can also be controlled by the $AllowInternet ...
15
One approach would be to run the evaluation in a second kernel which is controlled from a main kernel through MathLink/WSTP. Then your main kernel can detect if the MathLink connection dies.
You can implement this manually (a lot of work), or you can try to do it using the parallel computing tools, where much of the groundwork is already laid down.
In ...
14
You can use GNU screen to make a sort of persistent terminal that allows you to resume work wherever you left off. Take a look at the many tutorials available.
It's not completely clear from your question whether the better solution is this, or nohup (see Stefan's answer).
Use nohup if your workflow is non-interactive: log in, start a batch job that ...
14
After some spelunking, I found a file which contains a lot of initialization code, including reading the kernel init.m file, loading Autoload packages, loading anything set with the -initfile option, starting the paclet manager (which may autoload packages), and many other things. It is
SystemFiles/Kernel/SystemResources/$SystemID/sysinit.m
Towards the ...
14
Apparently, Throw is deactivated during kernel initialization. The following function can determine if Throw is inoperative:
throwInoperativeQ[] := CheckAll[Catch[Throw[False]], # /. Null -> True &]
The undocumented function CheckAll is used here because Check also appears to be unreliable when Throw is inoperative.
If we make the assumption that ...
13
As an alternative to DumpSave, what I've done in the past was to Compress the relevant results and store them within the same notebook. You can optionally set things up so that your data/results would self-uncompress themselves upon being called the first time. For one example of such use, see this answer.
In any case, the advantage of this approach is ...
13
Yes, the Mathematica application on Mac OS contains a few external binaries, which are mostly used for importing and exporting. These files have suffix .exe:
$ find "/Applications/Mathematica 8.app" -name '*.exe'|wc -l
49
But even though .exe is a prefix common for Windows executables, it doesn’t mean that it can’t be used for other things. In fact, Mac OS ...
13
Updated
This happens because your DynamicModule returns a dynamic object of which x is passed on to the front-end before the scheduled task starts, so the front-end-x cannot be modified anymore by any process (more details at the end).
The problem can be further simplified. This works:
RemoveScheduledTask@ScheduledTasks[];
DynamicModule[{x = 0}, ...
13
Assuming FrontEnd survives, prepare 3 cells:
(*init cell, won't be needed later*)
state = CurrentValue[EvaluationNotebook[], {"TaggingRules", "state"}] = 0;
SetOptions[ #,
{CellTags -> {"Procedure"}, ShowCellTags -> True}
]& /@ {NextCell[], NextCell @ NextCell[]};
CurrentValue[$FrontEndSession, "ClearEvaluationQueueOnKernelQuit"] = False;
...
12
You can put your calculation inside TimeConstrained. However in your case, probably the better idea is to restrict the used memory. That's done with MemoryConstrained.
If you don't want to figure out the available memory yourself, see here for how to do it automatically.
For example this terminates a calculation if the calculation needs more than 1 GB of ...
12
You can make use of either TimeConstrained or MemoryConstrained to terminate evaluation when it runs out of time or memory respectively.
For example, if you have a function that has a reasonable memory footprint, but takes time to evaluate, you can abort evaluation after a certain amount of time (in seconds) has elapsed, as:
TimeConstrained[Eigenvalues@...
Only top voted, non community-wiki answers of a minimum length are eligible
