Linear algebra / Algebra linear

A\B and the built-in mldivide(A,B) require dense REAL MATRIX A m-by-n and B m-by-p and always return one MATRIX X n-by-p, including 1-by-1. Exactly two arguments and one output; no tolerance, flags, residual or warning outputs. @mldivide works under normal handle resolution. No implicit Number/logical/complex/string conversions and no scalar backslash or .\; / and ./ are unchanged.

Shape alone selects the backend. Square A uses EXACTLY solve(A,B): protected column-scaled nalgebra LU, relative pivot test |Ujj_scaled|<=n*eps*(maxAbs(Acolj)/scalej), ALL-input finite validation and protected RHS per column, C*Z=B*E^-1 and X=D^-1*Z*E with frexp/scalbn recovery. Singular square A raises Sun:SingularMatrix: NO SVD fallback, automatic Cholesky or symmetry detection. Rectangular A uses EXACTLY lsqminnorm(A,B) with the default SVD cutoff max(m,n)*eps*sigma_max, for tall, wide and rank-deficient matrices. It minimizes residual norm, then solution norm. This is NOT MATLAB's basic solution, warning system, sparse support or general mldivide dispatch. For [1,1]\[2], X=[1;1]. solve/inv/det retain their preceding contracts.

The same backend input/output axes and element limits of 16,777,216 apply, not a total memory quota. A/B row mismatch raises Sun:IncompatibleDimensions BEFORE empty shortcuts. Square 0-by-0 with B 0-by-p returns 0-by-p; rectangular 0-by-n with B 0-by-p returns n-by-p zeros; m-by-0 with B m-by-p returns 0-by-p; B m-by-0 returns n-by-0. With empty RHS, finite singular square A still bypasses the singularity test, but ALL A/B must first be finite. NaN/Inf and nonfinite matrix outputs raise Sun:InvalidArgument; extreme protected/normalized ranges raise Sun:LinearAlgebraRange, bounded SVD nonconvergence Sun:DecompositionFailed.

Binary A\B evaluates left then right once and bypasses overloaded session functions; the named alias is NOT unshadowable. Both are pure single-output expressions in supported parfor with indexed scalar writes to preallocated real outputs; no slices, reductions or MultiAssign. Both are rejected by native LLVM: use sun run. No C ABI change. The companion example is examples/divisao_esquerda.sun.

A\B e o builtin mldivide(A,B) exigem MATRIZ REAL DENSA A m por n e B m por p; sempre retornam uma MATRIZ X n por p, inclusive 1 por 1. Exatamente dois argumentos e uma saida; sem tolerancia, flags, residuos ou avisos extras. @mldivide segue resolucao normal de handles. Sem conversao implicita de Number/logicos/complexos/texto, backslash escalar ou .\; / e ./ nao mudam.

Somente a forma seleciona o backend. A quadrada usa EXATAMENTE solve(A,B): LU de nalgebra com escalas protegidas por coluna, teste relativo |Ujj_scaled|<=n*eps*(maxAbs(Acolj)/scalej), validacao finita de TODA entrada e protecao de cada coluna RHS, C*Z=B*E^-1 e X=D^-1*Z*E com recuperacao frexp/scalbn. Quadrada singular gera Sun:SingularMatrix, SEM fallback SVD, Cholesky automatico ou deteccao de simetria. A retangular usa EXATAMENTE lsqminnorm(A,B) com corte SVD padrao max(m,n)*eps*sigma_max, incluindo altas, largas e deficientes em posto: minimiza residuo e depois norma da solucao. NAO e a solucao basica MATLAB, sistema de avisos, suporte esparso ou despacho geral mldivide. [1,1]\[2] retorna [1;1]. Contratos anteriores de solve/inv/det permanecem iguais.

Mesmos limites de entrada/saida de 16.777.216 elementos/eixo do backend, nao cota global. Linhas A/B incompativeis geram Sun:IncompatibleDimensions ANTES dos atalhos vazios. A quadrada 0 por 0 com B 0 por p retorna 0 por p; retangular 0 por n com B 0 por p retorna zeros n por p; m por 0 com B m por p retorna 0 por p; B m por 0 retorna n por 0. RHS vazio ainda dispensa teste de singularidade de A quadrada finita, mas TODA A/B deve ser finita primeiro. NaN/Inf e saidas matriciais nao finitas geram Sun:InvalidArgument; faixa protegida/normalizada extrema gera Sun:LinearAlgebraRange e SVD sem convergencia gera Sun:DecompositionFailed.

A\B binario avalia esquerda e depois direita uma vez e ignora funcoes de sessao sobrecarregadas; o alias nomeado PODE ser sombreado. Ambos sao puros com uma saida em parfor suportado, com escritas escalares indexadas reais prealocadas; sem fatias/reducoes/MultiAssign. Ambos rejeitados por LLVM nativo: use sun run. ABI C inalterada. Exemplo complementar: examples/divisao_esquerda.sun.

Every printed invariant should be true; compare shapes and residuals, not exact floating-point formatting.

