The simplest is to use .MX or .WDX formats that store arbitrary Wolfram Language expressions. But MX files cannot be exchanged between operating systems that differ in $SystemWordLength. And MX files created by newer versions of the Wolfram System may not be usable by older

ysol = NDSolveValue[{y'[x] == y[x] Cos[x + y[x]], y[0] == 1}, y, {x, 0, 30}];
Export["ysol.wdx", ysol];
impysol = Import["ysol.wdx"];
Plot[impysol[x], {x, 0, 30}, PlotRange -> All]

We can use .txt as well

L = 50;
usol = NDSolve[{I D[u[t, x], t] + D[u[t, x], x, x] + 
     2 Abs[u[t, x]]^2 u[t, x] == 0.1 (1 - Cos[Pi x/L]), 
   u[0, x] == Sech[x] Exp[I x], u[t, -L] == u[t, L]}, 
  u, {t, 0, 1}, {x, -L, L}]
usolE = First[u /. usol]
Export["C:\\Users\\...\\Desktop\\Schrodinger.txt", \
usolE]
Usol = ToExpression[
  Import["C:\\Users\\...\\Desktop\\Schrodinger.txt"]]
In[16]:= Head[Usol]

Out[16]= InterpolatingFunction
{Plot3D[Abs[usolE[t, x]], {t, 0, 1}, {x, -L, L}, PlotRange -> All, 
  ColorFunction -> Hue, Mesh -> None, PlotPoints -> 50], 
 Plot3D[Abs[Usol[t, x]], {t, 0, 1}, {x, -L, L}, PlotRange -> All, 
  ColorFunction -> Hue, Mesh -> None, PlotPoints -> 50]}

Perfect, I tried Vitaliy's approach and it works. Thanks you all.

Does anyone of you ever had bad experience with the interpolation function generated by NDsolve?

Here is my problem: I have solved the Nonlinear Schrödinger Equation in a more complicated form to analyse ultrafast third harmonic generation in waveguides. The issue is that I have to use a very fine mesh to get the solution, i.e., to get a result which does not show the error message "NDSolve::eerr: Warning: scaled local spatial error estimate of...". The final interpolation function has 6001 steps in spatial and 750 steps in time domain (according to the function shown by Alexander's code) and is extremely slow. The interpolation function is actually so slow that I cannot process the function properly (e.g, to do a numerical FFT). I have no idea how to improve that, i.e., how to make the interpolation function faster.

Is there any trick that speed up the interpolation function (maybe by some option in NDsolve)?

Any help is greatly appreciated.

If anyone has an idea I can provide some code.

M

Your latter question is interesting (... well, the first as well of course)! Might it be that this is a case for a meaningful application of FunctionInterpolation? - I have never unterstood for what else this function could be useful. What I have in mind is simply like:

easyToEvaluateFunction = FunctionInterpolation[hardToEvaluateFunction[x], {x, x0, x1}];

Or am I completely wrong?

It's possible to look at the code?

To Michaels point above, I would try using Table to create a 2x2 grid of points, time it, do the FFT on the list of points and see if it is the interpolation that is slowing everything down (and you can control the number of points used this way).

I have tried all the things being suggested, and in the end I create a new 2D matrix (i.e., table) that contains the result of NDsolve at discrete points using the interpolation function (goes along the lines of Neil's suggestion). This is saved and interpolated again and this gives a sufficiently fast response. Thank you all for your suggestions.

What I found out is that if an interpolation function is called from inside a module requires a much longer time than if the same interpolation function is called outside the module. Does anyone has experienced this kind of thing and if yes, how can this be solved?

Best,

M