Constrained optimization / Otimizacao restrita

fmincon(fun,x0,A,b[,Aeq,beq[,lb,ub[,nonlcon[,options]]]]) accepts exactly 4/6/8/9/10 arguments. fun is a handle receiving x0's original shape and returning one finite real Number or 1x1 matrix. x0 is a finite real Number or nonempty dense row/column vector with 1..64 coordinates; logical, complex, sparse and general matrices are rejected. x preserves x0 shape, fval is a Number; at most two output positions [x,fval], including ~, never an exitflag. Named/forwarded handles use the same dispatcher and anonymous captures copy values.

Only fmincon is new in Stage 6.1. slsqp-rssl 0.1.0 is a pure Rust port of SciPy's Fortran SLSQP, a local method: no global optimum guarantee or proof of unboundedness. Runtime source solvers/constrained.rs is authoritative, not the broader MATLAB API.

target=2; fun=@(point) (point-target)^2; target=9;
[x,cost]=fmincon(fun,0,[],[]);
disp(abs(x-2)<1e-6 && cost<1e-10 && strcmp(class(cost),'double'));
solver=@fmincon;
row=solver(@(point) sum((point-[2,3]).^2),[0,0],[],[]);
disp(all(size(row)==[1,2]) && all(abs(row-[2,3])<1e-6));

fmincon(fun,x0,A,b[,Aeq,beq[,lb,ub[,nonlcon[,options]]]]) aceita exatamente 4/6/8/9/10 argumentos. fun e handle que recebe a forma original de x0 e retorna um Number real finito ou matriz 1x1. x0 e Number real finito ou vetor denso linha/coluna nao vazio com 1..64 coordenadas; rejeita logicos, complexos, esparsos e matrizes gerais. x preserva forma de x0, fval e Number; ate duas posicoes [x,fval], inclusive ~, nunca exitflag. Handles nomeados/encaminhados usam o mesmo dispatcher e capturas anonimas copiam valores.

Somente fmincon e novo na etapa 6.1. slsqp-rssl 0.1.0 e port Rust puro do SLSQP Fortran do SciPy, metodo local: sem garantia de otimo global ou prova de ilimitacao. Fonte solvers/constrained.rs do runtime e autoritativa, nao a API MATLAB mais ampla.

[x,custo]=fmincon(@(p) sum((p-[2;3]).^2),[0;0],[],[]);
disp(all(size(x)==[2,1]) && all(abs(x-[2;3])<1e-6) && custo<1e-10);
[~,custo]=fmincon(@(p) (p-3)^2,0,[],[],[],[],0,2);
disp(abs(custo-1)<1e-7);

Minimize fun(x) with A*x<=b, native equalities Aeq*x=beq and lb<=x<=ub. A/Aeq are finite real dense matrices (Number for 1x1), with columns matching coordinate count; b/beq are matching finite real vectors or Numbers. [] omits pairs. At most 512 combined inequality/equality rows and 16777216 workspace elements (16M). Positive row normalization rejects numerical range loss; final feasibility uses ORIGINAL units, not normalized residuals.

Bounds are real vectors matching x0 count (Number only for one coordinate), no scalar broadcasting; [] defaults to lb=-Inf, ub=Inf. Only correctly signed infinities are allowed, no NaN, lb<=ub. Internally infinities map to +/-realmax (maximum finite real range), NOT arbitrary +/-1e12. Equal fixed bounds are allowed. x0 outside bounds is rejected, never initially clamped; x0 need not already satisfy linear/nonlinear constraints.

[x,cost]=fmincon(@(p) sum((p-2).^2),[0.2;0.3],[1,1],1);
disp(all(size(x)==[2,1]) && all(abs(x-0.5)<1e-6) && abs(cost-4.5)<1e-6);
[x,cost]=fmincon(@(p) sum((p-2).^2),[0.2,0.8],[],[],[1,1],1,[0,0],[1,1]);
disp(all(abs(x-0.5)<1e-6) && abs(sum(x)-1)<1e-8);

Minimiza fun(x) com A*x<=b, igualdades nativas Aeq*x=beq e lb<=x<=ub. A/Aeq sao matrizes densas reais finitas (Number para 1x1), colunas iguais a contagem de coordenadas; b/beq vetores reais finitos compativeis ou Numbers. [] omite pares. Ate 512 linhas combinadas de desigualdade/igualdade e 16777216 elementos de workspace (16M). Normalizacao positiva por linha rejeita perda de faixa numerica; viabilidade final usa unidades ORIGINAIS, nao residuos normalizados.

Bounds sao vetores reais com contagem de x0 (Number so para uma coordenada), sem broadcasting escalar; [] padrao lb=-Inf, ub=Inf. Infinitos apenas com sinal correto, sem NaN, lb<=ub. Internamente infinitos viram +/-realmax (faixa real finita maxima), NAO +/-1e12 arbitrario. Bounds fixos iguais sao aceitos. x0 fora dos bounds e rejeitado, sem clamp inicial; x0 nao precisa satisfazer restricoes lineares/nao lineares inicialmente.