A = [0,2;3,4];
B = A*[1,2;3,4];
X = A\B;
Y = mldivide(A,B);
disp(all(size(X)==[2,2]) && all(abs(X-solve(A,B))<1e-12) && all(abs(X-Y)<1e-12));
disp(all(abs(A*X-B)<1e-12));
W = [1,1];
X = W\[2];
disp(all(size(X)==[2,1]) && all(abs(X-[1;1])<1e-12));
T = [1,0;1,1;1,2];
B = [1;2;2];
X = mldivide(T,B);
disp(all(abs(X-lsqminnorm(T,B))<1e-12) && all(abs(T.'*(T*X-B))<1e-12));
R = [1,2;2,4;3,6];
B = [3,6;6,12;9,18];
X = R\B;
disp(all(size(X)==[2,2]) && all(abs(X-[0.6,1.2;1.2,2.4])<1e-12));
scale = 2^(-600);
tiny = realmin*eps;
expected = 2^(-475);
X = [scale,scale;scale,-scale]\[tiny;0];
disp(all(abs(X/expected-[1;1])<1e-12));
X = mldivide([1,0;0,1e-100],[1e250;1e-100]);
disp(abs(X(1)/1e250-1)<1e-12 && abs(X(2)-1)<1e-12);

Todos os invariantes devem imprimir true. Erros usam switch, nao igualdade de strings.

left = @mldivide;
X = left([2],[6]);
disp(all(size(X)==[1,1]) && abs(X(1)-3)<1e-12);
disp(all(size(zeros(0,0)\zeros(0,3))==[0,3]));
X = mldivide(zeros(0,2),zeros(0,3));
disp(all(size(X)==[2,3]) && all(X==0));
disp(all(size(zeros(3,0)\zeros(3,2))==[0,2]));
disp(all(size(mldivide(zeros(2,2),zeros(2,0)))==[2,0]));
matched = false;
try
    [1,2;2,4]\[3;6];
catch failure
    switch failure.identifier
        case 'Sun:SingularMatrix'
            matched = true;
    end
end
disp(matched);
matched = false;
try
    mldivide([NaN],zeros(1,0));
catch failure
    switch failure.identifier
        case 'Sun:InvalidArgument'
            matched = true;
    end
end
disp(matched);
operators = zeros(1,2);
aliases = zeros(1,2);
parfor index = 1:2
    local_operator = [2]\[6];
    operators(index) = local_operator(1);
    local_alias = mldivide([1,1],[2]);
    aliases(index) = local_alias(2);
end
disp(all(abs(operators-3)<1e-12) && all(abs(aliases-1)<1e-12));

EN: This guide records the current development contract, not a released-version guarantee. Engine integration can lag the numeric backend; check builtins() in the executable you use. SVD/pseudoinverse examples require an engine exposing svd and pinv.

PT: Este guia registra o contrato atual de desenvolvimento, nao uma garantia de versao publicada. A integracao do motor pode estar atras do backend numerico; confira builtins() no executavel usado. Os exemplos de SVD/pseudoinversa exigem motor com svd e pinv.

EN: LU/Cholesky examples require an integrated engine exposing lu and chol. A checker success is not proof of built-in availability; unknown-function execution errors and runtime catalog mismatches must be reported, not skipped or filtered.

PT: Exemplos LU/Cholesky exigem motor integrado com lu e chol. Sucesso no checker nao prova disponibilidade dos built-ins; funcao desconhecida e divergencia de catalogo devem ser reportadas, nao ignoradas ou filtradas.

solve(A,B) requires dense REAL MATRIX A n-by-n and B n-by-p and returns one X n-by-p with A*X=B. inv(A) returns one n-by-n matrix; det(A) returns one Number. All require square A, including empty inputs; no Number, logical or complex implicit conversion (explicit double for logical data is allowed). There is no new syntax, mode, tolerance argument or additional output. No automatic Cholesky, symmetry assumption or fallback to lsqminnorm/pinv for rectangular or singular input.

These operations now use nalgebra LU with partial row pivoting and the SAME protected positive column scales as lu(A). With D=diag(scales), solve factors C=A*D^-1. Each nonzero RHS column has a protected scale E_j=min(maxAbs(Bcolj), minNonzeroAbs(Bcolj)/MIN_POSITIVE), where MIN_POSITIVE is the smallest positive normal double. With E=diag(E_j), solve computes C*Z=B*E^-1 and returns X=D^-1*Z*E. Zero RHS columns are handled specially as zero solution columns (scale 1). If maxAbs(Bcolj)/E_j overflows, Sun:LinearAlgebraRange is raised instead of silently erasing small entries. B is not globally normalized: protected scaling is per RHS column, since a single global scale could erase small independent components.

Each entry Z_ij*E_j/D_i is recovered using libm frexp/scalbn mantissa/exponent arithmetic, avoiding intermediate underflow/overflow when the final double fits. The subnormal RHS example requires both components equal to 2^(-475); the previous unscaled-RHS path gave [2*expected;0] despite condition number 1. The mixed-scale example preserves [1e250;1]. Extremely ill-conditioned systems or backend intermediate overflow can still be rejected; this is not full arbitrary precision. inv uses backend LU try_inverse and rescales rows, not custom Gaussian elimination. lu itself still allows singular matrices and zero pivots; QR, Cholesky, SVD, pinv, rank, cond and least-squares contracts are unchanged.

det(zeros(0,0))=1; inv of 0-by-0 is 0-by-0; solve of A 0-by-0 and B 0-by-p is 0-by-p. For finite square A n-by-n and B n-by-0, solve returns n-by-0 WITHOUT a singularity test. ALL A/B entries are validated first: NaN/Inf raises Sun:InvalidArgument even when B has no columns. Numerical singularity raises Sun:SingularMatrix for solve/inv and returns 0 for det. Nonsquare A or incompatible A/B rows raises Sun:IncompatibleDimensions.

Nonfinite computed solution/inverse matrices raise Sun:InvalidArgument; nonfinite normalized LU factors or an unrepresentable scale range raise Sun:LinearAlgebraRange. These remain interpreter-only pure single-output parfor calls (indexed preallocated real writes, no slices/reductions or MultiAssign). Native LLVM lowering and the C ABI are unchanged: use sun run.

solve(A,B) exige MATRIZ REAL DENSA A n por n e B n por p, retornando uma X n por p com A*X=B. inv(A) retorna uma matriz n por n; det(A) retorna um Number. A deve ser quadrada, inclusive vazia; sem conversao implicita de Number, logicos ou complexos (double explicito para logicos e permitido). Sem nova sintaxe, modo, argumento de tolerancia ou saida adicional. Sem Cholesky automatico, suposicao de simetria ou fallback para lsqminnorm/pinv em entradas retangulares ou singulares.

As operacoes agora usam LU de nalgebra com pivoteamento parcial de linhas e as MESMAS escalas positivas protegidas por coluna de lu(A). Com D=diag(escalas), solve fatora C=A*D^-1. Cada coluna RHS nao nula tem escala protegida E_j=min(maxAbs(Bcolj), minNonzeroAbs(Bcolj)/MIN_POSITIVE), com MIN_POSITIVE igual ao menor double positivo normal. Com E=diag(E_j), resolve C*Z=B*E^-1 e retorna X=D^-1*Z*E. Colunas RHS nulas recebem tratamento especial como colunas de solucao zero (escala 1). Se maxAbs(Bcolj)/E_j transbordar, gera Sun:LinearAlgebraRange em vez de apagar entradas pequenas silenciosamente. B nao e normalizada globalmente: a escala protegida e por coluna RHS, pois uma escala global poderia apagar componentes pequenas independentes.

Cada entrada Z_ij*E_j/D_i e recuperada com aritmetica de mantissa/expoente libm frexp/scalbn, evitando underflow/overflow intermediario quando o double final cabe. O exemplo de RHS subnormal exige ambas as componentes iguais a 2^(-475); o caminho anterior sem escala de RHS produzia [2*expected;0] apesar de condicionamento 1. O caso de escalas mistas preserva [1e250;1]. Sistemas extremamente mal condicionados ou overflow intermediario do backend ainda podem ser rejeitados; nao e precisao arbitraria completa. inv usa LU try_inverse do backend e reescala linhas, nao eliminacao gaussiana propria. lu continua aceitando matrizes singulares e pivos zero; contratos de QR, Cholesky, SVD, pinv, rank, cond e minimos quadrados permanecem iguais.

det(zeros(0,0))=1; inv de 0 por 0 retorna 0 por 0; solve com A 0 por 0 e B 0 por p retorna 0 por p. Para A quadrada finita n por n e B n por 0, solve retorna n por 0 SEM testar singularidade. TODAS as entradas A/B sao validadas antes: NaN/Inf gera Sun:InvalidArgument mesmo se B nao tem colunas. Singularidade numerica gera Sun:SingularMatrix em solve/inv e retorna 0 em det. A nao quadrada ou linhas A/B incompativeis geram Sun:IncompatibleDimensions.

Solucao/inversa calculada nao finita gera Sun:InvalidArgument; fatores LU normalizados nao finitos ou faixa de escala irrepresentavel geram Sun:LinearAlgebraRange. Sao chamadas puras de uma saida em parfor suportado (escritas indexadas reais prealocadas, sem fatias/reducoes ou MultiAssign). LLVM nativo e ABI C permanecem iguais: use sun run.

The positive scale for each nonzero column is min(maxAbs, minNonzeroAbs/MIN_POSITIVE), as for lu; a zero column uses 1. Numerical singularity tests each normalized pivot: |Ujj_scaled|<=n*eps*(maxAbs(Acolj)/scalej). This replaces the old global-Amax tolerance: independent column units do not falsely reject diag([1e200,1e-200]). The cutoff is not user-configurable and is NOT the SVD rank/lsqminnorm/pinv tolerance. After equilibration, solve may accept a system that default rank(A) regards as deficient; this is a column-units policy, not a guarantee of accuracy or conditioning.

det combines the LU row-permutation sign with libm frexp/scalbn mantissa/exponent accumulation, avoiding INTERMEDIATE overflow/underflow. For diagonal entries [1e200,1e200,1e-200,1e-200], det is approximately 1 regardless of the ordering. Real FINAL overflow gives signed Inf and final underflow gives signed zero; both are valid Number results. Zero also represents numerical singularity, so det is not a rank test. There are no bitwise or exact float-format guarantees; test residuals, shapes and relative invariants.

A escala positiva de cada coluna nao nula e min(maxAbs, minNonzeroAbs/MIN_POSITIVE), como em lu; coluna nula usa 1. Singularidade numerica testa cada pivo normalizado: |Ujj_scaled|<=n*eps*(maxAbs(Acolj)/scalej). Substitui a antiga tolerancia global de Amax: unidades independentes nao rejeitam falsamente diag([1e200,1e-200]). O corte nao e configuravel e NAO e a tolerancia SVD de rank/lsqminnorm/pinv. Apos equilibracao, solve pode aceitar um sistema que rank(A) padrao considera deficiente; e politica de unidades por coluna, nao garantia de precisao ou condicionamento.

det combina o sinal da permutacao de linhas LU com acumulacao de mantissa/expoente libm frexp/scalbn, evitando overflow/underflow INTERMEDIARIO. Para entradas diagonais [1e200,1e200,1e-200,1e-200], det fica aproximadamente 1 independentemente da ordem. Overflow FINAL real produz Inf com sinal e underflow final produz zero com sinal; ambos sao Number validos. Zero tambem representa singularidade numerica, portanto det nao testa posto. Sem garantias bit a bit ou de formato flutuante exato; teste residuos, formas e invariantes relativos.

Every result should be true. Relative checks preserve sensitivity to tiny entries; no exact floating factors are required.

A = [0,2;3,4];
expected = [1,2;3,4];
B = A*expected;
X = solve(A,B);
disp(all(size(X)==[2,2]) && all(abs(X-expected)<1e-12) && all(abs(A*X-B)<1e-12));
Z = inv(A);
disp(all(abs(A*Z-eye(2))<1e-12) && all(abs(Z*A-eye(2))<1e-12));
disp(abs(det(A)+6)<1e-12);
D = [1e200,0;0,1e-200];
X = solve(D,[1e200,2e200;3e-200,4e-200]);
disp(all(abs(X-[1,2;3,4])<1e-12));
Z = inv(D);
disp(abs(Z(1,1)/1e-200-1)<1e-12 && abs(Z(2,2)/1e200-1)<1e-12);
disp(abs(det(D)-1)<1e-12);
X = solve(eye(2),[1e250;1e-100]);
disp(abs(X(1)/1e250-1)<1e-12 && abs(X(2)/1e-100-1)<1e-12);
scale = 2^(-600);
tiny = realmin*eps;
expected = 2^(-475);
X = solve([scale,scale;scale,-scale],[tiny;0]);
disp(all(abs(X/expected-[1;1])<1e-12));
X = solve([1,0;0,1e-100],[1e250;1e-100]);
disp(abs(X(1)/1e250-1)<1e-12 && abs(X(2)-1)<1e-12);
E = [1,0;0,1e-20];
disp(rank(E)==1 && all(abs(solve(E,[1;1e-20])-[1;1])<1e-12));
output = zeros(1,2);
parfor index = 1:2
    output(index) = det(A);
end
disp(all(abs(output+6)<1e-12));

Todos os resultados devem ser true. Zero por underflow nao prova singularidade; erros sao conferidos com switch, sem igualdade de strings.

A = [1e200,0,0,0;0,1e200,0,0;0,0,1e-200,0;0,0,0,1e-200];
disp(abs(det(A)-1)<1e-12);
B = [1e-200,0,0,0;0,1e-200,0,0;0,0,1e200,0;0,0,0,1e200];
disp(abs(det(B)-1)<1e-12);
scale = 2^(-600);
tiny = realmin*eps;
expected = 2^(-475);
X = solve([scale,scale;scale,-scale],[tiny;0]);
disp(all(abs(X/expected-[1;1])<1e-12));
X = solve([1,0;0,1e-100],[1e250;1e-100]);
disp(abs(X(1)/1e250-1)<1e-12 && abs(X(2)-1)<1e-12);
disp(det([-1e200,0;0,1e200])==-Inf);
disp(det([-1e-200,0;0,1e-200])==0);
disp(det(zeros(0,0))==1 && all(size(inv(zeros(0,0)))==[0,0]));
disp(all(size(solve(zeros(0,0),zeros(0,3)))==[0,3]));
S = [1,2;2,4];
disp(det(S)==0 && all(size(solve(S,zeros(2,0)))==[2,0]));
matched = false;
try
    solve(S,[1;2]);
catch failure
    switch failure.identifier
        case 'Sun:SingularMatrix'
            matched = true;
    end
end
disp(matched);
matched = false;
try
    inv(S);
catch failure
    switch failure.identifier
        case 'Sun:SingularMatrix'
            matched = true;
    end
end
disp(matched);
matched = false;
try
    solve([NaN],zeros(1,0));
catch failure
    switch failure.identifier
        case 'Sun:InvalidArgument'
            matched = true;
    end
end
disp(matched);

lu(A) accepts exactly one dense REAL MATRIX m-by-n argument, including rectangular and singular matrices; singular factorization is valid, not an error. Let k=min(m,n). One output is packed m-by-n: strict lower entries store L multipliers, diagonal and upper entries store U; the unit diagonal of L is implicit and no permutation is returned. It is not U alone.

[L,U]=lu(A) returns L m-by-k and U k-by-n with A=L*U. L absorbs the inverse row permutation and may not be triangular. [L,U,P]=lu(A) returns unit lower trapezoidal L m-by-k, upper trapezoidal U k-by-n and permutation matrix P m-by-m with P*A=L*U. No string flags, extra arguments, 'vector' or pivot-vector LU are supported.

nalgebra partial row pivoting uses positive per-column scaling, then rescales U to original units. Masks skip materializing discarded L/U/P; a requested m-by-m P must pass the 16,777,216-element/dimension limit before decomposition. Empty shapes follow the same formulas, with P the m-by-m identity. Pivot ties and exact floating factors are not compatibility guarantees.

lu(A) aceita exatamente um argumento MATRIZ REAL DENSA m por n, inclusive retangular ou singular; fatorar uma singular e valido, nao erro. Seja k=min(m,n). Uma saida e compactada m por n: abaixo da diagonal ficam multiplicadores de L; na diagonal e acima fica U. A diagonal unitaria de L e implicita e nenhuma permutacao e retornada. Nao e U isolada.

[L,U]=lu(A) retorna L m por k e U k por n com A=L*U; L absorve a permutacao inversa de linhas e pode nao ser triangular. [L,U,P]=lu(A) retorna L triangular inferior trapezoidal unitaria m por k, U superior trapezoidal k por n e P m por m com P*A=L*U. Sem flags de texto, argumentos extras, 'vector' ou vetor de pivos.

O pivoteamento parcial de linhas usa nalgebra, escala positiva por coluna e U reescalada. Mascaras evitam materializar L/U/P descartados; P solicitada passa pelo limite de 16.777.216 elementos/eixo antes da decomposicao. Vazias seguem as mesmas formas, com P identidade m por m. Desempates de pivos e fatores flutuantes exatos nao sao garantidos.

chol(A[,triangle]) requires a square dense REAL MATRIX n-by-n. Only exact 'upper' (default) or 'lower' is accepted. The selected triangle is mirrored to define impliedA; asymmetric entries in the unselected half are ignored, but ALL input must be finite, even that unused half. One output is upper R with R.'*R=impliedA or lower L with L*L.'=impliedA.

A one-output non-positive-definite call raises Sun:NotPositiveDefinite. [factor,p]=chol(A[,triangle]) instead returns scalar Number p=0 on success, otherwise the first failed leading minor, 1-based. On failure factor is partial square (p-1)-by-(p-1), factoring the successful leading block; p=1 gives empty 0-by-0. Status catches only non-positive-definiteness: type, shape, finiteness, range and other failures remain errors. [~,p] skips materializing the output factor. Empty 0-by-0 succeeds with p=0; nonsquare empties are errors.

Positive diagonal equilibration uses D_i=sqrt(abs(diagA_i)), or 1 for a zero diagonal. nalgebra Cholesky factors the equilibrated matrix; factors return in original units. The failure index is located by bounded binary search over leading blocks using nalgebra Cholesky, not a separate factorization engine. Nonfinite normalized matrices raise Sun:LinearAlgebraRange; nonfinite factors raise Sun:InvalidArgument.

chol(A[,triangulo]) exige MATRIZ REAL DENSA quadrada n por n. Aceita somente 'upper' exato (padrao) ou 'lower'. Espelhar o triangulo selecionado define impliedA; assimetria na metade nao selecionada e ignorada, mas TODA entrada deve ser finita, inclusive a metade inutilizada. Uma saida retorna R superior com R.'*R=impliedA ou L inferior com L*L.'=impliedA.

Uma saida nao positiva definida gera Sun:NotPositiveDefinite. [fator,p]=chol(A[,triangulo]) retorna Number escalar p=0 no sucesso; caso contrario p e o primeiro menor principal lider que falhou, base 1. O fator parcial e quadrado (p-1) por (p-1), referente ao bloco lider bem-sucedido; p=1 produz 0 por 0. Status trata somente falta de positividade definida: erros de tipo, forma, finitude, faixa e outras falhas continuam erros. [~,p] evita materializar o fator de saida. Vazia 0 por 0 tem sucesso com p=0; vazias nao quadradas geram erro.

Equilibracao diagonal positiva usa D_i=sqrt(abs(diagA_i)), ou 1 se a diagonal for zero. Cholesky de nalgebra fatora a matriz equilibrada e os fatores voltam as unidades originais. O indice da falha vem de busca binaria limitada em blocos lideres usando Cholesky de nalgebra, nao de motor proprio. Matriz normalizada nao finita gera Sun:LinearAlgebraRange; fatores nao finitos geram Sun:InvalidArgument.

The positive column scale is not always maxAbs. For each nonzero column it is min(maxAbs, minNonzeroAbs/MIN_POSITIVE), where maxAbs and minNonzeroAbs are that column's largest and smallest nonzero absolute entries, and MIN_POSITIVE is the smallest positive normal floating-point value. This keeps normalized nonzeros in the normal range. If maxAbs/scale overflows with the required scale, LU raises Sun:LinearAlgebraRange instead of silently erasing small entries.

For [1e-100,1e308;0,1e-100], LU preserves the small U diagonal entry 1e-100. This range protection does not guarantee arbitrary full accuracy; floating-point rounding and backend intermediate limits still apply. All input must remain finite, and the factor/output contracts are unchanged.

A = [1e-100,1e308;0,1e-100];
[L,U] = lu(A);
disp(abs(U(1,1)/1e-100-1)<1e-12);
disp(abs(U(2,2)/1e-100-1)<1e-12);

A escala positiva por coluna nem sempre e maxAbs. Para cada coluna nao nula, usa min(maxAbs, minNonzeroAbs/MIN_POSITIVE): maxAbs e minNonzeroAbs sao o maior e o menor valor absoluto nao nulo da coluna, e MIN_POSITIVE e o menor valor positivo normal de ponto flutuante. Isso mantem os valores normalizados nao nulos na faixa normal. Se maxAbs/scale transbordar com a escala necessaria, LU gera Sun:LinearAlgebraRange em vez de apagar silenciosamente entradas pequenas.

Para [1e-100,1e308;0,1e-100], LU preserva a pequena entrada diagonal 1e-100 de U. Essa protecao de faixa nao garante precisao plena arbitraria: arredondamento e limites intermediarios do backend continuam existindo. Toda entrada deve continuar finita, e os contratos dos fatores e das saidas permanecem iguais.

Diagonal equilibration computes each entry by sequential divisions (Aij/Di)/Dj, never by forming the product Di*Dj. Rounding a subnormal product could otherwise cause a false Sun:NotPositiveDefinite. For t equal to the smallest positive subnormal floating-point value, the SPD matrix [[t,t],[t,2*t]] succeeds with status p=0.

This avoids that product-rounding failure, not all floating-point error; arbitrary full accuracy is not guaranteed. All input must remain finite, including the unused triangle. The selected-triangle, partial-factor and status contracts are unchanged; range failures remain errors rather than a non-positive-definite status.

A equilibracao diagonal calcula cada entrada por divisoes sequenciais (Aij/Di)/Dj, sem formar o produto Di*Dj. O arredondamento de um produto subnormal poderia causar um falso Sun:NotPositiveDefinite. Para t igual ao menor valor positivo subnormal de ponto flutuante, a matriz positiva definida [[t,t],[t,2*t]] tem sucesso com status p=0.

Isso evita essa falha de arredondamento do produto, nao todos os erros de ponto flutuante; nao ha garantia de precisao plena arbitraria. Toda entrada deve continuar finita, inclusive o triangulo inutilizado. Os contratos de triangulo selecionado, fator parcial e status permanecem iguais; falhas de faixa continuam erros, nao status de falta de positividade definida.

Every result should be true. Verify reconstruction and shapes, not exact floating factors or pivot ties.

A = [0,2;3,4;6,8];
packed = lu(A);
[L,U] = lu(A);
disp(all(size(packed)==[3,2]) && all(size(L)==[3,2]) && all(size(U)==[2,2]));
disp(all(abs(A-L*U)<1e-10));
[Lp,Up,P] = lu(A);
disp(all(size(P)==[3,3]) && all(abs(P*A-Lp*Up)<1e-10));
disp(all(abs(P.'*P-eye(3))<1e-10));
[~,Uonly,~] = lu(A);
disp(all(abs(Uonly-Up)<1e-10));
[S,T] = lu([1,2;2,4]);
disp(all(abs(S*T-[1,2;2,4])<1e-10));
W = [0,2,1;3,4,5];
[Lw,Uw,Pw] = lu(W);
disp(all(size(Lw)==[2,2]) && all(size(Uw)==[2,3]) && all(abs(Pw*W-Lw*Uw)<1e-10));

Todos os resultados devem ser true. A metade nao selecionada e assimetrica de proposito; verifique a matriz simetrica implicita, nao a entrada inteira.

A = [4,2;99,3];
R = chol(A);
disp(all(abs(R.'*R-[4,2;2,3])<1e-10));
[L,p] = chol(A,'lower');
disp(p==2 && all(size(L)==[1,1]) && abs(L(1,1)*L(1,1)-4)<1e-10);
B = [4,99;2,3];
L = chol(B,'lower');
disp(all(abs(L*L.'-[4,2;2,3])<1e-10));
[R,p] = chol([4,2;2,3],'upper');
disp(p==0 && all(abs(R.'*R-[4,2;2,3])<1e-10));
[~,p] = chol([1,0,0;0,-1,0;0,0,2]);
disp(p==2);
[F,p] = chol([0]);
disp(p==1 && all(size(F)==[0,0]));
[E,p] = chol(zeros(0,0));
disp(p==0 && all(size(E)==[0,0]));
matched = false;
try
    chol([-1]);
catch failure
    switch failure.identifier
        case 'Sun:NotPositiveDefinite'
            matched = true;
    end
end
disp(matched);
matched = false;
try
    [~,p] = chol([4,2;Inf,3]);
catch failure
    switch failure.identifier
        case 'Sun:InvalidArgument'
            matched = true;
    end
end
disp(matched);

For A m-by-n, k=min(m,n). One or two outputs are unpivoted: [Q,R]=qr(A) gives Q m-by-m and R m-by-n; qr(A,0) gives Q m-by-k and R k-by-n. Q*R reconstructs A; Q.'*Q is identity and R is upper trapezoidal. One output returns only the corresponding R, not Q.

Three output positions activate pivoting, even if the third is ~. [Q,R,P]=qr(A) returns full factors and an n-by-n permutation matrix with A*P=Q*R. [Q,R,p]=qr(A,0) returns economy factors and a 1-by-n row of 1-based indices with A(:,p)=Q*R. ~ skips discarded Q/P allocations without disabling pivoting. Only the real numeric scalar 0 selects economy; false, [] and all string flags, including 'econ', are unsupported. Signs and pivot tie ordering are not guaranteed. QR does not return numerical rank; use rank.

Para A m por n, k=min(m,n). Uma ou duas saidas nao usam pivoteamento: [Q,R]=qr(A) retorna Q m por m e R m por n; qr(A,0) retorna Q m por k e R k por n. Q*R reconstroi A, Q.'*Q e identidade e R e triangular superior trapezoidal. Uma saida retorna somente R, nao Q.

Tres posicoes de saida ativam pivoteamento, mesmo com ~ na terceira. [Q,R,P]=qr(A) satisfaz A*P=Q*R com P n por n; [Q,R,p]=qr(A,0) satisfaz A(:,p)=Q*R com p linha 1 por n de indices base 1. ~ evita alocar Q/P descartados sem desativar pivoteamento. Somente o escalar numerico real 0 seleciona a forma economica; false, [] e flags de texto, inclusive 'econ', nao sao aceitos. Sinais e desempate dos pivos nao sao garantidos. QR nao retorna posto numerico; use rank.

s=svd(A) returns a k-by-1 column of nonnegative singular values sorted in descending order, without computing singular vectors. [U,S,V]=svd(A) returns full U m-by-m, rectangular diagonal S m-by-n and V n-by-n, with A=U*S*V.'. [U,S]=svd(A) is valid and uses the same U/S shapes.

svd(A,0) and svd(A,'econ') both return economy U m-by-k, diagonal S k-by-k and V n-by-k for tall and wide matrices. Two outputs keep the same economy U/S; one output keeps the same singular-value column. Only numeric 0 or exact 'econ' are accepted; booleans, 'vector', 'matrix' and algorithm flags are unsupported. ~ skips unrequested factors and unnecessary singular vectors. Signs and bases for repeated singular values are not guaranteed.

For empty A, s is 0-by-1. Full U/V are m-by-m/n-by-n identities and S is m-by-n zeros; economy U/V are truncated identities m-by-k/n-by-k and S is k-by-k zeros.

s=svd(A) retorna coluna k por 1 de valores singulares nao negativos em ordem decrescente, sem calcular vetores singulares. [U,S,V]=svd(A) retorna U m por m, S diagonal retangular m por n e V n por n, com A=U*S*V.'. [U,S]=svd(A) e valido e mantem as mesmas formas de U/S.

svd(A,0) e svd(A,'econ') retornam U m por k, S diagonal k por k e V n por k tanto para matrizes altas quanto largas. Duas saidas mantem U/S economicos; uma retorna os mesmos valores singulares. Aceita somente 0 numerico ou 'econ' exato, nao booleanos, 'vector', 'matrix' ou flags de algoritmo. ~ evita fatores e vetores singulares desnecessarios. Sinais e bases de subespacos com valores singulares repetidos nao sao garantidos.

Para A vazia, s e 0 por 1. U/V completos sao identidades m por m/n por n e S e zero m por n; na forma economica U/V sao identidades truncadas m por k/n por k e S e zero k por k.

lsqminnorm(A,B[,tol]) uses SVD, not normal equations, for real dense A m-by-n and B m-by-p, returning X n-by-p. Tall, wide, square, rank-deficient and multiple-right-hand-side systems are supported. It minimizes each residual's Euclidean norm, then the solution norm. It exposes no residual, rank, singular-value or warning outputs. solve(A,B) remains square-only; its scaled LU path is separate from SVD least squares.

pinv(A[,tol]) returns the SVD Moore-Penrose pseudoinverse n-by-m. Prefer lsqminnorm(A,B) to pinv(A)*B when solving: it avoids materializing an unnecessary pseudoinverse. Zero/empty A gives n-by-m zeros. Least squares gives n-by-p zeros when A has no rows, A is zero or B is zero; A with no columns gives 0-by-p.

lsqminnorm(A,B[,tol]) usa SVD, nao equacoes normais: A real densa m por n e B m por p produzem X n por p. Aceita matrizes altas, largas, quadradas, deficientes em posto e multiplos lados direitos. Minimiza a norma euclidiana de cada residuo e depois a da solucao. Nao retorna residuos, posto, valores singulares ou avisos adicionais. solve(A,B) continua restrito a A quadrada; sua LU escalada e separada dos minimos quadrados por SVD.

pinv(A[,tol]) retorna a pseudoinversa de Moore-Penrose por SVD n por m. Para resolver sistemas, prefira lsqminnorm(A,B) a pinv(A)*B, evitando materializar a pseudoinversa desnecessaria. A nula/vazia retorna zeros n por m. Minimos quadrados retorna zeros n por p se A nao tem linhas, A e nula ou B e nula; A sem colunas retorna 0 por p.

rank(A[,tol]) returns a scalar Number counting sigma > tol, without singular vectors; empty and zero rank is 0. rank, lsqminnorm and pinv share an absolute default cutoff max(m,n)*eps*sigma_max and discard sigma <= tol. Explicit tol is a finite nonnegative real Number, not a boolean or 1-by-1 matrix. tol=0 is allowed: it removes the intentional cutoff, not floating-point limitations or range checks.

cond(A) and cond(A,2) return a scalar Number: the raw sigma_max/sigma_min ratio, including rectangular matrices, without singular vectors or rank cutoff. Empty returns 0; nonempty zero matrices or exactly zero computed sigma_min return Inf. A numerically rank-deficient matrix may still have a very large finite condition number. Other norms and string flags are unsupported.

rank(A[,tol]) retorna Number escalar contando sigma > tol, sem vetores singulares; posto de matrizes vazias e nulas e 0. rank, lsqminnorm e pinv compartilham limiar absoluto padrao max(m,n)*eps*sigma_max e descartam sigma <= tol. tol explicito deve ser Number real finito nao negativo, nao booleano nem matriz 1 por 1. tol=0 e permitido: remove o corte intencional, nao as limitacoes numericas nem as verificacoes de faixa.

cond(A) e cond(A,2) retornam Number escalar com a razao bruta sigma_max/sigma_min, inclusive para retangulares, sem vetores singulares nem corte de posto. Vazia retorna 0; nula nao vazia ou sigma_min calculado exatamente zero retorna Inf. Uma matriz numericamente deficiente pode ter condicao finita muito grande. Outras normas e flags de texto nao sao aceitas.

All eight factorization/diagnostic functions, plus solve/inv/det, require dense REAL MATRIX inputs, including [2]; Number, logical, complex, string and handle inputs are not implicitly converted. Convert logical data explicitly with double. NaN/Inf inputs and nonfinite computed matrix outputs raise Sun:InvalidArgument; documented scalar Inf condition numbers and final determinant Inf/zero remain valid. Nonfinite normalized matrices raise Sun:LinearAlgebraRange. A/B row mismatch raises Sun:IncompatibleDimensions. Bounded SVD nonconvergence raises Sun:DecompositionFailed; extreme scales can raise Sun:LinearAlgebraRange, even for mathematically finite results.

Requested output axes and element counts are checked against 16,777,216 before factor allocation. Full Q, P, U or V can exceed the limit even when A fits; economy forms and ~ avoid unrequested full allocations. This is not a total memory/time quota. Full empty QR uses identity Q m-by-m and zero R m-by-n; economy uses Q m-by-k and R k-by-n. Failed multiple-output validation leaves all destinations intact. Cancellation is checked around calls, not inside backend decompositions. Square solve, inv and det now share protected column-scaled nalgebra LU; their single-output shapes remain stable.

Use sun run: native LLVM lowering is unsupported. All eight and solve/inv/det are pure single-output calls in supported parfor bodies, but indexed preallocated real output writes are still required, no slices or loop-carried reduction are allowed, and multiple assignment (MultiAssign) remains forbidden.

As oito funcoes de fatoracao/diagnostico, mais solve/inv/det, exigem MATRIZES REAIS DENSAS, inclusive [2]; nao convertem implicitamente Number, dados logicos, complexos, texto ou handles. Converta logicos explicitamente com double. Entradas NaN/Inf e saidas matriciais calculadas nao finitas geram Sun:InvalidArgument; Inf escalar documentado de cond e Inf/zero finais de det sao validos. Matrizes normalizadas nao finitas geram Sun:LinearAlgebraRange. Linhas de A/B incompativeis geram Sun:IncompatibleDimensions. SVD tem iteracoes limitadas e gera Sun:DecompositionFailed sem convergencia; escalas extremas podem gerar Sun:LinearAlgebraRange mesmo com resultado matematicamente finito.

Eixos e contagens de elementos das saidas solicitadas sao verificados contra 16.777.216 antes de alocar fatores. Q, P, U ou V completos podem exceder o limite mesmo se A couber; formas economicas e ~ evitam alocacoes completas desnecessarias. Nao e uma cota total de memoria/tempo. QR completa vazia usa Q identidade m por m e R zero m por n; economica usa Q m por k e R k por n. Falha de validacao mantem intactos todos os destinos da atribuicao multipla. Cancelamento e verificado ao redor das chamadas, nao dentro das decomposicoes do backend. solve quadrado, inv e det agora compartilham LU de nalgebra com escalas protegidas por coluna; as formas de uma saida permanecem estaveis.

Use sun run: nao ha suporte LLVM nativo. As oito funcoes e solve/inv/det sao puras com uma saida em corpos parfor suportados, mas exigem escritas indexadas em saidas reais prealocadas, sem fatias ou reducao acumulada; atribuicao multipla (MultiAssign) continua proibida.

EN: Each result should be true: reconstruction, R-only/discarded-Q equivalence, minimum norm, absolute rank cutoff and raw condition ratio.

PT: Cada resultado deve ser true: reconstrucao, equivalencia de R isolado/Q descartado, norma minima, limiar absoluto de posto e razao bruta de condicao.

A = [1,0;1,1;1,2];
[Q,R] = qr(A);
disp(all(abs(Q*R-A)<1e-10));
Ronly = qr(A,0);
[~,Re] = qr(A,0);
disp(all(abs(Ronly-Re)<1e-10));
[Qp,Rp,P] = qr(A);
disp(all(abs(A*P-Qp*Rp)<1e-10));
[Qe,Re,p] = qr(A,0);
disp(all(abs(A(:,p)-Qe*Re)<1e-10));
X = lsqminnorm([1,1],[2,4]);
disp(all(abs(X-[1,2;1,2])<1e-10));
Xd = lsqminnorm([1,2;2,4],[3;6]);
disp(all(abs(Xd-[0.6;1.2])<1e-10));
B = [1;2;2];
Xt = lsqminnorm(A,B);
disp(all(abs(A.'*(A*Xt-B))<1e-10));
D = [1,0;0,1e-12;0,0];
disp(rank(D)==2 && rank(D,1e-10)==1);
disp(abs(cond(D)/1e12-1)<1e-10 && cond(D)==cond(D,2));

Every printed result below should be true. Checks use tolerances and identities, never exact factor signs or repeated-subspace bases.

A = [1,0;1,1;1,2];
[Q,R] = qr(A);
disp(all(abs(Q*R-A)<1e-10));
[Qe,Re] = qr(A,0);
disp(all(size(Qe)==[3,2]) && all(size(Re)==[2,2]));
[Qp,Rp,P] = qr(A);
disp(all(abs(A*P-Qp*Rp)<1e-10));
[Qpe,Rpe,p] = qr(A,0);
disp(all(abs(A(:,p)-Qpe*Rpe)<1e-10));
[U,S,V] = svd(A);
disp(all(size(U)==[3,3]) && all(size(S)==[3,2]) && all(size(V)==[2,2]));
disp(all(abs(A-U*S*V.')<1e-10));
disp(all(abs(U.'*U-eye(3))<1e-10) && all(abs(V.'*V-eye(2))<1e-10));
s = svd(A);
disp(all(size(s)==[2,1]) && all(s>=0) && s(1)>=s(2));
[~,Sonly] = svd(A);
disp(all(abs(Sonly-S)<1e-10));
W = [1,1];
[Uw,Sw,Vw] = svd(W,'econ');
disp(all(size(Uw)==[1,1]) && all(size(Sw)==[1,1]) && all(size(Vw)==[2,1]));
disp(all(abs(W-Uw*Sw*Vw.')<1e-10));
X = lsqminnorm(W,[2,4]);
disp(all(abs(X-[1,2;1,2])<1e-10));
B = [1;2;2];
Xt = lsqminnorm(A,B);
disp(all(abs(A.'*(A*Xt-B))<1e-10));
D = [1,0;0,1e-12;0,0];
disp(rank(D)==2 && rank(D,1e-10)==1);
disp(abs(cond(D)/1e12-1)<1e-10 && cond(D)==cond(D,2));
Z = pinv(A);
disp(all(size(Z)==[2,3]) && all(abs(A*Z*A-A)<1e-10));
disp(all(abs(Z*A*Z-Z)<1e-10));
disp(all(abs((A*Z).'-A*Z)<1e-10) && all(abs((Z*A).'-Z*A)<1e-10));

Todos os resultados impressos devem ser true. Os exemplos verificam propriedades e formas, nao fatores impressos exatos; svd_pseudoinversa.sun e o exemplo complementar da distribuicao Sun.

A = [1,2;2,4];
B = [3,6;6,12];
X = lsqminnorm(A,B);
disp(all(abs(X-[0.6,1.2;1.2,2.4])<1e-10));
[U,S] = svd(A,0);
disp(all(size(U)==[2,2]) && all(size(S)==[2,2]));
T = [1,0;0,1e-12;0,0];
[Ut,St,Vt] = svd(T,'econ');
disp(all(size(Ut)==[3,2]) && all(size(St)==[2,2]) && all(size(Vt)==[2,2]));
disp(all(abs(T-Ut*St*Vt.')<1e-10));
disp(all(abs(svd(T,0)-svd(T,'econ'))<1e-10));
Z = pinv(T,1e-10);
disp(all(abs(Z-[1,0,0;0,0,0])<1e-10));
Xt = lsqminnorm(T,[1;1;0],1e-10);
disp(all(abs(Xt-[1;0])<1e-10) && rank(T,0)==2);
E = zeros(3,0);
[Ue,Se,Ve] = svd(E);
disp(all(Ue==eye(3)) && all(size(Se)==[3,0]) && all(size(Ve)==[0,0]));
[U0,S0,V0] = svd(E,0);
disp(all(size(U0)==[3,0]) && all(size(S0)==[0,0]) && all(size(V0)==[0,0]));
disp(all(size(svd(E))==[0,1]) && all(size(pinv(E))==[0,3]));
disp(rank(E)==0 && cond(E)==0 && cond(zeros(2,2))==Inf);
disp(all(size(pinv(zeros(2,3)))==[3,2]) && all(pinv(zeros(2,3))==0));
output = zeros(1,2);
parfor index = 1:2
    output(index) = rank(A);
end
disp(all(output==1));