update guess in fsolve

I want to solve f(x) = 0 using x0 as a guess. I can use fsolve. Let's assume that given the guess the exit flag is not 1 (equation not solved). What would be the most straighforward way to update my initial guess?

[Walter Roberson]

It is normal for the exit flag is positive (1 through 4), unless you have set options to make most tolerances extremely small.

[Luigi]

You are right-- I was imprecise. I am concerned by pathological exit flags (instances of imaginary numbers for example, which are imcompatible with my (macroeconomic) model).

Answer 1

[Star Strider]

I am not certain what you are actually asking.

If possible (if an equation can be plotted), I usually begin by plotting iit to get an idea of its characteristics. I then use an initial estimate based on what I learn from the plot.

There are a number of apppropriate functions in the Global Optimization Toolbox (my favourite being ga) that will themselves iterate the initial guess until they find the best one. This works even if an equation cannot be plotted.

.

[Luigi]

I am considering a system of n equations in n unknowns. Sometimes given my n guesses fsolve's exit flag is not one. As of today I built a matrix of guesses for each of the n guesses and I iterate over it until I find a solution. This is quite inefficient.

Unfortunately I do not have access to the Global Optimization Toolbox.

[Star Strider]

My plotting approach will not work with n equations and n unknowns.

Genetic algorithms are not difficult to write, however writing and debugging a complete version involving crossovers and mutations can be time-consuming.

I do not understand a reason to need to update the fsolve initial guess. I would just use the optimset function to increase the number of iterations and the number of function evaluations to allow fsolve to converge to an acceptable result.

Perhaps:

opts = optimset(MaxIterations=1000, MaxFunctionEvaluations=50000);

and then pass that as the third argument to fsolve. Change those as necessary for your problem.

.

Answer 2

[John D'Errico]

Um, no, You cannot always find a way to "update" your initial guess for fsolve. One can even prove this to be true.

You can change your initial guess. Simplest is to use a multi-start scheme, which will work even wothout the global optimization TB. There is nothing magic in multi-start. Just generate a random start point, and see if you get a solution you like. If not, keep trying random points inside the domain of interest until you are happy, well, until you get lucky.

However, there is no simple (or any complicated scheme either) to infer a better start point for an optimization problem, even if you can try to base it on a previous set of iterations. Again, we can prove that must fail. So no. There is no straightforward way to do what you want.

Unfortunately, from what you say, this is a system of nonlinear equations. And that means they can be arbitrarily nasty. They can have large domains where no matter what the start point in that domain, fsolve will always converge to a non-solution, and even if a solution does exist, the set of start points that will converge to the solution you want will be arbitrarily small.

So I'm sorry, but want what you want, there is no magic you can use. At best, you want to use global optimization tools, which themselves are not gauranteed to converge to a happy place. (But they are more likely to do so, on difficult problems.) Lacking that, just use a home-brewed multi-start method, calling fsolve repeatedly with random start points..

[Walter Roberson]

For example, the non-linear equations could include a term

-1/((x-C1)^N + C2)

as long as N is even, and the quantities involved are all real-valued, and C2 is positive, then this cannot generate a singularity (if x == C1 exactly then (x-C1)^N would be 0, but you then add the positive C2 to get a positive result.)

The graph of this kind of function is a well. The higher the N, the narrower the well. For high enough N and small enough C2, this approaches a delta function, but it is continuous -- just potentially rather narrow. At x==C1 it reduces to -1/C2 and for C2=10^(-P) that would be -10^(P) -- so it can be a pretty deep well.

Now the thing about such wells is that outside of the edges of the well, they can easily be fairly flat, with no significant contribution to the overall function. If you do not happen to start your search very close to the well, the search is unlikely to find the well.

The ultimate non-continuous version of this is -delta(x-C1)/C2 -- a term which is 0 except where x == C1 exactly but is -1/C2 at x == C1 exactly. Such terms are impossible to find through searches, except searches that just happen to test at x == C1 exactly

So... in general if you have non-linear terms, the "catchment basin" of individual linear terms might be quite small.

The -1/((x-C1)^N + C2) form is variation of a Gaussian term by the way, so it is not so uncommon...

[Luigi]

thank you this is very useful. For now I am following the suggestion of increasing MaxIterations and MaxFunctionEvaluations, which seems to help. The thing is that I am solving a highly nonlinear stochastic model (using value function iterations), meaning that I need to solve the system of equations many times to find a solution (I do not think I can reach a closed form solution). My code works but is extremeley slow, which is why I was asking for possible alternative pathways. My code now reads something like:

        z2Vmi=0.00001:0.00001:nc_guess+0.2;
        z2Vpl = nc_guess:0.001:nc_guess+0.2;
        i=1;j=1;
        flag=-10;
    
        while flag<=0
         if i<=length(z2Vpl)
        x0(:,2) = z2Vpl(i);
          i=i+1
        else
        x0(:,2)=nc_guess;
        x0(:,2) = x0(:,2)-z2Vmi(j);
        j=j+1
        
        end
          try
            [sol,~,error,flag]=lsqnonlin(f,x0,lb,ub,options);
        catch
        continue
        end end

which indeed goes "brute force" and is very inefficient.

[Walter Roberson]

fsolve() cannot handle stochastic equations. Neither can any of the optimization routines, with the exception of patternsearch from the Global Optimization Toolbox; https://www.mathworks.com/help/gads/noisy-objective-function.html

[Luigi]

the equation itself is not stochastic, my model is. It is a discrete time macroeconomic model. I am discretizing the state space of my model and solving the system of equations in a loop over a large grid of states (finding the optimal values of my variables, given the states and future possible values of the shocks). All this to say that I need to use fsolve many times.

[Torsten]

If the function does not vary much from step to step, use the solution of the i-th call to "fsolve" as initial guess for the (i+1)th call.