Numerical solvers / Solvers numericos

The library cores are argmin 0.11, quad-rs 0.5 and ivp 0.6. Numerical convergence is not proof of a root or a global minimum. fzero assumes continuity across opposite signs; it makes no residual-size promise. A scalar start searches at most 64 expanding rounds, not the whole real line. fminsearch verifies convergence of both active simplex coordinates and costs, not cost alone.

Optimization has a global 100000-callback budget including the final fval evaluation, even when that output is discarded. integral shares one global 100000-callback budget across at most 8 refinement passes; the budget does not restart on a retry. ODE limits cover 100000 derivative evaluations and 100000 steps, including rejected solver work. Combined T+Y output is limited to 16777216 elements even when an output is discarded; minimum/requested output size is checked before the first callback and adaptive output is checked as it grows.

Callbacks use existing handle dispatch and request exactly one output: nargout() is 1 and isargout(1) is true inside a user callback. Bindings are transactional on evaluation/validation errors, but callback I/O effects are not rolled back. Cancellation is never catchable by try/catch, including inside callbacks. No function-name strings, options structs, exitflags, ODE events, dense solution structs or infinite-bound integration. Stage 5 adds fsolve, lsqnonneg, stiff ode15s BDF and linprog with separate bounded contracts: /language/sparse-advanced-solvers.

[point,value] = fzero(@jump,[-1,1]);
disp(abs(point)<1e-6 && abs(value)==1);
function value = jump(point)
    if point<0
        value=-1;
    else
        value=1;
    end
end

Os nucleos usam argmin 0.11, quad-rs 0.5 e ivp 0.6. Convergencia numerica nao prova raiz nem minimo global. fzero pressupoe continuidade entre sinais opostos e nao promete residuo pequeno. A busca escalar tem no maximo 64 rodadas de expansao, nao cobre toda a reta. fminsearch verifica convergencia das coordenadas e dos custos do simplex ativo, nao apenas custo.

Otimizacao compartilha limite global de 100000 callbacks, incluindo a avaliacao final de fval mesmo descartada. integral compartilha 100000 callbacks entre ate 8 passes de refinamento; tentativas nao reiniciam o limite. EDOs limitam avaliacoes da derivada e passos a 100000, incluindo trabalho rejeitado. A soma T+Y tem limite de 16777216 elementos, mesmo com descarte; tamanho minimo/solicitado e conferido antes do primeiro callback e a saida adaptativa e conferida ao crescer.

Callbacks usam o despacho existente de handles e solicitam uma saida: nargout() e 1 e isargout(1) e true no callback de usuario. Erros de avaliacao/validacao preservam os destinos da atribuicao em conjunto, mas efeitos de I/O dos callbacks nao sao desfeitos. Cancelamento nunca e capturavel por try/catch, inclusive dentro de callbacks. Sem nomes de funcao em strings, structs de opcoes, exitflags, eventos de EDO, structs de solucao densa ou integracao com limites infinitos. Etapa 5 adiciona fsolve, lsqnonneg, ode15s BDF rigido e linprog com contratos limitados separados: /language/sparse-advanced-solvers.

[ponto,custo] = fminsearch(@objetivo,0);
disp(abs(ponto-2)<1e-5 && custo<1e-10);
function valor = objetivo(ponto)
    if nargout()~=1 || !isargout(1) || isargout(2)
        error("Docs:Outputs","callback requires one output");
    end
    valor=(ponto-2)^2;
end

[root,residual] = fzero(fun,x0[,tol[,maxiter]]) uses argmin BrentRoot. x0 is a finite real Number for a bounded bracket search, or a real two-element row/column bracket with distinct finite endpoints and a sign change (an endpoint root is accepted). Search failure is an error, not proof that no root exists.

[xmin,fval] = fminbnd(fun,a,b[,tol[,maxiter]]) uses argmin BrentOpt with finite real Number bounds a < b. [xmin,fval] = fminsearch(fun,x0[,tol[,maxiter]]) uses argmin NelderMead for an unconstrained local minimum, not a global guarantee. Its finite Number or nonempty real row/column vector x0 has at most 128 dimensions; both callback argument and xmin preserve its Number/row/column shape.

All three default to tol=1e-8 and maxiter=1000. tol must be a positive finite real Number; maxiter a real Number integer in 1..100000. The evaluation budget is 100000. Nonconvergence raises Sun:InvalidArgument, without optimization flags or partial results.

[root,residual] = fzero(@(x) x^2-2,[0,2]);
disp(abs(root-sqrt(2))<1e-6 && abs(residual)<1e-6);
[xmin,fval] = fminbnd(@(x) (x-3)^2,0,5);
disp(abs(xmin-3)<1e-5 && fval<1e-10);
[point,cost] = fminsearch(@(x) (x(1)-1)^2+(x(2)+2)^2,[0;0]);
disp(size(point,1)==2 && size(point,2)==1 && all(abs(point-[1;-2])<1e-5) && cost<1e-10);

