BTW, the first two posts where I just repeat your last post were not posted by me.. I think. I just posted the last one and was close to taking a video of me submitting my post and getting reposts of yours out of it.

Perhaps the moderation team could delete the last two re-posts of Sanders post. They were not intended, and I have no idea how they got there.

Cheers,

Marco

Have you read:

https://reference.wolfram.com/language/tutorial/ControllingThePrecisionOfResults.html

? Notice the phrase:

"But within this constraint you can tell the Wolfram Language how 
much precision and accuracy you want it to try to get."

In order to attain a certain precision/accuracy you need a certain workingprecision and a good algorithm to 'home in' to the correct solution. So two things are possible:

Chose an algorithm explicitly which improves the way it 'homes in' to a good solution. A crappy integration scheme limits the possible accuracy/precision one can get when given a certain working precision. By default it accuracy/precision goal to be half the digits of the workingprecision. If accuracy/precision goals becomes closer to workingprecision you need smarter and smarter integration schemes in order to get the correct result. It is sometimes much faster 'just' increasing the workingprecision, and set no goals (defaults) rather than trying different algorithms/integration schemes and stepsizes and so on...

Hi everyone,

It appears that there is no issue with the analytical solution here, right? (I might have overhead something, because I could not read all posts, as I am on a mobile phone.)

sol = DSolveValue[{y''[x] - (s + x)*y[x] == 0, y'[0] == -1, y[M] == 0}, y[x], x]
(*(-AiryAi[s + x] AiryBi[M + s] + AiryAi[M + s] AiryBi[s + x])/(AiryAiPrime[s] AiryBi[M + s] - AiryAi[M + s] AiryBiPrime[s])*)

Then we can calculate

limit=Limit[sol, M -> Infinity]

It seems to be ok-ish, from what I can see now:

D[limit, x, x] - (s + x)*limit == 0 

evaluates to True.

D[limit, x] /. x -> 0

gives -1; and

Limit[limit, x -> Infinity]

gives 0. From that we can generate very high precision results, of course.

But as the OP says, in the case they are interested in there is no analytical solution. So in order to suggest anything it would be useful to get the actual problem.

By the way, the example:

sol=NDSolve[{u''[x]-(s+x)*u[x]==0,u'[0]+1==0,u[L]==0},u[x],{x,0,L},WorkingPrecision->50,PrecisionGoal->32];

fails to run on my MMA11.0.0 on OSX 10.11.6, but it does run on MMA 10.4.1. I also get an error message that the maximum number of steps is reached before obtaining the requested precision, but that can be changed by adding something like this:

post = NDSolveValue[{u''[x] - (s + x)*u[x] == 0, u'[0] + 1 == 0, u[L] == 0}, u[x], {x, 0, L}, WorkingPrecision -> 50, PrecisionGoal -> 32, MaxSteps -> 10^6]

which does finish after quite some while. No joy on MMA11. There are several reasons why I think that your way of checking the precision is not quite ideal, but this is what I get using your approach:

rerror = u0/u0acc - 1

gives $7.1796\cdot 10^{-27}$. Not quite what you want though.

Finally, if you use

solpost = 
 NDSolveValue[{u''[x] - (s + x)*u[x] == 0, u'[0] + 1 == 0, u[L] == 0},u[x], {x, 0, L}, WorkingPrecision -> 56, PrecisionGoal -> 39, 
  MaxSteps -> 10^6, InterpolationOrder -> All, Method -> "StiffnessSwitching" ]

your test gives basically what you might expect $3.335\cdot10^{-32}$. You can play a bit with the parameters to improve on this.

And this here

solpost = 
 NDSolveValue[{u''[x] - (s + x)*u[x] == 0, u'[0] + 1 == 0, u[L] == 0},u[x], {x, 0, L}, WorkingPrecision -> 60, PrecisionGoal -> 45, 
  MaxSteps -> 10^7, InterpolationOrder -> All, Method -> "StiffnessSwitching" ]

gives $1.1*10^{-34}$ for your "rerror".

Cheers,

Marco

Hi Sander,

yes, I had that clear. The point is that the first approach might be to crank up the Accuracy/Precision and hope that it'll work. But it did not. Needs e.g. explicit method for integration etc.

Cheers,

Marco

If I run your code as-is:

uanal[x_, s_, b_] = -(AiryAi[s + x]*AiryBi[s + b] -  AiryAi[s + b]*AiryBi[s + x])/(AiryAiPrime[s]*AiryBi[s + b] - AiryAi[s + b]*AiryBiPrime[s]);

s = 2;
L = 10;
ndigits = 32;
sol = NDSolve[{u''[x] - (s + x)*u[x] == 0, u'[0] + 1 == 0, u[L] == 0}, u[x], {x, 0, L}, WorkingPrecision -> 50, PrecisionGoal -> 30];
uappr[x_] = First[u[x] /. sol];
u0 = N[uappr[0], ndigits]
u0acc = N[uanal[0, s, L], ndigits]
rerror = u0/u0acc - 1

I get:

-2.06657*10^-26

Using version 10.4.1 or version 11 same result.

If you want more steps you can set MaxSteps option. Look at the documentation! This is all quite trivial if you just spend a few minutes reading and observe the examples.

Hi Sander,

I find it a bit worrying that that code works on your machine but not on mine; doesn't work on MMA11.

Cheers,

M.

10.4.1 works fine.

Performed clean start on MMA11; still the same. Will investigate further.

M.

I don't know u0acc so I don't know what is the correct solution. But:

s = 10; L = 10; sol = 
 NDSolve[{u''[x] - (s + x)*u[x] == 0, u'[0] + 1 == 0, u[L] == 0}, u, {x, 0, L}, WorkingPrecision -> 50];
sol = u /. First[sol];
sol[0]

works just fine, without any error:

0.31379386687943471460767057577019210318851451370584

Without an example and the code you tried no one will be able to help you effectively, post your code, and your analysis of the n = 2--5.