[x,custo]=fmincon(@(p) (p-3)^2,0,[],[],[],[],0,2);
disp(abs(x-2)<1e-7 && abs(custo-1)<1e-7);
[x,custo]=fmincon(@(p) sum((p-2).^2),[0.2;0.8],[],[],[1,1],1);
disp(all(abs(x-0.5)<1e-6) && abs(sum(x)-1)<1e-8);

nonlcon is [] or a handle DECLARING TWO outputs [c,ceq]. Sun inequalities use c<=0, equalities ceq=0 and native backend Eq, not paired inequalities. Each output is a finite real Number, row/column vector or []; both counts must remain fixed over all queries and their aggregate is <=64. A one-output anonymous callback is not a replacement. The callback receives x0's original shape. Both outputs are requested even when solver outputs use discard masks.

Callbacks must be deterministic functions of the point: nonlinear results are cached per step to share component evaluations, then freshly evaluated for final feasibility. Changing counts, nonfinite values or user errors fail rather than returning partial results.

[x,cost]=fmincon(@(p) sum((p-2).^2),[0.2,0.2],[],[],[],[],[],[],@disk);
disp(all(abs(x-sqrt(0.5))<1e-5) && sum(x.^2)<=1+1e-8);
function [c,ceq]=disk(point)
    c=sum(point.^2)-1;
    ceq=[];
end

nonlcon e [] ou handle que DECLARA DUAS saidas [c,ceq]. Desigualdades Sun usam c<=0, igualdades ceq=0 e Eq nativa do backend, nao pares de desigualdades. Cada saida e Number real finito, vetor linha/coluna ou []; ambas as contagens sao fixas em todas as consultas e a soma e <=64. Callback anonimo de uma saida nao substitui esse contrato. Recebe forma original de x0. Ambas as saidas sao pedidas mesmo com mascaras de descarte nas saidas do solver.

Callbacks devem ser funcoes deterministas do ponto: resultados nao lineares ficam em cache por passo para compartilhar avaliacoes de componentes, com nova avaliacao final de viabilidade. Contagens variaveis, valores nao finitos ou erros do usuario falham sem resultados parciais.

[~,custo]=fmincon(@(p) sum((p-2).^2),[0.2;0.8],[],[],[],[],[],[],@soma);
disp(abs(custo-4.5)<1e-6);
function [c,ceq]=soma(ponto)
    c=[];
    ceq=sum(ponto)-1;
end

options must be a scalar Struct, not [] or optimoptions; only four case-sensitive fields are accepted. MaxIterations defaults 200, integer 1..10000. MaxFunctionEvaluations defaults 10000, integer 1..100000; this is ONE SHARED fun+nonlcon callback budget including finite differences (FD), initial nonlinear evaluation and final nonlinear/objective checks. Linear row evaluations do not consume callback budget. Exhaustion errors, not exitflag or partial optimum.

OptimalityTolerance defaults 1e-8, a positive finite Number passed as backend absolute accuracy; ten times it must remain finite. It is NOT an independent KKT certificate. ConstraintTolerance defaults 1e-8, positive finite Number, used for final bounds/linear/nonlinear feasibility in ORIGINAL units. Unknown fields, aliases such as TolFun, Display, Algorithm or lowercase names are rejected, never silently ignored.

options=struct('MaxIterations',200,'MaxFunctionEvaluations',10000,'OptimalityTolerance',1e-8,'ConstraintTolerance',1e-8);
[x,cost]=fmincon(@(p) (p-2)^2,0,[],[],[],[],[],[],[],options);
disp(abs(x-2)<1e-6 && cost<1e-10);

options deve ser Struct escalar, nao [] nem optimoptions; aceita apenas quatro campos sensiveis a maiusculas. MaxIterations padrao 200, inteiro 1..10000. MaxFunctionEvaluations padrao 10000, inteiro 1..100000; e UM orcamento COMPARTILHADO fun+nonlcon incluindo diferencas finitas (FD), consulta nao linear inicial e verificacoes finais nao linear/objetivo. Linhas lineares nao gastam callbacks. Esgotamento gera erro, nao exitflag ou otimo parcial.

OptimalityTolerance padrao 1e-8, Number positivo finito passado como precisao absoluta do backend; dez vezes seu valor deve continuar finito. NAO e certificado KKT independente. ConstraintTolerance padrao 1e-8, Number positivo finito, verifica viabilidade final de bounds/lineares/nao lineares em unidades ORIGINAIS. Campos desconhecidos, aliases TolFun, Display, Algorithm ou nomes minusculos sao rejeitados, nunca ignorados silenciosamente.