[root,residual] = fzero(fun,x0[,tol[,maxiter]]) usa argmin BrentRoot. x0 e Number real finito para busca limitada de intervalo, ou vetor real de dois elementos em linha/coluna com extremos finitos distintos e troca de sinal; raiz no extremo e aceita. Falha da busca nao prova ausencia de raiz.

[xmin,fval] = fminbnd(fun,a,b[,tol[,maxiter]]) usa argmin BrentOpt com limites Number reais finitos a < b. [xmin,fval] = fminsearch(fun,x0[,tol[,maxiter]]) usa argmin NelderMead, sem restricoes e sem garantia global. x0 e Number finito ou vetor real finito nao vazio de ate 128 dimensoes; callback e xmin preservam Number/linha/coluna de x0.

Padroes dos tres: tol=1e-8 e maxiter=1000. tol deve ser Number real finito positivo; maxiter, Number inteiro de 1..100000. Limite de 100000 avaliacoes. Nao convergencia gera Sun:InvalidArgument, sem flags de otimizacao ou resultados parciais.

[raiz,residuo] = fzero(@(x) x-2,0);
disp(abs(raiz-2)<1e-6 && abs(residuo)<1e-6);
[ponto,custo] = fminsearch(@(x) (x-4)^2,0);
disp(isa(ponto,"double") && abs(ponto-4)<1e-5 && custo<1e-10);

[q,error] = integral(fun,a,b[,abstol[,reltol]]) uses quad-rs GaussKronrod. Bounds must be finite real Numbers. Reversing bounds changes the sign of q, not the nonnegative error estimate. Equal bounds return [0,0] without invoking the callback, but the handle, arity, bounds and tolerances are still validated.

Defaults are abstol=1e-10 and reltol=1e-6, both positive finite real Numbers. The target is error <= max(abstol,reltol*abs(q)); this is a numerical estimate, not a rigorous error bound. At most 100000 evaluations; failure to converge or unrepresentable scaled values raises Sun:InvalidArgument. No infinite bounds, vectorized callback, integral2 or integral3.

[q,estimate] = integral(@(x) x^2,0,1);
[reverse,reverseError] = integral(@(x) x^2,1,0);
disp(abs(q-1/3)<1e-8 && estimate>=0 && estimate<=1e-6*abs(q));
disp(abs(reverse+q)<1e-8 && reverseError>=0);
[empty,emptyError] = integral(@(x) error("Docs:Unexpected","must not run"),2,2);
disp(empty==0 && emptyError==0);

[q,error] = integral(fun,a,b[,abstol[,reltol]]) usa quad-rs GaussKronrod. Limites devem ser Number reais finitos. Inverter limites muda o sinal de q, nao a estimativa de erro nao negativa. Limites iguais retornam [0,0] sem chamar callback, mas handle, aridade, limites e tolerancias passam por validacao completa.

Padroes: abstol=1e-10 e reltol=1e-6, ambos Number reais finitos positivos. Alvo: error <= max(abstol,reltol*abs(q)); estimativa numerica, nao limite rigoroso. Ate 100000 avaliacoes; nao convergencia ou valores escalados irrepresentaveis geram Sun:InvalidArgument. Sem limites infinitos, callback vetorizado, integral2 ou integral3.

[valor,erro] = integral(@sin,0,pi,1e-10,1e-6);
disp(abs(valor-2)<1e-7 && erro>=0);

[T,Y] = ode45(fun,tspan,y0[,reltol[,abstol]]) uses ivp DOPRI5; ode23 has the same signature and uses ivp RK23. These are nonstiff methods only. Defaults: reltol=1e-6, abstol=1e-9, both positive finite real Numbers (note the order differs from integral).

tspan is a finite real row/column vector, strictly monotone with at least two distinct entries and finite total span. Two entries return adaptive times; more than two return the exact requested grid using dense output, including descending grids. y0 is a finite real Number or nonempty real vector. Every callback receives (t,y) with Number t and column matrix y even for scalar y0. The derivative must be a finite real vector with the same element count; a Number is also allowed only for one state.

T is n-by-1 and Y is n-by-states; rows of Y correspond to T, columns to state components. One output returns T, not a solution struct. Combined T and Y size must be <=16777216 elements, with at most 100000 steps and 100000 derivative evaluations. Size overflow is an error; nonconvergence raises Sun:InvalidArgument, never a partial trajectory.

