Please check your boundary condition D(f)(0) = lambda + xi*(D^2)(f)(0). Note that if you wanted the second derivative and not the square of the first derivative, then you need D(f)(0) = lambda + xi*(D@@2)(f)(0)

@NeraSnow Your procedure to upload the worksheet was correct, but the website is not working correctly today, as happens sometimes.

@Carl Love Yes, I tried something like this expecting the new inline loops might be more efficient, but was disappointed (as I've found a couple of times before).

There is also the issue of counts>9, which I missed originally. So "1111111111111" gives "131" in my code, but "11111111111111" in yours.

@sursumCorda Arrays are usually efficient, but here adding on to the end with the ,= operation is part of the secret.

@AngieS7 It means it can't find a solution. You can help it by providing ranges (or an initial guess), but it might mean there is no solution

@AngieS7 You can tell fsolve to only look for solutions in specific ranges by using something like

fsolve({eq1, eq2, eq3, eq4, eq5, eq6}, {A=0..5, B=3..7, C=0..infinity, omega=0..10, x1=0..1, x2=0..1});

@AngieS7 It is hard to tell why this hasn't worked without you uploading your worksheet. You can do that with the green up-arrow in the Mapleprimes editor.

Edit: looks like you might have changed vb:=0.5 to vb:=5

@hojat Lambda still has a 1[1] and a 2[1].

@hojat Please confirm that you are minimizing a function of 12 variables (from indets(Lambda,name) ). If so this will be an extremely difficult problem and I'm guessing it generates some complex numbers because it doesn't know enough about these values. What are the approximate values of these variables? For nonlinear problems, an initialpoint is almost certainly needed.

@ianmccr This recasting into alternate forms happens in several situations, including just printing the code of a procedure with a semicolon. Since these are often less readable, I find this frustrating but don't know of a workaround.

@sursumCorda I see there that the symmetric NAG routine is recommended over the general one because it is "more accurate", so a NAG general routine is probably not useful here (can't increase digits then) though the specialized ones may be. Maple probably has a special routine for exp (I didn't check), which is why @Axel Vogt's method works.

Detecting the non-diagonalizable case will always be difficult if Jordan forms are used, because that is a difficult computation. Eigenvectors returns a "zero eigenvector" in that case but how close to zero does it have to be to be detected? [Edit: I see Eigenvectors can just output the true eigenvectors, so has some detection method for this.] These situations, including when two numerical eigenvalues are the same, rely on some careful assessments and are tricky in general - maybe the linalg method that worked well in this case would not work so well in other cases.

However, the fact that it is so bad in quite a few cases means it needs some improvement for sure.

@tomleslie Yes, it is interesting how often this question is asked. Perhaps it should be in huge letters on the help pages for plot and plot3d.

@sursumCorda I had a closer look into how the algorithm works, and my analysis below suggests in the numerical case, close eigenvalues that should be detected as degenerate are not in LinearAlgebra:-MatrixFunction, but are in linalg:-matfunc. I have submitted an SCR.

For going beyond, the normal case is well-behaved and can be done just by applying the function to the eigenvalues in a unitary decomposition (Horn and Johnson, Theorem 6.2.37). So for numerical matrices with shape=symmetric or shape=hermitian (or the skew versions), that would be a separate case worth doing.

Download MatrixFunctionAlgorithm.mw

@ishan_ae I'm guessing that you didn't add two unevaluation quotes around the add: '' add '' (these are two ' not one "). This is an endless problem in Maple. One way to solve not knowing how many is just to have one in the definition, and then add a "numeric" option, which effectively tells animate not to bother unless a number is provided. The output of the fourier_f definition is now ugly.

fourier_analysis_numeric.mw

Or you can use Sum, but then you need value:

fourier_analysis_Sum.mw

@ishan_ae

I changed to assume n is a positive integer, then the sin(n*Pi) and cos(n*Pi) can be simplified. assume(N>0) has no effect since the N within the fourier_f is not the same as the one outside.

The delayed evaluation quotes around 'add' are because at the time the fourier_f definition is evaluated, the value of N is not known. This prevents add from generating an error because N does not yet have a value. In the animated one, I have needed to do this twice.

display is in the plots package so needs to be plots:-display (or use with(plots): at the start of the worksheet).

If you use sum instead of add, it tries to work out the general formula every time sum in encountered, which slows it down significantly.

Here it is working.

Download fourier_analysis.mw