opcoes=struct('MaxIterations',200,'MaxFunctionEvaluations',10000,'OptimalityTolerance',1e-8,'ConstraintTolerance',1e-8);
[x,custo]=fmincon(@(p) (p-3)^2,0,[],[],[],[],0,2,[],opcoes);
disp(abs(x-2)<1e-7 && abs(custo-1)<1e-7);

Coordinates for which x+sqrt(eps)==x in f64 are rejected before callbacks with an explicit range error, not accepted as stationary. Ordinary floating rounding and cancellation remain limitations.

The backend uses a fixed sqrt(eps) finite-difference step (sqrt(EPSILON)), not a relative or bound-aware stencil. Probes may be OUTSIDE bounds, even with fixed variables; there is NO clamp of callback queries. fun and nonlcon must return finite valid values at EVERY queried point, including outside bounds. Original callback errors propagate, not a replacement convergence message. Do not rely on bounds to protect log/sqrt or other domain-limited callbacks.

caught=false;
try
    fmincon(@guard,0,[],[],[],[],0,0);
catch problem
    caught=strcmp(problem.identifier,'Docs:Outside');
end
disp(caught);
function value=guard(point)
    if point>0
        error('Docs:Outside','finite difference outside fixed bounds');
    end
    value=point^2;
end

Coordenadas em que x+sqrt(eps)==x em f64 sao rejeitadas antes dos callbacks com erro explicito de faixa, nao aceitas como estacionarias. Arredondamento e cancelamento comuns continuam sendo limitacoes.

Backend usa passo fixo sqrt(eps) de diferencas finitas (sqrt(EPSILON)), nao stencil relativo ou adaptado aos bounds. Consultas podem ocorrer FORA dos bounds, inclusive variaveis fixas; NAO ha clamp das consultas. fun e nonlcon devem retornar valores validos finitos em CADA ponto consultado, inclusive fora dos bounds. Erros originais de callback propagam, sem mensagem substituta de convergencia. Bounds nao protegem callbacks com dominio limitado como log/sqrt.

capturado=false;
try
    fmincon(@dominio,0,[],[],[],[],0,0);
catch problema
    capturado=strcmp(problema.identifier,'Docs:Outside');
end
disp(capturado);
function valor=dominio(ponto)
    if ponto>0
        error('Docs:Outside','consulta fora dos bounds fixos');
    end
    valor=ponto^2;
end

fmincon is BLOCKED in parfor, including handle dispatch; LLVM rejects it and requires sun run, with NO interpreter fallback. sun check checks syntax/static restrictions, not numerical success. Original callback errors and cancellation propagate; cancellation is not catchable. Failed calls preserve atomic output bindings, not I/O rollback: already executed callback output/file effects remain. Static arguments/output arity are checked before callbacks; discarded outputs still validate and solve.

Stage 6 was selected across all fronts, but is delivered in separate increments with contracts first; only 6.1 fmincon is implemented now, not all Stage 6. PDE/BVP/DDE, classdef/OOP, Python/Java/FFI/MEX remain PENDING, without placeholder wrappers. Future external permissions must default deny with an explicit host allowlist; this increment adds NO new host capability. Earlier bounded contracts remain at /language/sparse-advanced-solvers and /language/numerical-solvers.

point=7; cost=8; caught=false;
try
    [point,cost]=fmincon(@bad,0,[],[]);
catch problem
    caught=strcmp(problem.identifier,'Docs:Callback');
end
disp(caught && point==7 && cost==8);
function value=bad(point)
    error('Docs:Callback','original callback error');
end

fmincon e BLOQUEADO em parfor, inclusive via handles; LLVM rejeita e exige sun run, SEM fallback para interpretador. sun check valida sintaxe/restricoes estaticas, nao sucesso numerico. Erros originais de callback e cancelamento propagam; cancelamento nao e capturavel. Falhas preservam bindings atomicos de saida, nao rollback de I/O: efeitos de saida/arquivo ja executados permanecem. Argumentos estaticos/aridade de saida sao verificados antes de callbacks; saidas descartadas ainda validam e resolvem.

Todas as frentes da etapa 6 foram escolhidas, mas serao entregues em incrementos separados com contratos antes; apenas 6.1 fmincon implementado agora, nao toda a etapa 6. PDE/BVP/DDE, classdef/OOP, Python/Java/FFI/MEX seguem PENDENTES, sem wrappers placeholder. Permissoes externas futuras devem negar por padrao (default deny) com host allowlist explicita; este incremento NAO adiciona capacidade host. Contratos limitados anteriores em /language/sparse-advanced-solvers e /language/numerical-solvers.

ponto=7; custo=8; capturado=false;
try
    [ponto,custo]=fmincon(@falha,0,[],[]);
catch problema
    capturado=strcmp(problema.identifier,'Docs:Callback');
end
disp(capturado && ponto==7 && custo==8);
function valor=falha(ponto)
    error('Docs:Callback','erro original');
end