[T,Y] = ode45(@(t,y) -y,[0,0.25,0.5,1],1);
disp(size(T,1)==4 && size(T,2)==1 && all(T==[0;0.25;0.5;1]));
disp(size(Y,1)==4 && size(Y,2)==1 && all(abs(Y-exp(-T))<1e-5));
[back,state] = ode23(@(t,y) -y,[1,0.5,0],exp(-1));
disp(all(back==[1;0.5;0]) && all(abs(state-exp(-back))<1e-5));
onlyTimes = ode45(@(t,y) -y,[0,1],1);
disp(size(onlyTimes,2)==1 && onlyTimes(1)==0 && onlyTimes(end)==1);

[T,Y] = ode45(fun,tspan,y0[,reltol[,abstol]]) usa ivp DOPRI5; ode23 tem a mesma assinatura e usa ivp RK23. Somente problemas nao rigidos. Padroes: reltol=1e-6, abstol=1e-9, ambos Number reais finitos positivos; a ordem difere de integral.

tspan e vetor real finito em linha/coluna estritamente monotono com ao menos dois tempos distintos e intervalo total finito. Dois tempos retornam malha adaptativa; mais de dois retornam exatamente a malha solicitada por saida densa, inclusive decrescente. y0 e Number real finito ou vetor real finito nao vazio. Callback recebe (t,y), sempre com t Number e y matriz coluna, mesmo para y0 escalar. Derivada: vetor real finito com mesma contagem de elementos; Number tambem permitido somente para um estado.

T tem n por 1 e Y n por estados; cada linha corresponde a um tempo. Uma saida retorna T, nao struct de solucao. T e Y juntos devem ter <=16777216 elementos; ate 100000 passos e 100000 avaliacoes da derivada. Excesso de tamanho e erro; nao convergencia gera Sun:InvalidArgument, nunca trajetoria parcial.

[tempos,estados] = ode23(@(t,y) [y(2);-y(1)],[0,0.5,1],[1,0]);
disp(size(estados,1)==3 && size(estados,2)==2 && all(tempos==[0;0.5;1]));
disp(abs(estados(end,1)-cos(1))<1e-5 && abs(estados(end,2)+sin(1))<1e-5);

All six accept builtin, named function-file and anonymous function handles, not function-name strings. Optimization objectives and integral callbacks receive a scalar (except shape-preserving fminsearch) and return a finite real Number or real 1x1 matrix. Logical and complex values are rejected, even with zero imaginary part. ODE derivatives follow the vector contract above.

All six allow at most two output positions, including discarded positions: [root,residual], [xmin,fval], [q,error], [T,Y]. One output keeps only the first. Callback errors preserve their original identifier, message and source; cancellation is preserved, not translated to nonconvergence. Interpreter/Studio interpreter only: all six are forbidden in parfor and rejected by native LLVM compilation with no fallback. Use sun check for syntax and sun run for execution; check does not execute callbacks.

These six Stage 2 APIs have no options struct, events, integral2/integral3, constraints or optimization flags. Stage 5 separately adds fsolve, lsqnonneg, stiff ode15s (BDF, not NDF) and linear programming linprog: /language/sparse-advanced-solvers; this does not add fmincon or change ode45/ode23.

preserved=false;
try
    integral(@(x) error("Docs:Callback","original callback"),0,1);
catch problem
    switch problem.identifier
    case "Docs:Callback"
        switch problem.message
        case "original callback"
            preserved=true;
        end
    end
end
disp(preserved);

Os seis aceitam handles de builtin, funcao nomeada em arquivo e funcao anonima, nao nomes em strings. Objetivos de otimizacao e callbacks de integral retornam Number real finito ou matriz real 1x1. Recebem escalar, exceto fminsearch que preserva forma. Logicos e complexos sao rejeitados mesmo com parte imaginaria zero; derivadas de EDO seguem o contrato vetorial acima.

Ate duas posicoes de saida, inclusive descartes: [root,residual], [xmin,fval], [q,error], [T,Y]. Uma saida preserva apenas a primeira. Erros de callback preservam identificador, mensagem e origem; cancelamento e preservado, nao convertido em nao convergencia. Somente interpretador, inclusive Studio: os seis sao proibidos em parfor e rejeitados pelo LLVM nativo sem fallback. sun check valida sintaxe sem executar callbacks; sun run executa.

Essas seis APIs da etapa 2 nao tem struct de opcoes, eventos, integral2/integral3, restricoes ou flags de otimizacao. Etapa 5 adiciona separadamente fsolve, lsqnonneg, ode15s rigido (BDF, nao NDF) e programacao linear linprog: /language/sparse-advanced-solvers; nao adiciona fmincon nem muda ode45/ode23.

[raiz,~] = fzero(@(x) x-1,[0,2]);
disp(abs(raiz-1)<1e-8);