Linear Algebra

NoPivot

No se realiza pivoteo. Las factorizaciones de matrices, como la factorización LU, pueden fallar sin pivoteo y también pueden ser numéricamente inestables para matrices de punto flotante ante errores de redondeo. Esta estrategia de pivoteo es principalmente útil con fines pedagógicos.

RowNonZero

El primer elemento no cero en las filas restantes se elige como el elemento pivote.

Ten en cuenta que para matrices de punto flotante, el algoritmo LU resultante es numéricamente inestable; esta estrategia es principalmente útil para la comparación con cálculos manuales (que típicamente utilizan esta estrategia) o para otros tipos algebraicos (por ejemplo, números racionales) que no son susceptibles a errores de redondeo. De lo contrario, la estrategia de pivoteo por defecto RowMaximum debería ser generalmente preferida en la eliminación de Gauss.

Ten en cuenta que el tipo de elemento de la matriz debe admitir un método iszero.

RowMaximum

El elemento de máxima magnitud en las filas restantes se elige como el elemento pivote. Esta es la estrategia predeterminada para la factorización LU de matrices de punto flotante, y a veces se refiere como el algoritmo de "pivoteo parcial".

Tenga en cuenta que el tipo de elemento de la matriz debe admitir un método abs, cuyo tipo de resultado debe admitir un método <.

ColumnNorm

La columna con la norma máxima se utiliza para el cálculo subsiguiente. Esto se utiliza para la factorización QR con pivoteo.

Tenga en cuenta que el tipo de elemento de la matriz debe admitir los métodos norm y abs, cuyos tipos de resultado respectivos deben admitir un método <.

*(A::AbstractMatrix, B::AbstractMatrix)

Multiplicación de matrices.

Ejemplos

julia> [1 1; 0 1] * [1 0; 1 1]
2×2 Matrix{Int64}:
 2  1
 1  1

*(A, B::AbstractMatrix, C)
A * B * C * D

La multiplicación encadenada de 3 o 4 matrices se realiza en la secuencia más eficiente, basada en los tamaños de los arreglos. Es decir, se compara el número de multiplicaciones escalares necesarias para (A * B) * C (con 3 matrices densas) con el de A * (B * C) para elegir cuál de estas ejecutar.

Si el último factor es un vector, o el primero un vector transpuesto, entonces es eficiente tratar con estos primero. En particular, x' * B * y significa (x' * B) * y para una B::Matrix ordinaria en orden de columna. A diferencia de dot(x, B, y), esto asigna un arreglo intermedio.

Si el primer o último factor es un número, esto se fusionará con la multiplicación de matrices, utilizando mul! de 5 argumentos.

Véase también muladd, dot.

\(A, B)

División de matrices utilizando un polialgoritmo. Para las matrices de entrada A y B, el resultado X es tal que A*X == B cuando A es cuadrada. El solucionador que se utiliza depende de la estructura de A. Si A es triangular superior o inferior (o diagonal), no se requiere factorización de A y el sistema se resuelve con sustitución hacia adelante o hacia atrás. Para matrices cuadradas no triangulares, se utiliza una factorización LU.

Para A rectangular, el resultado es la solución de mínimos cuadrados de norma mínima calculada mediante una factorización QR con pivoteo de A y una estimación de rango de A basada en el factor R.

Cuando A es dispersa, se utiliza un polialgoritmo similar. Para matrices indefinidas, la factorización LDLt no utiliza pivoteo durante la factorización numérica y, por lo tanto, el procedimiento puede fallar incluso para matrices invertibles.

Ver también: factorize, pinv.

Ejemplos

julia> A = [1 0; 1 -2]; B = [32; -4];

julia> X = A \ B
2-element Vector{Float64}:
 32.0
 18.0

julia> A * X == B
true

A / B

División a la derecha de matrices: A / B es equivalente a (B' \ A')' donde \ es el operador de división a la izquierda. Para matrices cuadradas, el resultado X es tal que A == X*B.

Véase también: rdiv!.

Ejemplos

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

SingularException

Excepción lanzada cuando la matriz de entrada tiene uno o más valores propios de valor cero y no es invertible. No se puede calcular una solución lineal que involucre tal matriz. El campo info indica la ubicación de (uno de) los valores singulares.

PosDefException

Excepción lanzada cuando la matriz de entrada no era definida positiva. Algunas funciones de álgebra lineal y factorizaciones solo son aplicables a matrices definidas positivas. El campo info indica la ubicación de (uno de) los valores propios que es (son) menor(es) o igual a 0.

ZeroPivotException <: Exception

Excepción lanzada cuando una factorización/resolución de matriz encuentra un cero en una posición de pivote (diagonal) y no puede continuar. Esto no significa necesariamente que la matriz sea singular: puede ser útil cambiar a una factorización diferente, como LU con pivoteo, que puede reordenar variables para eliminar pivotes cero espurios. El campo info indica la ubicación de (uno de) los pivotes cero.

RankDeficientException

Excepción lanzada cuando la matriz de entrada es deficiente en rango. Algunas funciones de álgebra lineal, como la descomposición de Cholesky, solo son aplicables a matrices que no son deficientes en rango. El campo info indica el rango calculado de la matriz.

LAPACKException

Excepción genérica de LAPACK lanzada ya sea durante llamadas directas a las funciones LAPACK o durante llamadas a otras funciones que utilizan las funciones LAPACK internamente pero carecen de un manejo de errores especializado. El campo info contiene información adicional sobre el error subyacente y depende de la función LAPACK que fue invocada.

dot(x, y)
x ⋅ y

Calcula el producto punto entre dos vectores. Para vectores complejos, el primer vector se conjuga.

dot también funciona en objetos iterables arbitrarios, incluyendo arreglos de cualquier dimensión, siempre que dot esté definido en los elementos.

dot es semánticamente equivalente a sum(dot(vx,vy) for (vx,vy) in zip(x, y)), con la restricción adicional de que los argumentos deben tener longitudes iguales.

x ⋅ y (donde ⋅ se puede escribir completando con tabulador \cdot en el REPL) es un sinónimo de dot(x, y).

Ejemplos

julia> dot([1; 1], [2; 3])
5

julia> dot([im; im], [1; 1])
0 - 2im

julia> dot(1:5, 2:6)
70

julia> x = fill(2., (5,5));

julia> y = fill(3., (5,5));

julia> dot(x, y)
150.0

dot(x, A, y)

Calcula el producto punto generalizado dot(x, A*y) entre dos vectores x y y, sin almacenar el resultado intermedio de A*y. Al igual que para el dot(_,_) de dos argumentos, esto actúa de manera recursiva. Además, para vectores complejos, el primer vector se conjuga.

Ejemplos

julia> dot([1; 1], [1 2; 3 4], [2; 3])
26

julia> dot(1:5, reshape(1:25, 5, 5), 2:6)
4850

julia> ⋅(1:5, reshape(1:25, 5, 5), 2:6) == dot(1:5, reshape(1:25, 5, 5), 2:6)
true

cross(x, y)
×(x,y)

Calcula el producto cruzado de dos vectores de 3 dimensiones.

Ejemplos

julia> a = [0;1;0]
3-element Vector{Int64}:
 0
 1
 0

julia> b = [0;0;1]
3-element Vector{Int64}:
 0
 0
 1

julia> cross(a,b)
3-element Vector{Int64}:
 1
 0
 0

axpy!(α, x::AbstractArray, y::AbstractArray)

Sobrescribe y con x * α + y y devuelve y. Si x y y tienen los mismos ejes, es equivalente a y .+= x .* a.

Ejemplos

julia> x = [1; 2; 3];

julia> y = [4; 5; 6];

julia> axpy!(2, x, y)
3-element Vector{Int64}:
  6
  9
 12

axpby!(α, x::AbstractArray, β, y::AbstractArray)

Sobrescribe y con x * α + y * β y devuelve y. Si x y y tienen los mismos ejes, es equivalente a y .= x .* a .+ y .* β.

Ejemplos

julia> x = [1; 2; 3];

julia> y = [4; 5; 6];

julia> axpby!(2, x, 2, y)
3-element Vector{Int64}:
 10
 14
 18

rotate!(x, y, c, s)

Sobrescribe x con c*x + s*y y y con -conj(s)*x + c*y. Devuelve x y y.

reflect!(x, y, c, s)

Sobrescribe x con c*x + s*y y y con conj(s)*x - c*y. Devuelve x y y.

factorizar(A)

Calcula una factorización conveniente de A, basada en el tipo de la matriz de entrada. factorizar verifica A para ver si es simétrica/triangular/etc. si A se pasa como una matriz genérica. factorizar revisa cada elemento de A para verificar/desestimar cada propiedad. Se detendrá tan pronto como pueda descartar la simetría/estructura triangular. El valor de retorno se puede reutilizar para resolver de manera eficiente múltiples sistemas. Por ejemplo: A=factorizar(A); x=A\b; y=A\C.

Si factorizar se llama en una matriz hermítica positiva-definida, por ejemplo, entonces factorizar devolverá una factorización de Cholesky.

Ejemplos

julia> A = Array(Bidiagonal(fill(1.0, (5, 5)), :U))
5×5 Matrix{Float64}:
 1.0  1.0  0.0  0.0  0.0
 0.0  1.0  1.0  0.0  0.0
 0.0  0.0  1.0  1.0  0.0
 0.0  0.0  0.0  1.0  1.0
 0.0  0.0  0.0  0.0  1.0

julia> factorizar(A) # factorizar verificará si A ya está factorizada
5×5 Bidiagonal{Float64, Vector{Float64}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

Esto devuelve un 5×5 Bidiagonal{Float64}, que ahora se puede pasar a otras funciones de álgebra lineal (por ejemplo, solucionadores de eigenvalores) que utilizarán métodos especializados para tipos Bidiagonal.

Diagonal(V::AbstractVector)

Construye una matriz perezosa con V como su diagonal.

Véase también UniformScaling para la matriz identidad perezosa I, diagm para hacer una matriz densa, y diag para extraer elementos diagonales.

Ejemplos

julia> d = Diagonal([1, 10, 100])
3×3 Diagonal{Int64, Vector{Int64}}:
 1   ⋅    ⋅
 ⋅  10    ⋅
 ⋅   ⋅  100

julia> diagm([7, 13])
2×2 Matrix{Int64}:
 7   0
 0  13

julia> ans + I
2×2 Matrix{Int64}:
 8   0
 0  14

julia> I(2)
2×2 Diagonal{Bool, Vector{Bool}}:
 1  ⋅
 ⋅  1

julia> A = transpose([7.0 13.0])
2×1 transpose(::Matrix{Float64}) con el tipo de elemento Float64:
  7.0
 13.0

julia> Diagonal(A)
1×1 Diagonal{Float64, Vector{Float64}}:
 7.0

Diagonal(A::AbstractMatrix)

Construye una matriz a partir de la diagonal principal de A. La matriz de entrada A puede ser rectangular, pero la salida será cuadrada.

Ejemplos

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> D = Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  4

julia> A = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  5

Diagonal{T}(undef, n)

Construye un Diagonal{T} no inicializado de longitud n. Ver undef.

Bidiagonal(dv::V, ev::V, uplo::Symbol) donde V <: AbstractVector

Construye una matriz bidiagonal superior (uplo=:U) o inferior (uplo=:L) utilizando los vectores diagonales dados (dv) y off-diagonales (ev). El resultado es de tipo Bidiagonal y proporciona solucionadores lineales especializados eficientes, pero puede ser convertido en una matriz regular con convert(Array, _) (o Array(_) para abreviar). La longitud de ev debe ser una menos que la longitud de dv.

Ejemplos

julia> dv = [1, 2, 3, 4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> ev = [7, 8, 9]
3-element Vector{Int64}:
 7
 8
 9

julia> Bu = Bidiagonal(dv, ev, :U) # ev está en la primera superdiagonal
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

julia> Bl = Bidiagonal(dv, ev, :L) # ev está en la primera subdiagonal
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 7  2  ⋅  ⋅
 ⋅  8  3  ⋅
 ⋅  ⋅  9  4

Bidiagonal(A, uplo::Symbol)

Construye una matriz Bidiagonal a partir de la diagonal principal de A y su primera superdiagonal (si uplo=:U) o subdiagonal (si uplo=:L).

Ejemplos

julia> A = [1 1 1 1; 2 2 2 2; 3 3 3 3; 4 4 4 4]
4×4 Matrix{Int64}:
 1  1  1  1
 2  2  2  2
 3  3  3  3
 4  4  4  4

julia> Bidiagonal(A, :U) # contiene la diagonal principal y la primera superdiagonal de A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

julia> Bidiagonal(A, :L) # contiene la diagonal principal y la primera subdiagonal de A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 2  2  ⋅  ⋅
 ⋅  3  3  ⋅
 ⋅  ⋅  4  4

SymTridiagonal(dv::V, ev::V) donde V <: AbstractVector

Construye una matriz tridiagonal simétrica a partir de la diagonal (dv) y la primera sub/super-diagonal (ev), respectivamente. El resultado es de tipo SymTridiagonal y proporciona solucionadores de eigenvalores especializados y eficientes, pero puede ser convertido en una matriz regular con convert(Array, _) (o Array(_) para abreviar).

Para las matrices de bloques SymTridiagonal, los elementos de dv son simetrizados. El argumento ev se interpreta como la superdiagonal. Los bloques de la subdiagonal son la transposición (materializada) de los bloques correspondientes de la superdiagonal.

Ejemplos

julia> dv = [1, 2, 3, 4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> ev = [7, 8, 9]
3-element Vector{Int64}:
 7
 8
 9

julia> SymTridiagonal(dv, ev)
4×4 SymTridiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 7  2  8  ⋅
 ⋅  8  3  9
 ⋅  ⋅  9  4

julia> A = SymTridiagonal(fill([1 2; 3 4], 3), fill([1 2; 3 4], 2));

julia> A[1,1]
2×2 Symmetric{Int64, Matrix{Int64}}:
 1  2
 2  4

julia> A[1,2]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> A[2,1]
2×2 Matrix{Int64}:
 1  3
 2  4

SymTridiagonal(A::AbstractMatrix)

Construye una matriz tridiagonal simétrica a partir de la diagonal y la primera superdiagonal de la matriz simétrica A.

Ejemplos

julia> A = [1 2 3; 2 4 5; 3 5 6]
3×3 Matrix{Int64}:
 1  2  3
 2  4  5
 3  5  6

julia> SymTridiagonal(A)
3×3 SymTridiagonal{Int64, Vector{Int64}}:
 1  2  ⋅
 2  4  5
 ⋅  5  6

julia> B = reshape([[1 2; 2 3], [1 2; 3 4], [1 3; 2 4], [1 2; 2 3]], 2, 2);

julia> SymTridiagonal(B)
2×2 SymTridiagonal{Matrix{Int64}, Vector{Matrix{Int64}}}:
 [1 2; 2 3]  [1 3; 2 4]
 [1 2; 3 4]  [1 2; 2 3]

Tridiagonal(dl::V, d::V, du::V) donde V <: AbstractVector

Construye una matriz tridiagonal a partir de la primera subdiagonal, diagonal y primera superdiagonal, respectivamente. El resultado es de tipo Tridiagonal y proporciona solucionadores lineales especializados eficientes, pero puede convertirse en una matriz regular con convert(Array, _) (o Array(_) para abreviar). Las longitudes de dl y du deben ser una menos que la longitud de d.

Ejemplos

julia> dl = [1, 2, 3];

julia> du = [4, 5, 6];

julia> d = [7, 8, 9, 0];

julia> Tridiagonal(dl, d, du)
4×4 Tridiagonal{Int64, Vector{Int64}}:
 7  4  ⋅  ⋅
 1  8  5  ⋅
 ⋅  2  9  6
 ⋅  ⋅  3  0

Tridiagonal(A)

Construye una matriz tridiagonal a partir de la primera sub-diagonal, la diagonal y la primera super-diagonal de la matriz A.

Ejemplos

julia> A = [1 2 3 4; 1 2 3 4; 1 2 3 4; 1 2 3 4]
4×4 Matrix{Int64}:
 1  2  3  4
 1  2  3  4
 1  2  3  4
 1  2  3  4

julia> Tridiagonal(A)
4×4 Tridiagonal{Int64, Vector{Int64}}:
 1  2  ⋅  ⋅
 1  2  3  ⋅
 ⋅  2  3  4
 ⋅  ⋅  3  4

Simétrico(A::AbstractMatrix, uplo::Symbol=:U)

Construye una vista Simétrico del triángulo superior (si uplo = :U) o inferior (si uplo = :L) de la matriz A.

Las vistas Simétrico son principalmente útiles para matrices simétricas reales, para las cuales se habilitan algoritmos especializados (por ejemplo, para problemas de autovalores) para los tipos Simétrico. Más generalmente, véase también Hermitiano(A) para matrices hermitianas A == A', que es efectivamente equivalente a Simétrico para matrices reales, pero también es útil para matrices complejas. (Mientras que las matrices Simétrico complejas son compatibles, tienen pocos o ningún algoritmo especializado).

Para calcular la parte simétrica de una matriz real, o más generalmente la parte hermitiana (A + A') / 2 de una matriz real o compleja A, use hermitianpart.

Ejemplos

julia> A = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> Supper = Simétrico(A)
3×3 Simétrico{Int64, Matrix{Int64}}:
 1  2  3
 2  5  6
 3  6  9

julia> Slower = Simétrico(A, :L)
3×3 Simétrico{Int64, Matrix{Int64}}:
 1  4  7
 4  5  8
 7  8  9

julia> hermitianpart(A)
3×3 Hermitiano{Float64, Matrix{Float64}}:
 1.0  3.0  5.0
 3.0  5.0  7.0
 5.0  7.0  9.0

Tenga en cuenta que Supper no será igual a Slower a menos que A sea simétrica (por ejemplo, si A == transpose(A)).

Hermitiano(A::AbstractMatrix, uplo::Symbol=:U)

Construye una vista Hermitiano del triángulo superior (si uplo = :U) o inferior (si uplo = :L) de la matriz A.

Para calcular la parte hermitiana de A, usa hermitianpart.

Ejemplos

julia> A = [1 2+2im 3-3im; 4 5 6-6im; 7 8+8im 9]
3×3 Matrix{Complex{Int64}}:
 1+0im  2+2im  3-3im
 4+0im  5+0im  6-6im
 7+0im  8+8im  9+0im

julia> Hupper = Hermitiano(A)
3×3 Hermitiano{Complex{Int64}, Matrix{Complex{Int64}}}:
 1+0im  2+2im  3-3im
 2-2im  5+0im  6-6im
 3+3im  6+6im  9+0im

julia> Hlower = Hermitiano(A, :L)
3×3 Hermitiano{Complex{Int64}, Matrix{Complex{Int64}}}:
 1+0im  4+0im  7+0im
 4+0im  5+0im  8-8im
 7+0im  8+8im  9+0im

julia> hermitianpart(A)
3×3 Hermitiano{ComplexF64, Matrix{ComplexF64}}:
 1.0+0.0im  3.0+1.0im  5.0-1.5im
 3.0-1.0im  5.0+0.0im  7.0-7.0im
 5.0+1.5im  7.0+7.0im  9.0+0.0im

Ten en cuenta que Hupper no será igual a Hlower a menos que A sea en sí misma hermitiana (por ejemplo, si A == adjoint(A)).

Todas las partes no reales de la diagonal serán ignoradas.

Hermitiano(fill(complex(1,1), 1, 1)) == fill(1, 1, 1)

LowerTriangular(A::AbstractMatrix)

Construye una vista LowerTriangular de la matriz A.

Ejemplos

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> LowerTriangular(A)
3×3 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅    ⋅
 4.0  5.0   ⋅
 7.0  8.0  9.0

UpperTriangular(A::AbstractMatrix)

Construye una vista UpperTriangular de la matriz A.

Ejemplos

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UpperTriangular(A)
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 1.0  2.0  3.0
  ⋅   5.0  6.0
  ⋅    ⋅   9.0

UnitLowerTriangular(A::AbstractMatrix)

Construye una vista UnitLowerTriangular de la matriz A. Tal vista tiene el oneunit del eltype de A en su diagonal.

Ejemplos

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UnitLowerTriangular(A)
3×3 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅    ⋅
 4.0  1.0   ⋅
 7.0  8.0  1.0

UnitUpperTriangular(A::AbstractMatrix)

Construye una vista UnitUpperTriangular de la matriz A. Tal vista tiene el oneunit del eltype de A en su diagonal.

Ejemplos

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UnitUpperTriangular(A)
3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  2.0  3.0
  ⋅   1.0  6.0
  ⋅    ⋅   1.0

UpperHessenberg(A::AbstractMatrix)

Construye una vista UpperHessenberg de la matriz A. Las entradas de A por debajo de la primera subdiagonal son ignoradas.

Se implementan algoritmos eficientes para H \ b, det(H), y similares.

Consulta también la función hessenberg para factorizar cualquier matriz en una matriz superior de Hessenberg similar.

Si F::Hessenberg es el objeto de factorización, la matriz unitaria se puede acceder con F.Q y la matriz de Hessenberg con F.H. Cuando se extrae Q, el tipo resultante es el objeto HessenbergQ, y puede ser convertido a una matriz regular con convert(Array, _) (o Array(_) para abreviar).

Iterar la descomposición produce los factores F.Q y F.H.

Ejemplos

julia> A = [1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15 16]
4×4 Matrix{Int64}:
  1   2   3   4
  5   6   7   8
  9  10  11  12
 13  14  15  16

julia> UpperHessenberg(A)
4×4 UpperHessenberg{Int64, Matrix{Int64}}:
 1   2   3   4
 5   6   7   8
 ⋅  10  11  12
 ⋅   ⋅  15  16

UniformScaling{T<:Number}

Operador de escalado uniforme de tamaño genérico definido como un escalar multiplicado por el operador identidad, λ*I. Aunque sin un size explícito, actúa de manera similar a una matriz en muchos casos e incluye soporte para algunos índices. Ver también I.

Ejemplos

julia> J = UniformScaling(2.)
UniformScaling{Float64}
2.0*I

julia> A = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> J*A
2×2 Matrix{Float64}:
 2.0  4.0
 6.0  8.0

julia> J[1:2, 1:2]
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

I

Un objeto del tipo UniformScaling, que representa una matriz identidad de cualquier tamaño.

Ejemplos

julia> fill(1, (5,6)) * I == fill(1, (5,6))
true

julia> [1 2im 3; 1im 2 3] * I
2×3 Matrix{Complex{Int64}}:
 1+0im  0+2im  3+0im
 0+1im  2+0im  3+0im

(I::UniformScaling)(n::Integer)

Construye una matriz Diagonal a partir de un UniformScaling.

Ejemplos

julia> I(3)
3×3 Diagonal{Bool, Vector{Bool}}:
 1  ⋅  ⋅
 ⋅  1  ⋅
 ⋅  ⋅  1

julia> (0.7*I)(3)
3×3 Diagonal{Float64, Vector{Float64}}:
 0.7   ⋅    ⋅
  ⋅   0.7   ⋅
  ⋅    ⋅   0.7

LinearAlgebra.Factorization

Tipo abstracto para factorizaciones de matrices también conocidas como descomposiciones de matrices. Consulta la documentación en línea para obtener una lista de las factorizaciones de matrices disponibles.

LU <: Factorización

Tipo de factorización de matriz de la factorización LU de una matriz cuadrada A. Este es el tipo de retorno de lu, la función de factorización de matriz correspondiente.

Los componentes individuales de la factorización F::LU se pueden acceder a través de getproperty:

Iterar sobre la factorización produce los componentes F.L, F.U y F.p.

Ejemplos

julia> A = [4 3; 6 3]
2×2 Matrix{Int64}:
 4  3
 6  3

julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

julia> F.L * F.U == A[F.p, :]
true

julia> l, u, p = lu(A); # desestructuración a través de la iteración

julia> l == F.L && u == F.U && p == F.p
true

lu(A::AbstractSparseMatrixCSC; check = true, q = nothing, control = get_umfpack_control()) -> F::UmfpackLU

Calcula la factorización LU de una matriz dispersa A.

Para A dispersa con tipo de elemento real o complejo, el tipo de retorno de F es UmfpackLU{Tv, Ti}, donde Tv = Float64 o ComplexF64 respectivamente y Ti es un tipo entero (Int32 o Int64).

Cuando check = true, se lanza un error si la descomposición falla. Cuando check = false, la responsabilidad de verificar la validez de la descomposición (a través de issuccess) recae en el usuario.

El vector de permutación q puede ser un vector de permutación o nothing. Si no se proporciona un vector de permutación o q es nothing, se utiliza el predeterminado de UMFPACK. Si la permutación no es basada en cero, se realiza una copia basada en cero.

El vector control tiene como configuración predeterminada la configuración predeterminada del paquete SparseArrays de Julia para UMFPACK (NB: esto se modifica de los predeterminados de UMFPACK para deshabilitar el refinamiento iterativo), pero se puede cambiar pasando un vector de longitud UMFPACK_CONTROL, consulta el manual de UMFPACK para posibles configuraciones. Por ejemplo, para reactivar el refinamiento iterativo:

umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # leer la configuración predeterminada de Julia para una matriz dispersa Float64
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # opcional - mostrar valores
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # reactivar el refinamiento iterativo (2 es el máximo de pasos de refinamiento iterativo predeterminado de UMFPACK)

Alu = lu(A; control = umfpack_control)
x = Alu \ b   # resolver Ax = b, incluyendo el refinamiento iterativo de UMFPACK

Los componentes individuales de la factorización F se pueden acceder mediante indexación:

La relación entre F y A es

F.L*F.U == (F.Rs .* A)[F.p, F.q]

F además soporta las siguientes funciones:

• \
• det

Consulta también lu!

lu(A, pivot = RowMaximum(); check = true, allowsingular = false) -> F::LU

Calcula la factorización LU de A.

Cuando check = true, se lanza un error si la descomposición falla. Cuando check = false, la responsabilidad de verificar la validez de la descomposición (a través de issuccess) recae en el usuario.

Por defecto, con check = true, también se lanza un error cuando la descomposición produce factores válidos, pero el factor triangular superior U es deficiente en rango. Esto se puede cambiar pasando allowsingular = true.

En la mayoría de los casos, si A es un subtipo S de AbstractMatrix{T} con un tipo de elemento T que soporta +, -, * y /, el tipo de retorno es LU{T,S{T}}.

En general, la factorización LU implica una permutación de las filas de la matriz (correspondiente a la salida F.p descrita a continuación), conocida como "pivoting" (porque corresponde a elegir qué fila contiene el "pivot", la entrada diagonal de F.U). Una de las siguientes estrategias de pivoting se puede seleccionar a través del argumento opcional pivot:

• RowMaximum() (por defecto): la estrategia de pivoting estándar; el pivot corresponde al elemento de valor absoluto máximo entre las filas restantes a factorizar. Esta estrategia de pivoting requiere que el tipo de elemento también soporte abs y <. (Esta es generalmente la única opción numéricamente estable para matrices de punto flotante.)
• RowNonZero(): el pivot corresponde al primer elemento no cero entre las filas restantes a factorizar. (Esto corresponde a la elección típica en cálculos manuales, y también es útil para tipos de números algebraicos más generales que soportan iszero pero no abs o <.)
• NoPivot(): pivoting desactivado (fallará si se encuentra una entrada cero en una posición de pivot, incluso cuando allowsingular = true).

Los componentes individuales de la factorización F se pueden acceder a través de getproperty:

Iterar sobre la factorización produce los componentes F.L, F.U y F.p.

La relación entre F y A es

F.L*F.U == A[F.p, :]

F además soporta las siguientes funciones:

Ejemplos

julia> A = [4 3; 6 3]
2×2 Matrix{Int64}:
 4  3
 6  3

julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

julia> F.L * F.U == A[F.p, :]
true

julia> l, u, p = lu(A); # desestructuración a través de la iteración

julia> l == F.L && u == F.U && p == F.p
true

julia> lu([1 2; 1 2], allowsingular = true)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
U factor (deficiente en rango):
2×2 Matrix{Float64}:
 1.0  2.0
 0.0  0.0

lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC; check=true, reuse_symbolic=true, q=nothing) -> F::UmfpackLU

Calcula la factorización LU de una matriz dispersa A, reutilizando la factorización simbólica de una factorización LU ya existente almacenada en F. A menos que reuse_symbolic se establezca en falso, la matriz dispersa A debe tener un patrón de no ceros idéntico al de la matriz utilizada para crear la factorización LU F, de lo contrario se lanzará un error. Si el tamaño de A y F difiere, todos los vectores se redimensionarán en consecuencia.

Cuando check = true, se lanza un error si la descomposición falla. Cuando check = false, la responsabilidad de verificar la validez de la descomposición (a través de issuccess) recae en el usuario.

La permutación q puede ser un vector de permutación o nothing. Si no se proporciona un vector de permutación o q es nothing, se utiliza el valor predeterminado de UMFPACK. Si la permutación no es basada en cero, se realiza una copia basada en cero.

Véase también lu

Ejemplos

julia> A = sparse(Float64[1.0 2.0; 0.0 3.0]);

julia> F = lu(A);

julia> B = sparse(Float64[1.0 1.0; 0.0 1.0]);

julia> lu!(F, B);

julia> F \ ones(2)
2-element Vector{Float64}:
 0.0
 1.0

lu!(A, pivot = RowMaximum(); check = true, allowsingular = false) -> LU

lu! es lo mismo que lu, pero ahorra espacio al sobrescribir la entrada A, en lugar de crear una copia. Se lanza una excepción InexactError si la factorización produce un número que no es representable por el tipo de elemento de A, por ejemplo, para tipos enteros.

Ejemplos

julia> A = [4. 3.; 6. 3.]
2×2 Matrix{Float64}:
 4.0  3.0
 6.0  3.0

julia> F = lu!(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

julia> iA = [4 3; 6 3]
2×2 Matrix{Int64}:
 4  3
 6  3

julia> lu!(iA)
ERROR: InexactError: Int64(0.6666666666666666)
Stacktrace:
[...]

Cholesky <: Factorización

Tipo de factorización de matriz de la factorización de Cholesky de una matriz densa simétrica/Hermítica definida positiva A. Este es el tipo de retorno de cholesky, la función de factorización de matriz correspondiente.

El factor triangular de Cholesky se puede obtener de la factorización F::Cholesky a través de F.L y F.U, donde A ≈ F.U' * F.U ≈ F.L * F.L'.

Las siguientes funciones están disponibles para objetos Cholesky: size, \, inv, det, logdet y isposdef.

Iterar la descomposición produce los componentes L y U.

Ejemplos

julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
   4.0   12.0  -16.0
  12.0   37.0  -43.0
 -16.0  -43.0   98.0

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.U
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.L
3×3 LowerTriangular{Float64, Matrix{Float64}}:
  2.0   ⋅    ⋅
  6.0  1.0   ⋅
 -8.0  5.0  3.0

julia> C.L * C.U == A
true

julia> l, u = C; # desestructuración a través de la iteración

julia> l == C.L && u == C.U
true

CholeskyPivoted

Tipo de factorización de matriz de la factorización de Cholesky con pivoteo de una matriz densa simétrica/Hermítica positiva semidefinida A. Este es el tipo de retorno de cholesky(_, ::RowMaximum), la función de factorización de matriz correspondiente.

El factor triangular de Cholesky se puede obtener de la factorización F::CholeskyPivoted a través de F.L y F.U, y la permutación a través de F.p, donde A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' con Ur = F.U[1:F.rank, :] y Lr = F.L[:, 1:F.rank], o alternativamente A ≈ Up' * Up ≈ Lp * Lp' con Up = F.U[1:F.rank, invperm(F.p)] y Lp = F.L[invperm(F.p), 1:F.rank].

Las siguientes funciones están disponibles para objetos CholeskyPivoted: size, \, inv, det, y rank.

Iterar la descomposición produce los componentes L y U.

Ejemplos

julia> X = [1.0, 2.0, 3.0, 4.0];

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true

julia> l, u = C; # destructuring via iteration

julia> l == C.L && u == C.U
true

cholesky(A, NoPivot(); check = true) -> Cholesky

Calcula la factorización de Cholesky de una matriz densa simétrica definida positiva A y devuelve una Cholesky factorización. La matriz A puede ser una Symmetric o Hermitian AbstractMatrix o una AbstractMatrix perfectamente simétrica o hermítica.

El factor triangular de Cholesky se puede obtener de la factorización F a través de F.L y F.U, donde A ≈ F.U' * F.U ≈ F.L * F.L'.

Las siguientes funciones están disponibles para los objetos Cholesky: size, \, inv, det, logdet y isposdef.

Si tienes una matriz A que es ligeramente no hermítica debido a errores de redondeo en su construcción, envuélvela en Hermitian(A) antes de pasarla a cholesky para tratarla como perfectamente hermítica.

Cuando check = true, se lanza un error si la descomposición falla. Cuando check = false, la responsabilidad de verificar la validez de la descomposición (a través de issuccess) recae en el usuario.

Ejemplos

julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
   4.0   12.0  -16.0
  12.0   37.0  -43.0
 -16.0  -43.0   98.0

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.U
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.L
3×3 LowerTriangular{Float64, Matrix{Float64}}:
  2.0   ⋅    ⋅
  6.0  1.0   ⋅
 -8.0  5.0  3.0

julia> C.L * C.U == A
true

cholesky(A, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

Calcula la factorización de Cholesky pivotada de una matriz densa simétrica positiva semidefinida A y devuelve una factorización CholeskyPivoted. La matriz A puede ser una Symmetric o Hermitian AbstractMatrix o una AbstractMatrix perfectamente simétrica o hermítica.

El factor triangular de Cholesky se puede obtener de la factorización F a través de F.L y F.U, y la permutación a través de F.p, donde A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' con Ur = F.U[1:F.rank, :] y Lr = F.L[:, 1:F.rank], o alternativamente A ≈ Up' * Up ≈ Lp * Lp' con Up = F.U[1:F.rank, invperm(F.p)] y Lp = F.L[invperm(F.p), 1:F.rank].

Las siguientes funciones están disponibles para objetos CholeskyPivoted: size, \, inv, det, y rank.

El argumento tol determina la tolerancia para determinar el rango. Para valores negativos, la tolerancia es la precisión de la máquina.

Si tienes una matriz A que es ligeramente no hermítica debido a errores de redondeo en su construcción, envuélvela en Hermitian(A) antes de pasarla a cholesky para tratarla como perfectamente hermítica.

Cuando check = true, se lanza un error si la descomposición falla. Cuando check = false, la responsabilidad de verificar la validez de la descomposición (a través de issuccess) recae en el usuario.

Ejemplos

julia> X = [1.0, 2.0, 3.0, 4.0];

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true

julia> l, u = C; # destructuring via iteration

julia> l == C.L && u == C.U
true

cholesky(A::SparseMatrixCSC; shift = 0.0, check = true, perm = nothing) -> CHOLMOD.Factor

Calcula la factorización de Cholesky de una matriz dispersa definida positiva A. A debe ser una SparseMatrixCSC o una vista Symmetric/Hermitian de una SparseMatrixCSC. Ten en cuenta que incluso si A no tiene la etiqueta de tipo, aún debe ser simétrica o hermítica. Si no se proporciona perm, se utiliza una permutación que reduce el llenado. F = cholesky(A) se usa con mayor frecuencia para resolver sistemas de ecuaciones con F\b, pero también se definen los métodos diag, det y logdet para F. También puedes extraer factores individuales de F, usando F.L. Sin embargo, dado que el pivoteo está activado por defecto, la factorización se representa internamente como A == P'*L*L'*P con una matriz de permutación P; usar solo L sin tener en cuenta P dará respuestas incorrectas. Para incluir los efectos de la permutación, es preferible extraer factores "combinados" como PtL = F.PtL (el equivalente de P'*L) y LtP = F.UP (el equivalente de L'*P).

Cuando check = true, se lanza un error si la descomposición falla. Cuando check = false, la responsabilidad de verificar la validez de la descomposición (a través de issuccess) recae en el usuario.

Establecer el argumento de palabra clave opcional shift calcula la factorización de A+shift*I en lugar de A. Si se proporciona el argumento perm, debe ser una permutación de 1:size(A,1) que da el orden a utilizar (en lugar del orden AMD predeterminado de CHOLMOD).

Ejemplos

En el siguiente ejemplo, la permutación que reduce el llenado utilizada es [3, 2, 1]. Si perm se establece en 1:3 para forzar ninguna permutación, el número de elementos no nulos en el factor es 6.

julia> A = [2 1 1; 1 2 0; 1 0 2]
3×3 Matrix{Int64}:
 2  1  1
 1  2  0
 1  0  2

julia> C = cholesky(sparse(A))
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  5
nnz:     5
success: true

julia> C.p
3-element Vector{Int64}:
 3
 2
 1

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421   0.0       0.0
 0.0       1.41421   0.0
 0.707107  0.707107  1.0

julia> L * L' ≈ A[C.p, C.p]
true

julia> P = sparse(1:3, C.p, ones(3))
3×3 SparseMatrixCSC{Float64, Int64} con 3 entradas almacenadas:
  ⋅    ⋅   1.0
  ⋅   1.0   ⋅
 1.0   ⋅    ⋅

julia> P' * L * L' * P ≈ A
true

julia> C = cholesky(sparse(A), perm=1:3)
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  6
nnz:     6
success: true

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421    0.0       0.0
 0.707107   1.22474   0.0
 0.707107  -0.408248  1.1547

julia> L * L' ≈ A
true

cholesky!(A::AbstractMatrix, NoPivot(); check = true) -> Cholesky

Lo mismo que cholesky, pero ahorra espacio al sobrescribir la entrada A, en lugar de crear una copia. Se lanza una excepción InexactError si la factorización produce un número que no se puede representar con el tipo de elemento de A, por ejemplo, para tipos enteros.

Ejemplos

julia> A = [1 2; 2 50]
2×2 Matrix{Int64}:
 1   2
 2  50

julia> cholesky!(A)
ERROR: InexactError: Int64(6.782329983125268)
Stacktrace:
[...]

cholesky!(A::AbstractMatrix, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

Lo mismo que cholesky, pero ahorra espacio al sobrescribir la entrada A, en lugar de crear una copia. Se lanza una excepción InexactError si la factorización produce un número que no es representable por el tipo de elemento de A, por ejemplo, para tipos enteros.

cholesky!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

Calcula la factorización de Cholesky ($LL'$) de A, reutilizando la factorización simbólica F. A debe ser una SparseMatrixCSC o una vista Symmetric/ Hermitian de una SparseMatrixCSC. Ten en cuenta que, incluso si A no tiene la etiqueta de tipo, debe seguir siendo simétrica o hermitiana.

Consulta también cholesky.

lowrankupdate(C::Cholesky, v::AbstractVector) -> CC::Cholesky

Actualiza una factorización de Cholesky C con el vector v. Si A = C.U'C.U entonces CC = cholesky(C.U'C.U + v*v') pero el cálculo de CC solo utiliza O(n^2) operaciones.

lowrankupdate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

Obtiene una factorización LDLt de A + C*C' dada una factorización LDLt o LLt F de A.

El factor devuelto es siempre una factorización LDLt.

Véase también lowrankupdate!, lowrankdowndate, lowrankdowndate!.

lowrankdowndate(C::Cholesky, v::AbstractVector) -> CC::Cholesky

Actualiza hacia abajo una factorización de Cholesky C con el vector v. Si A = C.U'C.U entonces CC = cholesky(C.U'C.U - v*v') pero el cálculo de CC solo utiliza O(n^2) operaciones.

lowrankdowndate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

Obtiene una factorización LDLt de A + C*C' dada una factorización LDLt o LLt F de A.

El factor devuelto es siempre una factorización LDLt.

Véase también lowrankdowndate!, lowrankupdate, lowrankupdate!.

lowrankupdate!(C::Cholesky, v::AbstractVector) -> CC::Cholesky

Actualiza una factorización de Cholesky C con el vector v. Si A = C.U'C.U entonces CC = cholesky(C.U'C.U + v*v') pero el cálculo de CC solo utiliza O(n^2) operaciones. La factorización de entrada C se actualiza en su lugar de modo que al salir C == CC. El vector v se destruye durante el cálculo.

lowrankupdate!(F::CHOLMOD.Factor, C::AbstractArray)

Actualiza una factorización LDLt o LLt F de A a una factorización de A + C*C'.

Las factorizaciones LLt se convierten en LDLt.

Véase también lowrankupdate, lowrankdowndate, lowrankdowndate!.

lowrankdowndate!(C::Cholesky, v::AbstractVector) -> CC::Cholesky

Realiza una actualización descendente de una factorización de Cholesky C con el vector v. Si A = C.U'C.U entonces CC = cholesky(C.U'C.U - v*v') pero el cálculo de CC solo utiliza O(n^2) operaciones. La factorización de entrada C se actualiza en su lugar de tal manera que al salir C == CC. El vector v se destruye durante el cálculo.

lowrankdowndate!(F::CHOLMOD.Factor, C::AbstractArray)

Actualiza una factorización LDLt o LLt F de A a una factorización de A - C*C'.

Las factorizaciones LLt se convierten en LDLt.

Véase también lowrankdowndate, lowrankupdate, lowrankupdate!.

LDLt <: Factorización

Tipo de factorización de matriz de la factorización LDLt de una matriz real SymTridiagonal S tal que S = L*Diagonal(d)*L', donde L es una matriz UnitLowerTriangular y d es un vector. El uso principal de una factorización LDLt F = ldlt(S) es resolver el sistema de ecuaciones lineales Sx = b con F\b. Este es el tipo de retorno de ldlt, la función de factorización de matriz correspondiente.

Los componentes individuales de la factorización F::LDLt se pueden acceder a través de getproperty:

Ejemplos

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> F = ldlt(S)
LDLt{Float64, SymTridiagonal{Float64, Vector{Float64}}}
Factor L:
3×3 UnitLowerTriangular{Float64, SymTridiagonal{Float64, Vector{Float64}}}:
 1.0        ⋅         ⋅
 0.333333  1.0        ⋅
 0.0       0.545455  1.0
Factor D:
3×3 Diagonal{Float64, Vector{Float64}}:
 3.0   ⋅        ⋅
  ⋅   3.66667   ⋅
  ⋅    ⋅       3.90909

ldlt(S::SymTridiagonal) -> LDLt

Calcula una factorización LDLt (es decir, $LDL^T$) de la matriz tridiagonal simétrica real S tal que S = L*Diagonal(d)*L' donde L es una matriz triangular inferior unitaria y d es un vector. El uso principal de una factorización LDLt F = ldlt(S) es resolver el sistema de ecuaciones lineales Sx = b con F\b.

Véase también bunchkaufman para una factorización similar, pero con pivoteo, de matrices simétricas o hermitianas arbitrarias.

Ejemplos

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> ldltS = ldlt(S);

julia> b = [6., 7., 8.];

julia> ldltS \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

julia> S \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

ldlt(A::SparseMatrixCSC; shift = 0.0, check = true, perm=nothing) -> CHOLMOD.Factor

Calcula la factorización $LDL'$ de una matriz dispersa A. A debe ser una SparseMatrixCSC o una vista Symmetric/Hermitian de una SparseMatrixCSC. Ten en cuenta que, incluso si A no tiene la etiqueta de tipo, aún debe ser simétrica o hermítica. Se utiliza una permutación que reduce el llenado. F = ldlt(A) se usa con mayor frecuencia para resolver sistemas de ecuaciones A*x = b con F\b. El objeto de factorización devuelto F también admite los métodos diag, det, logdet y inv. Puedes extraer factores individuales de F usando F.L. Sin embargo, dado que el pivoteo está activado por defecto, la factorización se representa internamente como A == P'*L*D*L'*P con una matriz de permutación P; usar solo L sin tener en cuenta P dará respuestas incorrectas. Para incluir los efectos de la permutación, generalmente es preferible extraer factores "combinados" como PtL = F.PtL (el equivalente de P'*L) y LtP = F.UP (el equivalente de L'*P). La lista completa de factores admitidos es :L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP.

Cuando check = true, se lanza un error si la descomposición falla. Cuando check = false, la responsabilidad de verificar la validez de la descomposición (a través de issuccess) recae en el usuario.

Establecer el argumento de palabra clave opcional shift calcula la factorización de A+shift*I en lugar de A. Si se proporciona el argumento perm, debe ser una permutación de 1:size(A,1) que da el orden a utilizar (en lugar del orden predeterminado AMD de CHOLMOD).

ldlt!(S::SymTridiagonal) -> LDLt

Igual que ldlt, pero ahorra espacio al sobrescribir la entrada S, en lugar de crear una copia.

Ejemplos

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

julia> S
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0       0.333333   ⋅
 0.333333  3.66667   0.545455
  ⋅        0.545455  3.90909

ldlt!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

Calcula la factorización $LDL'$ de A, reutilizando la factorización simbólica F. A debe ser una SparseMatrixCSC o una vista Symmetric/Hermitian de una SparseMatrixCSC. Ten en cuenta que, incluso si A no tiene la etiqueta de tipo, aún debe ser simétrica o hermitiana.

Consulta también ldlt.

QR <: Factorización

Una factorización de matriz QR almacenada en un formato empaquetado, típicamente obtenida de qr. Si $A$ es una matriz m×n, entonces

\[A = Q R\]

donde $Q$ es una matriz ortogonal/unitaria y $R$ es triangular superior. La matriz $Q$ se almacena como una secuencia de reflectores de Householder $v_i$ y coeficientes $\tau_i$ donde:

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T).\]

Iterar la descomposición produce los componentes Q y R.

El objeto tiene dos campos:

• factors es una matriz m×n.

  • La parte triangular superior contiene los elementos de $R$, es decir, R = triu(F.factors) para un objeto QR F.
  • La parte subdiagonal contiene los reflectores $v_i$ almacenados en un formato empaquetado donde $v_i$ es la $i$-ésima columna de la matriz V = I + tril(F.factors, -1).

• τ es un vector de longitud min(m,n) que contiene los coeficientes $au_i$.

QRCompactWY <: Factorization

Una factorización de matriz QR almacenada en un formato compacto bloqueado, típicamente obtenida de qr. Si $A$ es una matriz m×n, entonces

\[A = Q R\]

donde $Q$ es una matriz ortogonal/unitaria y $R$ es triangular superior. Es similar al formato QR excepto que la matriz ortogonal/unitaria $Q$ se almacena en formato Compact WY ^{[Schreiber1989]}. Para el tamaño de bloque $n_b$, se almacena como una matriz trapezoidal inferior m×n $V$ y una matriz $T = (T_1 \; T_2 \; ... \; T_{b-1} \; T_b')$ compuesta de $b = \lceil \min(m,n) / n_b \rceil$ matrices triangulares superiores $T_j$ de tamaño $n_b$×$n_b$ ($j = 1, ..., b-1$) y una matriz trapezoidal superior $n_b$×$\min(m,n) - (b-1) n_b$ $T_b'$ ($j=b$) cuya parte cuadrada superior se denota con $T_b$ satisfaciendo

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T) = \prod_{j=1}^{b} (I - V_j T_j V_j^T)\]

de modo que $v_i$ es la $i$-ésima columna de $V$, $\tau_i$ es el $i$-ésimo elemento de [diag(T_1); diag(T_2); …; diag(T_b)], y $(V_1 \; V_2 \; ... \; V_b)$ es el bloque izquierdo m×min(m, n) de $V$. Cuando se construye utilizando qr, el tamaño del bloque está dado por $n_b = \min(m, n, 36)$.

Iterar la descomposición produce los componentes Q y R.

El objeto tiene dos campos:

• factors, como en el tipo QR, es una matriz m×n.

  • La parte triangular superior contiene los elementos de $R$, es decir, R = triu(F.factors) para un objeto QR F.
  • La parte subdiagonal contiene los reflectores $v_i$ almacenados en un formato empaquetado tal que V = I + tril(F.factors, -1).

• T es una matriz de $n_b$ por $\min(m,n)$ como se describió anteriormente. Se ignoran los elementos subdiagonales para cada matriz triangular $T_j$.

QRPivoted <: Factorization

Una factorización de matriz QR con pivoteo de columnas en un formato empaquetado, típicamente obtenida de qr. Si $A$ es una matriz m×n, entonces

\[A P = Q R\]

donde $P$ es una matriz de permutación, $Q$ es una matriz ortogonal/unitaria y $R$ es triangular superior. La matriz $Q$ se almacena como una secuencia de reflectores de Householder:

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T).\]

Iterar la descomposición produce los componentes Q, R y p.

El objeto tiene tres campos:

• factors es una matriz m×n.

  • La parte triangular superior contiene los elementos de $R$, es decir, R = triu(F.factors) para un objeto QR F.
  • La parte subdiagonal contiene los reflectores $v_i$ almacenados en un formato empaquetado donde $v_i$ es la $i$-ésima columna de la matriz V = I + tril(F.factors, -1).

• τ es un vector de longitud min(m,n) que contiene los coeficientes $au_i$.

• jpvt es un vector entero de longitud n correspondiente a la permutación $P$.

qr(A::SparseMatrixCSC; tol=_default_tol(A), ordering=ORDERING_DEFAULT) -> QRSparse

Calcula la factorización QR de una matriz dispersa A. Se utilizan permutaciones de filas y columnas que reducen el llenado de manera que F.R = F.Q'*A[F.prow,F.pcol]. La aplicación principal de este tipo es resolver problemas de mínimos cuadrados o subdeterminado con \. La función llama a la biblioteca C SPQR^[ACM933].

Ejemplos

julia> A = sparse([1,2,3,4], [1,1,2,2], [1.0,1.0,1.0,1.0])
4×2 SparseMatrixCSC{Float64, Int64} con 4 entradas almacenadas:
 1.0   ⋅
 1.0   ⋅
  ⋅   1.0
  ⋅   1.0

julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Factor Q:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
Factor R:
2×2 SparseMatrixCSC{Float64, Int64} con 2 entradas almacenadas:
 -1.41421    ⋅
   ⋅       -1.41421
Permutación de filas:
Vector de 4 elementos{Int64}:
 1
 3
 4
 2
Permutación de columnas:
Vector de 2 elementos{Int64}:
 1
 2

qr(A, pivot = NoPivot(); blocksize) -> F

Calcula la factorización QR de la matriz A: una matriz ortogonal (o unitaria si A es de valor complejo) Q, y una matriz triangular superior R tal que

\[A = Q R\]

El objeto devuelto F almacena la factorización en un formato empaquetado:

• si pivot == ColumnNorm() entonces F es un objeto QRPivoted,
• de lo contrario, si el tipo de elemento de A es un tipo BLAS (Float32, Float64, ComplexF32 o ComplexF64), entonces F es un objeto QRCompactWY,
• de lo contrario, F es un objeto QR.

Los componentes individuales de la descomposición F se pueden recuperar a través de accesores de propiedades:

• F.Q: la matriz ortogonal/unitaria Q
• F.R: la matriz triangular superior R
• F.p: el vector de permutación del pivote (QRPivoted solo)
• F.P: la matriz de permutación del pivote (QRPivoted solo)

Iterar la descomposición produce los componentes Q, R, y si existe p.

Las siguientes funciones están disponibles para los objetos QR: inv, size, y \. Cuando A es rectangular, \ devolverá una solución de mínimos cuadrados y si la solución no es única, se devuelve la que tiene la norma más pequeña. Cuando A no tiene rango completo, se requiere la factorización con pivoteo (por columna) para obtener una solución de norma mínima.

Se permite la multiplicación con respecto a Q completo/cuadrado o no completo/cuadrado, es decir, tanto F.Q*F.R como F.Q*A son compatibles. Una matriz Q se puede convertir en una matriz regular con Matrix. Esta operación devuelve el factor Q "delgado", es decir, si A es m×n con m>=n, entonces Matrix(F.Q) produce una matriz m×n con columnas ortonormales. Para recuperar el factor Q "completo", una matriz ortogonal m×m, usa F.Q*I o collect(F.Q). Si m<=n, entonces Matrix(F.Q) produce una matriz ortogonal m×m.

El tamaño del bloque para la descomposición QR se puede especificar mediante el argumento de palabra clave blocksize :: Integer cuando pivot == NoPivot() y A isa StridedMatrix{<:BlasFloat}. Se ignora cuando blocksize > minimum(size(A)). Ver QRCompactWY.

Ejemplos

julia> A = [3.0 -6.0; 4.0 -8.0; 0.0 1.0]
3×2 Matrix{Float64}:
 3.0  -6.0
 4.0  -8.0
 0.0   1.0

julia> F = qr(A)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Factor Q: 3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
Factor R:
2×2 Matrix{Float64}:
 -5.0  10.0
  0.0  -1.0

julia> F.Q * F.R == A
true

qr!(A, pivot = NoPivot(); blocksize)

qr! es lo mismo que qr cuando A es un subtipo de AbstractMatrix, pero ahorra espacio al sobrescribir la entrada A, en lugar de crear una copia. Se lanza una excepción InexactError si la factorización produce un número que no es representable por el tipo de elemento de A, por ejemplo, para tipos enteros.

Ejemplos

julia> a = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> qr!(a)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q factor: 2×2 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R factor:
2×2 Matrix{Float64}:
 -3.16228  -4.42719
  0.0      -0.632456

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> qr!(a)
ERROR: InexactError: Int64(3.1622776601683795)
Stacktrace:
[...]

LQ <: Factorización

Tipo de factorización de matriz de la factorización LQ de una matriz A. La descomposición LQ es la descomposición QR de transpose(A). Este es el tipo de retorno de lq, la función de factorización de matriz correspondiente.

Si S::LQ es el objeto de factorización, el componente triangular inferior se puede obtener a través de S.L, y el componente ortogonal/unitario a través de S.Q, de modo que A ≈ S.L*S.Q.

Iterar la descomposición produce los componentes S.L y S.Q.

Ejemplos

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}

julia> S.L * S.Q
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> l, q = S; # desestructuración a través de la iteración

julia> l == S.L &&  q == S.Q
true

lq(A) -> S::LQ

Calcula la descomposición LQ de A. El componente triangular inferior de la descomposición se puede obtener del objeto LQ S a través de S.L, y el componente ortogonal/unitario a través de S.Q, de modo que A ≈ S.L*S.Q.

Iterar la descomposición produce los componentes S.L y S.Q.

La descomposición LQ es la descomposición QR de transpose(A), y es útil para calcular la solución de mínima norma lq(A) \ b para un sistema de ecuaciones subdeterminado (A tiene más columnas que filas, pero tiene rango completo de filas).

Ejemplos

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
Factor L:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Factor Q: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}

julia> S.L * S.Q
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> l, q = S; # desestructuración a través de la iteración

julia> l == S.L &&  q == S.Q
true

lq!(A) -> LQ

Calcula la factorización LQ de A, utilizando la matriz de entrada como espacio de trabajo. Consulta también lq.

BunchKaufman <: Factorization

Tipo de factorización de matriz de la factorización de Bunch-Kaufman de una matriz simétrica o hermítica A como P'UDU'P o P'LDL'P, dependiendo de si el triángulo superior (el predeterminado) o el triángulo inferior se almacena en A. Si A es simétrica compleja, entonces U' y L' denotan las transpuestas no conjugadas, es decir, transpose(U) y transpose(L), respectivamente. Este es el tipo de retorno de bunchkaufman, la función de factorización de matriz correspondiente.

Si S::BunchKaufman es el objeto de factorización, los componentes se pueden obtener a través de S.D, S.U o S.L según corresponda dado S.uplo, y S.p.

Iterar la descomposición produce los componentes S.D, S.U o S.L según corresponda dado S.uplo, y S.p.

Ejemplos

julia> A = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  3.0

julia> S = bunchkaufman(A) # A se envuelve internamente por Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # desestructuración a través de la iteración

julia> d == S.D && u == S.U && p == S.p
true

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Vector{Int64}:
 2
 1

bunchkaufman(A, rook::Bool=false; check = true) -> S::BunchKaufman

Calcula la factorización de Bunch-Kaufman ^[Bunch1977] de una matriz simétrica o hermítica A como P'*U*D*U'*P o P'*L*D*L'*P, dependiendo de qué triángulo se almacene en A, y devuelve un objeto BunchKaufman. Ten en cuenta que si A es simétrica compleja, entonces U' y L' denotan las transpuestas no conjugadas, es decir, transpose(U) y transpose(L).

Iterar la descomposición produce los componentes S.D, S.U o S.L según corresponda dado S.uplo, y S.p.

Si rook es true, se utiliza pivoteo de rook. Si rook es falso, no se utiliza pivoteo de rook.

Cuando check = true, se lanza un error si la descomposición falla. Cuando check = false, la responsabilidad de verificar la validez de la descomposición (a través de issuccess) recae en el usuario.

Las siguientes funciones están disponibles para objetos BunchKaufman: size, \, inv, issymmetric, ishermitian, getindex.

Ejemplos

julia> A = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  3.0

julia> S = bunchkaufman(A) # A se envuelve internamente por Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # desestructuración a través de la iteración

julia> d == S.D && u == S.U && p == S.p
true

julia> S.U*S.D*S.U' - S.P*A*S.P'
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Vector{Int64}:
 2
 1

julia> S.L*S.D*S.L' - A[S.p, S.p]
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

bunchkaufman!(A, rook::Bool=false; check = true) -> BunchKaufman

bunchkaufman! es lo mismo que bunchkaufman, pero ahorra espacio al sobrescribir la entrada A, en lugar de crear una copia.

Eigen <: Factorization

Tipo de factorización de matriz de la descomposición en valores propios/espectrales de una matriz cuadrada A. Este es el tipo de retorno de eigen, la función de factorización de matriz correspondiente.

Si F::Eigen es el objeto de factorización, los valores propios se pueden obtener a través de F.values y los vectores propios como las columnas de la matriz F.vectors. (El k-ésimo vector propio se puede obtener del segmento F.vectors[:, k].)

Iterar sobre la descomposición produce los componentes F.values y F.vectors.

Ejemplos

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
  1.0
  3.0
 18.0
vectors:
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Vector{Float64}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

GeneralizedEigen <: Factorization

Tipo de factorización de matriz de la descomposición generalizada de valores propios/espectrales de A y B. Este es el tipo de retorno de eigen, la función de factorización de matriz correspondiente, cuando se llama con dos argumentos de matriz.

Si F::GeneralizedEigen es el objeto de factorización, los valores propios se pueden obtener a través de F.values y los vectores propios como las columnas de la matriz F.vectors. (El k-ésimo vector propio se puede obtener de la porción F.vectors[:, k].)

Iterar sobre la descomposición produce los componentes F.values y F.vectors.

Ejemplos

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> F = eigen(A, B)
GeneralizedEigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}
values:
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im
vectors:
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigvals(A; permute::Bool=true, scale::Bool=true, sortby) -> values

Devuelve los valores propios de A.

Para matrices generales no simétricas, es posible especificar cómo se balancea la matriz antes del cálculo de los valores propios. Las palabras clave permute, scale y sortby son las mismas que para eigen.

Ejemplos

julia> diag_matrix = [1 0; 0 4]
2×2 Matrix{Int64}:
 1  0
 0  4

julia> eigvals(diag_matrix)
2-element Vector{Float64}:
 1.0
 4.0

Para una entrada escalar, eigvals devolverá un escalar.

Ejemplos

julia> eigvals(-2)
-2

eigvals(A, B) -> valores

Calcule los valores propios generalizados de A y B.

Ejemplos

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> eigvals(A,B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

Devuelve los valores propios de A. Es posible calcular solo un subconjunto de los valores propios especificando un UnitRange irange que cubra índices de los valores propios ordenados, por ejemplo, los valores propios del 2º al 8º.

Ejemplos

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A, 2:2)
1-element Vector{Float64}:
 0.9999999999999996

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

Devuelve los valores propios de A. Es posible calcular solo un subconjunto de los valores propios especificando un par vl y vu para los límites inferior y superior de los valores propios.

Ejemplos

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A, -1, 2)
1-element Vector{Float64}:
 1.0000000000000009

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

eigvals!(A; permute::Bool=true, scale::Bool=true, sortby) -> values

Igual que eigvals, pero ahorra espacio al sobrescribir la entrada A, en lugar de crear una copia. Las palabras clave permute, scale y sortby son las mismas que para eigen.

Ejemplos

julia> A = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> eigvals!(A)
2-element Vector{Float64}:
 -0.3722813232690143
  5.372281323269014

julia> A
2×2 Matrix{Float64}:
 -0.372281  -1.0
  0.0        5.37228

eigvals!(A, B; sortby) -> values

Igual que eigvals, pero ahorra espacio al sobrescribir la entrada A (y B), en lugar de crear copias.

Ejemplos

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> eigvals!(A, B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> A
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0  -0.0

julia> B
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

Igual que eigvals, pero ahorra espacio al sobrescribir la entrada A, en lugar de crear una copia. irange es un rango de índices de valores propios a buscar; por ejemplo, los valores propios del 2º al 8º.

eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

Igual que eigvals, pero ahorra espacio al sobrescribir la entrada A, en lugar de crear una copia. vl es el límite inferior del intervalo para buscar valores propios, y vu es el límite superior.

eigmax(A; permute::Bool=true, scale::Bool=true)

Devuelve el mayor valor propio de A. La opción permute=true permuta la matriz para acercarse a una forma triangular superior, y scale=true escala la matriz por sus elementos diagonales para hacer que las filas y columnas sean más iguales en norma. Ten en cuenta que si los valores propios de A son complejos, este método fallará, ya que los números complejos no se pueden ordenar.

Ejemplos

julia> A = [0 im; -im 0]
2×2 Matrix{Complex{Int64}}:
 0+0im  0+1im
 0-1im  0+0im

julia> eigmax(A)
1.0

julia> A = [0 im; -1 0]
2×2 Matrix{Complex{Int64}}:
  0+0im  0+1im
 -1+0im  0+0im

julia> eigmax(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` no puede tener valores propios complejos.
Stacktrace:
[...]

eigmin(A; permute::Bool=true, scale::Bool=true)

Devuelve el valor propio más pequeño de A. La opción permute=true permuta la matriz para acercarse a una forma triangular superior, y scale=true escala la matriz por sus elementos diagonales para hacer que las filas y columnas sean más iguales en norma. Ten en cuenta que si los valores propios de A son complejos, este método fallará, ya que los números complejos no se pueden ordenar.

Ejemplos

julia> A = [0 im; -im 0]
2×2 Matrix{Complex{Int64}}:
 0+0im  0+1im
 0-1im  0+0im

julia> eigmin(A)
-1.0

julia> A = [0 im; -1 0]
2×2 Matrix{Complex{Int64}}:
  0+0im  0+1im
 -1+0im  0+0im

julia> eigmin(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` no puede tener valores propios complejos.
Stacktrace:
[...]

eigvecs(A::SymTridiagonal[, eigvals]) -> Matrix

Devuelve una matriz M cuyas columnas son los eigenvectores de A. (El k-ésimo eigenvector se puede obtener de la porción M[:, k].)

Si se especifica el vector opcional de eigenvalores eigvals, eigvecs devuelve los eigenvectores correspondientes específicos.

Ejemplos

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

julia> eigvecs(A)
3×3 Matrix{Float64}:
  0.418304  -0.83205      0.364299
 -0.656749  -7.39009e-16  0.754109
  0.627457   0.5547       0.546448

julia> eigvecs(A, [1.])
3×1 Matrix{Float64}:
  0.8320502943378438
  4.263514128092366e-17
 -0.5547001962252291

eigvecs(A; permute::Bool=true, scale::Bool=true, `sortby`) -> Matrix

Devuelve una matriz M cuyas columnas son los vectores propios de A. (El k-ésimo vector propio se puede obtener del corte M[:, k].) Las palabras clave permute, scale y sortby son las mismas que para eigen.

Ejemplos

julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

eigvecs(A, B) -> Matrix

Devuelve una matriz M cuyas columnas son los eigenvectores generalizados de A y B. (El k-ésimo eigenvector se puede obtener del corte M[:, k].)

Ejemplos

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> eigvecs(A, B)
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

eigen(A; permute::Bool=true, scale::Bool=true, sortby) -> Eigen

Calcula la descomposición en valores propios de A, devolviendo un objeto de factorización Eigen F que contiene los valores propios en F.values y los vectores propios en las columnas de la matriz F.vectors. Esto corresponde a resolver un problema de valores propios de la forma Ax = λx, donde A es una matriz, x es un vector propio, y λ es un valor propio. (El k-ésimo vector propio se puede obtener de la porción F.vectors[:, k].)

Iterar la descomposición produce los componentes F.values y F.vectors.

Las siguientes funciones están disponibles para los objetos Eigen: inv, det, y isposdef.

Para matrices generales no simétricas, es posible especificar cómo se balancea la matriz antes del cálculo del vector propio. La opción permute=true permuta la matriz para acercarse a una forma triangular superior, y scale=true escala la matriz por sus elementos diagonales para hacer que las filas y columnas sean más iguales en norma. El valor predeterminado es true para ambas opciones.

Por defecto, los valores y vectores propios se ordenan lexicográficamente por (real(λ),imag(λ)). Se puede pasar una función de comparación diferente by(λ) a sortby, o se puede pasar sortby=nothing para dejar los valores propios en un orden arbitrario. Algunos tipos de matriz especiales (por ejemplo, Diagonal o SymTridiagonal) pueden implementar su propia convención de ordenación y no aceptar una palabra clave sortby.

Ejemplos

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
  1.0
  3.0
 18.0
vectors:
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Vector{Float64}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigen(A, B; sortby) -> GeneralizedEigen

Calcula la descomposición de valores propios generalizados de A y B, devolviendo un objeto de factorización GeneralizedEigen F que contiene los valores propios generalizados en F.values y los vectores propios generalizados en las columnas de la matriz F.vectors. Esto corresponde a resolver un problema de valores propios generalizados de la forma Ax = λBx, donde A, B son matrices, x es un vector propio y λ es un valor propio. (El k-ésimo vector propio generalizado se puede obtener de la porción F.vectors[:, k].)

Iterar la descomposición produce los componentes F.values y F.vectors.

Por defecto, los valores propios y vectores se ordenan lexicográficamente por (real(λ),imag(λ)). Se puede pasar una función de comparación diferente by(λ) a sortby, o se puede pasar sortby=nothing para dejar los valores propios en un orden arbitrario.

Ejemplos

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> F = eigen(A, B);

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> Eigen

Calcula la descomposición en valores propios de A, devolviendo un objeto de factorización Eigen F que contiene los valores propios en F.values y los vectores propios en las columnas de la matriz F.vectors. (El k-ésimo vector propio se puede obtener de la porción F.vectors[:, k].)

Iterar la descomposición produce los componentes F.values y F.vectors.

Las siguientes funciones están disponibles para los objetos Eigen: inv, det, y isposdef.

El UnitRange irange especifica los índices de los valores propios ordenados a buscar.

eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> Eigen

Calcula la descomposición en valores propios de A, devolviendo un objeto de factorización Eigen F que contiene los valores propios en F.values y los vectores propios en las columnas de la matriz F.vectors. (El k-ésimo vector propio se puede obtener de la porción F.vectors[:, k].)

Iterar sobre la descomposición produce los componentes F.values y F.vectors.

Las siguientes funciones están disponibles para los objetos Eigen: inv, det, y isposdef.

vl es el límite inferior de la ventana de valores propios a buscar, y vu es el límite superior.

eigen!(A; permute, scale, sortby)
eigen!(A, B; sortby)

Igual que eigen, pero ahorra espacio al sobrescribir la entrada A (y B), en lugar de crear una copia.

Hessenberg <: Factorización

Un objeto Hessenberg representa la factorización de Hessenberg QHQ' de una matriz cuadrada, o un desplazamiento Q(H+μI)Q' de la misma, que es producido por la función hessenberg.

hessenberg(A) -> Hessenberg

Calcula la descomposición de Hessenberg de A y devuelve un objeto Hessenberg. Si F es el objeto de factorización, la matriz unitaria se puede acceder con F.Q (de tipo LinearAlgebra.HessenbergQ) y la matriz de Hessenberg con F.H (de tipo UpperHessenberg), cualquiera de las cuales puede ser convertida a una matriz regular con Matrix(F.H) o Matrix(F.Q).

Si A es Hermitiana o real-Simétrica, entonces la descomposición de Hessenberg produce una matriz tridiagonal real-simétrica y F.H es de tipo SymTridiagonal.

Ten en cuenta que la factorización desplazada A+μI = Q (H+μI) Q' se puede construir de manera eficiente mediante F + μ*I usando el objeto UniformScaling I, que crea un nuevo objeto Hessenberg con almacenamiento compartido y un desplazamiento modificado. El desplazamiento de un dado F se obtiene mediante F.μ. Esto es útil porque múltiples resoluciones desplazadas (F + μ*I) \ b (para diferentes μ y/o b) se pueden realizar de manera eficiente una vez que se crea F.

Iterar la descomposición produce los factores F.Q, F.H, F.μ.

Ejemplos

julia> A = [4. 9. 7.; 4. 4. 1.; 4. 3. 2.]
3×3 Matrix{Float64}:
 4.0  9.0  7.0
 4.0  4.0  1.0
 4.0  3.0  2.0

julia> F = hessenberg(A)
Hessenberg{Float64, UpperHessenberg{Float64, Matrix{Float64}}, Matrix{Float64}, Vector{Float64}, Bool}
Q factor: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H factor:
3×3 UpperHessenberg{Float64, Matrix{Float64}}:
  4.0      -11.3137       -1.41421
 -5.65685    5.0           2.0
   ⋅        -8.88178e-16   1.0

julia> F.Q * F.H * F.Q'
3×3 Matrix{Float64}:
 4.0  9.0  7.0
 4.0  4.0  1.0
 4.0  3.0  2.0

julia> q, h = F; # desestructuración mediante iteración

julia> q == F.Q && h == F.H
true

hessenberg!(A) -> Hessenberg

hessenberg! es lo mismo que hessenberg, pero ahorra espacio al sobrescribir la entrada A, en lugar de crear una copia.

Schur <: Factorización

Tipo de factorización de matriz de la factorización de Schur de una matriz A. Este es el tipo de retorno de schur(_), la función de factorización de matriz correspondiente.

Si F::Schur es el objeto de factorización, el factor de Schur (cuasi) triangular se puede obtener a través de F.Schur o F.T y los vectores de Schur ortogonales/unitarios a través de F.vectors o F.Z de tal manera que A = F.vectors * F.Schur * F.vectors'. Los eigenvalores de A se pueden obtener con F.values.

Iterar la descomposición produce los componentes F.T, F.Z y F.values.

Ejemplos

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalores:
2-element Vector{Float64}:
  3.0
 -2.0

julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> t, z, vals = F; # desestructuración a través de la iteración

julia> t == F.T && z == F.Z && vals == F.values
true

GeneralizedSchur <: Factorization

Tipo de factorización de matriz de la factorización de Schur generalizada de dos matrices A y B. Este es el tipo de retorno de schur(_, _), la función de factorización de matriz correspondiente.

Si F::GeneralizedSchur es el objeto de factorización, los factores de Schur (cuasi) triangulares se pueden obtener a través de F.S y F.T, los vectores de Schur unitarios/ortogonales a la izquierda a través de F.left o F.Q, y los vectores de Schur unitarios/ortogonales a la derecha se pueden obtener con F.right o F.Z de tal manera que A=F.left*F.S*F.right' y B=F.left*F.T*F.right'. Los valores propios generalizados de A y B se pueden obtener con F.α./F.β.

Iterar la descomposición produce los componentes F.S, F.T, F.Q, F.Z, F.α y F.β.

schur(A) -> F::Schur

Calcula la factorización de Schur de la matriz A. El factor de Schur (cuasi) triangular se puede obtener del objeto Schur F con F.Schur o F.T y los vectores de Schur ortogonales/unitarios se pueden obtener con F.vectors o F.Z de tal manera que A = F.vectors * F.Schur * F.vectors'. Los valores propios de A se pueden obtener con F.values.

Para A real, la factorización de Schur es "cuasitridimensional", lo que significa que es superior-triangular excepto con bloques diagonales de 2×2 para cualquier par conjugado de valores propios complejos; esto permite que la factorización sea puramente real incluso cuando hay valores propios complejos. Para obtener la factorización de Schur (compleja) puramente superior-triangular a partir de una factorización cuasitridimensional real, puedes usar Schur{Complex}(schur(A)).

Iterar la descomposición produce los componentes F.T, F.Z y F.values.

Ejemplos

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
valores propios:
2-element Vector{Float64}:
  3.0
 -2.0

julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> t, z, vals = F; # desestructuración a través de la iteración

julia> t == F.T && z == F.Z && vals == F.values
true

schur(A, B) -> F::GeneralizedSchur

Calcula la factorización Schur generalizada (o QZ) de las matrices A y B. Los factores Schur (cuasi) triangulares se pueden obtener del objeto Schur F con F.S y F.T, los vectores Schur unitarios/ortogonales izquierdos se pueden obtener con F.left o F.Q y los vectores Schur unitarios/ortogonales derechos se pueden obtener con F.right o F.Z de tal manera que A=F.left*F.S*F.right' y B=F.left*F.T*F.right'. Los valores propios generalizados de A y B se pueden obtener con F.α./F.β.

Iterar la descomposición produce los componentes F.S, F.T, F.Q, F.Z, F.α y F.β.

schur!(A) -> F::Schur

Igual que schur pero utiliza el argumento de entrada A como espacio de trabajo.

Ejemplos

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur!(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
valores propios:
2-element Vector{Float64}:
  3.0
 -2.0

julia> A
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0

schur!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur

Igual que schur pero utiliza las matrices de entrada A y B como espacio de trabajo.

ordschur(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur

Reordena la factorización de Schur F de una matriz A = Z*T*Z' de acuerdo con el arreglo lógico select, devolviendo el objeto de factorización reordenado F. Los valores propios seleccionados aparecen en la diagonal principal de F.Schur y las correspondientes columnas principales de F.vectors forman una base ortogonal/unitaria del subespacio invariante derecho correspondiente. En el caso real, un par de valores propios conjugados complejos debe ser incluido o excluido en su totalidad a través de select.

ordschur(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur

Reordena la factorización de Schur generalizada F de un par de matrices (A, B) = (Q*S*Z', Q*T*Z') de acuerdo con el arreglo lógico select y devuelve un objeto GeneralizedSchur F. Los valores propios seleccionados aparecen en la diagonal principal de ambos F.S y F.T, y los vectores de Schur ortogonales/unitarios izquierdo y derecho también se reordenan de tal manera que (A, B) = F.Q*(F.S, F.T)*F.Z' aún se mantiene y los valores propios generalizados de A y B aún se pueden obtener con F.α./F.β.

ordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur

Igual que ordschur pero sobrescribe la factorización F.

ordschur!(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur

Igual que ordschur, pero sobrescribe la factorización F.

SVD <: Factorización

Tipo de factorización de matriz de la descomposición en valores singulares (SVD) de una matriz A. Este es el tipo de retorno de svd(_), la función de factorización de matriz correspondiente.

Si F::SVD es el objeto de factorización, U, S, V y Vt se pueden obtener a través de F.U, F.S, F.V y F.Vt, de tal manera que A = U * Diagonal(S) * Vt. Los valores singulares en S están ordenados en orden descendente.

Iterar la descomposición produce los componentes U, S y V.

Ejemplos

julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> F = svd(A)
SVD{Float64, Float64, Matrix{Float64}, Vector{Float64}}
U factor:
4×4 Matrix{Float64}:
 0.0  1.0   0.0  0.0
 1.0  0.0   0.0  0.0
 0.0  0.0   0.0  1.0
 0.0  0.0  -1.0  0.0
valores singulares:
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0
Vt factor:
4×5 Matrix{Float64}:
 -0.0        0.0  1.0  -0.0  0.0
  0.447214   0.0  0.0   0.0  0.894427
  0.0       -1.0  0.0   0.0  0.0
  0.0        0.0  0.0   1.0  0.0

julia> F.U * Diagonal(F.S) * F.Vt
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> u, s, v = F; # desestructuración a través de la iteración

julia> u == F.U && s == F.S && v == F.V
true

GeneralizedSVD <: Factorization

Tipo de factorización de matriz de la descomposición en valores singulares generalizada (SVD) de dos matrices A y B, tal que A = F.U*F.D1*F.R0*F.Q' y B = F.V*F.D2*F.R0*F.Q'. Este es el tipo de retorno de svd(_, _), la función de factorización de matriz correspondiente.

Para una matriz A de M por N y una matriz B de P por N,

• U es una matriz ortogonal de M por M,
• V es una matriz ortogonal de P por P,
• Q es una matriz ortogonal de N por N,
• D1 es una matriz diagonal de M por (K+L) con 1s en las primeras K entradas,
• D2 es una matriz de P por (K+L) cuyo bloque superior derecho de L por L es diagonal,
• R0 es una matriz de (K+L) por N cuyo bloque superior derecho de (K+L) por (K+L) es no singular y triangular superior,

K+L es el rango numérico efectivo de la matriz [A; B].

Iterar la descomposición produce los componentes U, V, Q, D1, D2 y R0.

Las entradas de F.D1 y F.D2 están relacionadas, como se explica en la documentación de LAPACK para el SVD generalizado y la rutina xGGSVD3 que se llama por debajo (en LAPACK 3.6.0 y versiones más nuevas).

Ejemplos

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> F = svd(A, B)
GeneralizedSVD{Float64, Matrix{Float64}, Float64, Vector{Float64}}
U factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
V factor:
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0   0.0
Q factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
D1 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
D2 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
R0 factor:
2×2 Matrix{Float64}:
 1.41421   0.0
 0.0      -1.41421

julia> F.U*F.D1*F.R0*F.Q'
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> F.V*F.D2*F.R0*F.Q'
2×2 Matrix{Float64}:
 -0.0  1.0
  1.0  0.0

svd(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

Calcula la descomposición en valores singulares (SVD) de A y devuelve un objeto SVD.

U, S, V y Vt se pueden obtener de la factorización F con F.U, F.S, F.V y F.Vt, de tal manera que A = U * Diagonal(S) * Vt. El algoritmo produce Vt y, por lo tanto, es más eficiente extraer Vt que V. Los valores singulares en S están ordenados en orden descendente.

Iterar la descomposición produce los componentes U, S y V.

Si full = false (por defecto), se devuelve una SVD "delgada". Para una matriz A de $M \times N$, en la factorización completa U es $M \times M$ y V es $N \times N$, mientras que en la factorización delgada U es $M \times K$ y V es $N \times K$, donde $K = \min(M,N)$ es el número de valores singulares.

Si alg = DivideAndConquer(), se utiliza un algoritmo de divide y vencerás para calcular la SVD. Otra opción (típicamente más lenta pero más precisa) es alg = QRIteration().

Ejemplos

julia> A = rand(4,3);

julia> F = svd(A); # Almacenar el objeto de factorización

julia> A ≈ F.U * Diagonal(F.S) * F.Vt
true

julia> U, S, V = F; # desestructuración a través de la iteración

julia> A ≈ U * Diagonal(S) * V'
true

julia> Uonly, = svd(A); # Almacenar solo U

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

Calcula la SVD generalizada de A y B, devolviendo un objeto de factorización GeneralizedSVD F tal que [A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q'

• U es una matriz ortogonal de M por M,
• V es una matriz ortogonal de P por P,
• Q es una matriz ortogonal de N por N,
• D1 es una matriz diagonal de M por (K+L) con 1s en las primeras K entradas,
• D2 es una matriz de P por (K+L) cuyo bloque superior derecho de L por L es diagonal,
• R0 es una matriz de (K+L) por N cuyo bloque superior derecho de (K+L) por (K+L) es no singular y triangular superior,

K+L es el rango numérico efectivo de la matriz [A; B].

Iterar la descomposición produce los componentes U, V, Q, D1, D2 y R0.

La SVD generalizada se utiliza en aplicaciones como cuando se quiere comparar cuánto pertenece a A frente a cuánto pertenece a B, como en el genoma humano frente al de levadura, o señal frente a ruido, o entre clústeres frente a dentro de clústeres. (Ver Edelman y Wang para discusión: https://arxiv.org/abs/1901.00485)

Descompone [A; B] en [UC; VS]H, donde [UC; VS] es una base ortogonal natural para el espacio de columnas de [A; B], y H = RQ' es una base no ortogonal natural para el espacio de filas de [A;B], donde las filas superiores se atribuyen más estrechamente a la matriz A, y las inferiores a la matriz B. Las matrices multi-coseno/seno C y S proporcionan una medida múltiple de cuánto A frente a cuánto B, y U y V proporcionan direcciones en las que se miden.

Ejemplos

julia> A = randn(3,2); B=randn(4,2);

julia> F = svd(A, B);

julia> U,V,Q,C,S,R = F;

julia> H = R*Q';

julia> [A; B] ≈ [U*C; V*S]*H
true

julia> [A; B] ≈ [F.U*F.D1; F.V*F.D2]*F.R0*F.Q'
true

julia> Uonly, = svd(A,B);

julia> U == Uonly
true

svd!(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

svd! es lo mismo que svd, pero ahorra espacio al sobrescribir la entrada A, en lugar de crear una copia. Consulta la documentación de svd para más detalles.

svd!(A, B) -> GeneralizedSVD

svd! es lo mismo que svd, pero modifica los argumentos A y B en su lugar, en lugar de hacer copias. Consulta la documentación de svd para más detalles.

svdvals(A)

Devuelve los valores singulares de A en orden descendente.

Ejemplos

julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> svdvals(A)
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0

svdvals(A, B)

Devuelve los valores singulares generalizados de la descomposición en valores singulares generalizados de A y B. Ver también svd.

Ejemplos

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> svdvals(A, B)
2-element Vector{Float64}:
 1.0
 1.0

svdvals!(A)

Devuelve los valores singulares de A, ahorrando espacio al sobrescribir la entrada. Consulta también svdvals y svd.

svdvals!(A, B)

Devuelve los valores singulares generalizados de la descomposición en valores singulares generalizados de A y B, ahorrando espacio al sobrescribir A y B. Véase también svd y svdvals.

LinearAlgebra.Givens(i1,i2,c,s) -> G

Un operador lineal de rotación de Givens. Los campos c y s representan el coseno y el seno del ángulo de rotación, respectivamente. El tipo Givens admite la multiplicación por la izquierda G*A y la multiplicación por la derecha con transposición conjugada A*G'. El tipo no tiene un size y, por lo tanto, se puede multiplicar con matrices de tamaño arbitrario siempre que i2<=size(A,2) para G*A o i2<=size(A,1) para A*G'.

Ver también givens.

givens(f::T, g::T, i1::Integer, i2::Integer) where {T} -> (G::Givens, r::T)

Calcula la rotación de Givens G y el escalar r tal que para cualquier vector x donde

x[i1] = f
x[i2] = g

el resultado de la multiplicación

y = G*x

tiene la propiedad de que

y[i1] = r
y[i2] = 0

Ver también LinearAlgebra.Givens.

givens(A::AbstractArray, i1::Integer, i2::Integer, j::Integer) -> (G::Givens, r)

Calcula la rotación de Givens G y el escalar r tal que el resultado de la multiplicación

B = G*A

tiene la propiedad de que

B[i1,j] = r
B[i2,j] = 0

Ver también LinearAlgebra.Givens. ```

givens(x::AbstractVector, i1::Integer, i2::Integer) -> (G::Givens, r)

Calcula la rotación de Givens G y el escalar r tal que el resultado de la multiplicación

B = G*x

tiene la propiedad de que

B[i1] = r
B[i2] = 0

Ver también LinearAlgebra.Givens. ```

triu(M)

Triángulo superior de una matriz.

Ejemplos

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 0.0  1.0  1.0  1.0
 0.0  0.0  1.0  1.0
 0.0  0.0  0.0  1.0

triu(M, k::Integer)

Devuelve el triángulo superior de M comenzando desde la k-ésima superdiagonal.

Ejemplos

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a,3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  1.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0

julia> triu(a,-3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

triu!(M)

Triángulo superior de una matriz, sobrescribiendo M en el proceso. Ver también triu.

triu!(M, k::Integer)

Devuelve el triángulo superior de M comenzando desde la k-ésima superdiagonal, sobrescribiendo M en el proceso.

Ejemplos

julia> M = [1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5]
5×5 Matrix{Int64}:
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

julia> triu!(M, 1)
5×5 Matrix{Int64}:
 0  2  3  4  5
 0  0  3  4  5
 0  0  0  4  5
 0  0  0  0  5
 0  0  0  0  0

tril(M)

Triángulo inferior de una matriz.

Ejemplos

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a)
4×4 Matrix{Float64}:
 1.0  0.0  0.0  0.0
 1.0  1.0  0.0  0.0
 1.0  1.0  1.0  0.0
 1.0  1.0  1.0  1.0

tril(M, k::Integer)

Devuelve el triángulo inferior de M comenzando desde la k-ésima superdiagonal.

Ejemplos

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,-3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 1.0  0.0  0.0  0.0

tril!(M)

Triángulo inferior de una matriz, sobrescribiendo M en el proceso. Ver también tril.

tril!(M, k::Integer)

Devuelve el triángulo inferior de M comenzando desde la k-ésima superdiagonal, sobrescribiendo M en el proceso.

Ejemplos

julia> M = [1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5]
5×5 Matrix{Int64}:
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

julia> tril!(M, 2)
5×5 Matrix{Int64}:
 1  2  3  0  0
 1  2  3  4  0
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

diagind(M::AbstractMatrix, k::Integer = 0, indstyle::IndexStyle = IndexLinear())
diagind(M::AbstractMatrix, indstyle::IndexStyle = IndexLinear())

Un AbstractRange que da los índices de la k-ésima diagonal de la matriz M. Opcionalmente, se puede especificar un estilo de índice que determina el tipo de rango devuelto. Si indstyle isa IndexLinear (por defecto), esto devuelve un AbstractRange{Integer}. Por otro lado, si indstyle isa IndexCartesian, esto devuelve un AbstractRange{CartesianIndex{2}}.

Si k no se proporciona, se asume que es 0 (correspondiente a la diagonal principal).

Ver también: diag, diagm, Diagonal.

Ejemplos

julia> A = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> diagind(A, -1)
2:4:6

julia> diagind(A, IndexCartesian())
StepRangeLen(CartesianIndex(1, 1), CartesianIndex(1, 1), 3)

diag(M, k::Integer=0)

La k-ésima diagonal de una matriz, como un vector.

Véase también diagm, diagind, Diagonal, isdiag.

Ejemplos

julia> A = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> diag(A,1)
2-element Vector{Int64}:
 2
 6

diagm(kv::Pair{<:Integer,<:AbstractVector}...)
diagm(m::Integer, n::Integer, kv::Pair{<:Integer,<:AbstractVector}...)

Construye una matriz a partir de `Pair`s de diagonales y vectores. El vector `kv.second` se colocará en la diagonal `kv.first`. Por defecto, la matriz es cuadrada y su tamaño se infiere de `kv`, pero se puede especificar un tamaño no cuadrado `m`×`n` (rellenado con ceros según sea necesario) pasando `m,n` como los primeros argumentos. Para índices de diagonal repetidos `kv.first`, los valores en los vectores correspondientes `kv.second` se sumarán.

`diagm` construye una matriz completa; si deseas versiones que ahorren espacio con aritmética rápida, consulta [`Diagonal`](@ref), [`Bidiagonal`](@ref), [`Tridiagonal`](@ref) y [`SymTridiagonal`](@ref).

# Ejemplos

jldoctest julia> diagm(1 => [1,2,3]) 4×4 Matrix{Int64}: 0 1 0 0 0 0 2 0 0 0 0 3 0 0 0 0

julia> diagm(1 => [1,2,3], -1 => [4,5]) 4×4 Matrix{Int64}: 0 1 0 0 4 0 2 0 0 5 0 3 0 0 0 0

julia> diagm(1 => [1,2,3], 1 => [1,2,3]) 4×4 Matrix{Int64}: 0 2 0 0 0 0 4 0 0 0 0 6 0 0 0 0 ```

diagm(v::AbstractVector)
diagm(m::Integer, n::Integer, v::AbstractVector)

Construye una matriz con los elementos del vector como elementos diagonales. Por defecto, la matriz es cuadrada y su tamaño está dado por length(v), pero se puede especificar un tamaño no cuadrado m×n pasando m,n como los primeros argumentos.

Ejemplos

julia> diagm([1,2,3])
3×3 Matrix{Int64}:
 1  0  0
 0  2  0
 0  0  3

rank(::QRSparse{Tv,Ti}) -> Ti

Devuelve el rango de la factorización QR

rank(S::SparseMatrixCSC{Tv,Ti}; [tol::Real]) -> Ti

Calcula el rango de S calculando su factorización QR. Los valores menores que tol se consideran cero. Consulta el manual de SPQR.

rank(A::AbstractMatrix; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
rank(A::AbstractMatrix, rtol::Real)

Calcula el rango numérico de una matriz contando cuántos valores de salida de svdvals(A) son mayores que max(atol, rtol*σ₁), donde σ₁ es el valor singular más grande calculado de A. atol y rtol son las tolerancias absolutas y relativas, respectivamente. La tolerancia relativa por defecto es n*ϵ, donde n es el tamaño de la dimensión más pequeña de A, y ϵ es el eps del tipo de elemento de A.

Ejemplos

julia> rank(Matrix(I, 3, 3))
3

julia> rank(diagm(0 => [1, 0, 2]))
2

julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.1)
2

julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.00001)
3

julia> rank(diagm(0 => [1, 0.001, 2]), atol=1.5)
1

norm(A, p::Real=2)

Para cualquier contenedor iterable A (incluyendo arreglos de cualquier dimensión) de números (o cualquier tipo de elemento para el cual norm está definido), calcula la p-norma (por defecto p=2) como si A fuera un vector de la longitud correspondiente.

La p-norma se define como

\[\|A\|_p = \left( \sum_{i=1}^n | a_i | ^p \right)^{1/p}\]

con $a_i$ las entradas de A, $| a_i |$ la norm de $a_i$, y $n$ la longitud de A. Dado que la p-norma se calcula utilizando las norms de las entradas de A$, lap-norma de un vector de vectores no es compatible con la interpretación de este como un vector bloque en general sip != 2`.

p puede asumir cualquier valor numérico (aunque no todos los valores producen una norma de vector matemáticamente válida). En particular, norm(A, Inf) devuelve el valor más grande en abs.(A), mientras que norm(A, -Inf) devuelve el más pequeño. Si A es una matriz y p=2, entonces esto es equivalente a la norma de Frobenius.

El segundo argumento p no es necesariamente parte de la interfaz para norm, es decir, un tipo personalizado puede implementar solo norm(A) sin el segundo argumento.

Usa opnorm para calcular la norma del operador de una matriz.

Ejemplos

julia> v = [3, -2, 6]
3-element Vector{Int64}:
  3
 -2
  6

julia> norm(v)
7.0

julia> norm(v, 1)
11.0

julia> norm(v, Inf)
6.0

julia> norm([1 2 3; 4 5 6; 7 8 9])
16.881943016134134

julia> norm([1 2 3 4 5 6 7 8 9])
16.881943016134134

julia> norm(1:9)
16.881943016134134

julia> norm(hcat(v,v), 1) == norm(vcat(v,v), 1) != norm([v,v], 1)
true

julia> norm(hcat(v,v), 2) == norm(vcat(v,v), 2) == norm([v,v], 2)
true

julia> norm(hcat(v,v), Inf) == norm(vcat(v,v), Inf) != norm([v,v], Inf)
true

norm(x::Number, p::Real=2)

Para números, devuelve $\left( |x|^p \right)^{1/p}$.

Ejemplos

julia> norm(2, 1)
2.0

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0

opnorm(A::AbstractMatrix, p::Real=2)

Calcula la norma del operador (o norma de matriz) inducida por la norma vectorial p, donde los valores válidos de p son 1, 2 o Inf. (Ten en cuenta que para matrices dispersas, p=2 actualmente no está implementado). Usa norm para calcular la norma de Frobenius.

Cuando p=1, la norma del operador es la suma máxima de columnas absolutas de A:

\[\|A\|_1 = \max_{1 ≤ j ≤ n} \sum_{i=1}^m | a_{ij} |\]

con $a_{ij}$ las entradas de $A$, y $m$ y $n$ sus dimensiones.

Cuando p=2, la norma del operador es la norma espectral, igual al mayor valor singular de A.

Cuando p=Inf, la norma del operador es la suma máxima de filas absolutas de A:

\[\|A\|_\infty = \max_{1 ≤ i ≤ m} \sum _{j=1}^n | a_{ij} |\]

Ejemplos

julia> A = [1 -2 -3; 2 3 -1]
2×3 Matrix{Int64}:
 1  -2  -3
 2   3  -1

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0

opnorm(x::Number, p::Real=2)

Para números, devuelve $\left( |x|^p \right)^{1/p}$. Esto es equivalente a norm.

opnorm(A::Adjoint{<:Any,<:AbstractVector}, q::Real=2)
opnorm(A::Transpose{<:Any,<:AbstractVector}, q::Real=2)

Para vectores envueltos en Adjoint/Transpose, devuelve el operador $q$-norm de A, que es equivalente al p-norm con valor p = q/(q-1). Coinciden en p = q = 2. Usa norm para calcular el p norm de A como un vector.

La diferencia en la norma entre un espacio vectorial y su dual surge para preservar la relación entre dualidad y el producto punto, y el resultado es consistente con el operador p-norm de una matriz 1 × n.

Ejemplos

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

normalize!(a::AbstractArray, p::Real=2)

Normaliza el arreglo a en su lugar para que su p-norma sea igual a la unidad, es decir, norm(a, p) == 1. Consulta también normalize y norm.

normalize(a, p::Real=2)

Normaliza a de modo que su p-norma sea igual a la unidad, es decir, norm(a, p) == 1. Para escalares, esto es similar a sign(a), excepto que normalize(0) = NaN. Consulta también normalize!, norm, y sign.

Ejemplos

julia> a = [1,2,4];

julia> b = normalize(a)
3-element Vector{Float64}:
 0.2182178902359924
 0.4364357804719848
 0.8728715609439696

julia> norm(b)
1.0

julia> c = normalize(a, 1)
3-element Vector{Float64}:
 0.14285714285714285
 0.2857142857142857
 0.5714285714285714

julia> norm(c, 1)
1.0

julia> a = [1 2 4 ; 1 2 4]
2×3 Matrix{Int64}:
 1  2  4
 1  2  4

julia> norm(a)
6.48074069840786

julia> normalize(a)
2×3 Matrix{Float64}:
 0.154303  0.308607  0.617213
 0.154303  0.308607  0.617213

julia> normalize(3, 1)
1.0

julia> normalize(-8, 1)
-1.0

julia> normalize(0, 1)
NaN

cond(M, p::Real=2)

Número de condición de la matriz M, calculado utilizando la norma del operador p. Los valores válidos para p son 1, 2 (por defecto) o Inf.

condskeel(M, [x, p::Real=Inf])

\[\kappa_S(M, p) = \left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \right\Vert_p \\ \kappa_S(M, x, p) = \frac{\left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \left\vert x \right\vert \right\Vert_p}{\left \Vert x \right \Vert_p}\]

El número de condición de Skeel $\kappa_S$ de la matriz M, opcionalmente con respecto al vector x, se calcula utilizando la norma del operador p. $\left\vert M \right\vert$ denota la matriz de valores absolutos (por entrada) de $M$; $\left\vert M \right\vert_{ij} = \left\vert M_{ij} \right\vert$. Los valores válidos para p son 1, 2 e Inf (por defecto).

Esta cantidad también se conoce en la literatura como el número de condición de Bauer, número de condición relativo o número de condición relativo por componente.

tr(M)

Traza de la matriz. Suma los elementos diagonales de M.

Ejemplos

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> tr(A)
5

det(M)

Determinante de la matriz.

Véase también: logdet y logabsdet.

Ejemplos

julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
 1  0
 2  2

julia> det(M)
2.0

logdet(M)

Logaritmo del determinante de la matriz. Equivalente a log(det(M)), pero puede proporcionar mayor precisión y evita desbordamiento/subdesbordamiento.

Ejemplos

julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
 1  0
 2  2

julia> logdet(M)
0.6931471805599453

julia> logdet(Matrix(I, 3, 3))
0.0

logabsdet(M)

Logaritmo del valor absoluto del determinante de la matriz. Equivalente a (log(abs(det(M))), sign(det(M))), pero puede proporcionar mayor precisión y/o velocidad.

Ejemplos

julia> A = [-1. 0.; 0. 1.]
2×2 Matrix{Float64}:
 -1.0  0.0
  0.0  1.0

julia> det(A)
-1.0

julia> logabsdet(A)
(0.0, -1.0)

julia> B = [2. 0.; 0. 1.]
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  1.0

julia> det(B)
2.0

julia> logabsdet(B)
(0.6931471805599453, 1.0)

inv(M)

Inversa de matriz. Calcula la matriz N tal que M * N = I, donde I es la matriz identidad. Se calcula resolviendo la división izquierda N = M \ I.

Ejemplos

julia> M = [2 5; 1 3]
2×2 Matrix{Int64}:
 2  5
 1  3

julia> N = inv(M)
2×2 Matrix{Float64}:
  3.0  -5.0
 -1.0   2.0

julia> M*N == N*M == Matrix(I, 2, 2)
true

pinv(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
pinv(M, rtol::Real) = pinv(M; rtol=rtol) # será desaprobado en Julia 2.0

Calcula la pseudoinversa de Moore-Penrose.

Para matrices M con elementos de punto flotante, es conveniente calcular la pseudoinversa invirtiendo solo los valores singulares mayores que max(atol, rtol*σ₁) donde σ₁ es el mayor valor singular de M.

La elección óptima de la tolerancia absoluta (atol) y la tolerancia relativa (rtol) varía tanto con el valor de M como con la aplicación prevista de la pseudoinversa. La tolerancia relativa predeterminada es n*ϵ, donde n es el tamaño de la dimensión más pequeña de M, y ϵ es el eps del tipo de elemento de M.

Para invertir matrices densas mal condicionadas en un sentido de mínimos cuadrados, se recomienda rtol = sqrt(eps(real(float(oneunit(eltype(M)))))).

Para más información, consulte ^[issue8859], ^[B96], ^[S84], ^[KY88].

Ejemplos

julia> M = [1.5 1.3; 1.2 1.9]
2×2 Matrix{Float64}:
 1.5  1.3
 1.2  1.9

julia> N = pinv(M)
2×2 Matrix{Float64}:
  1.47287   -1.00775
 -0.930233   1.16279

julia> M * N
2×2 Matrix{Float64}:
 1.0          -2.22045e-16
 4.44089e-16   1.0

nullspace(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
nullspace(M, rtol::Real) = nullspace(M; rtol=rtol) # será desaprobado en Julia 2.0

Calcula una base para el espacio nulo de `M` incluyendo los vectores singulares de `M` cuyos valores singulares tienen magnitudes menores que `max(atol, rtol*σ₁)`, donde `σ₁` es el mayor valor singular de `M`.

Por defecto, la tolerancia relativa `rtol` es `n*ϵ`, donde `n` es el tamaño de la dimensión más pequeña de `M`, y `ϵ` es el [`eps`](@ref) del tipo de elemento de `M`.

# Ejemplos

jldoctest julia> M = [1 0 0; 0 1 0; 0 0 0] 3×3 Matrix{Int64}: 1 0 0 0 1 0 0 0 0

julia> nullspace(M) 3×1 Matrix{Float64}: 0.0 0.0 1.0

julia> nullspace(M, rtol=3) 3×3 Matrix{Float64}: 0.0 1.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0

julia> nullspace(M, atol=0.95) 3×1 Matrix{Float64}: 0.0 0.0 1.0 ```

kron(A, B)

Calcula el producto de Kronecker de dos vectores, matrices o números.

Para vectores reales v y w, el producto de Kronecker está relacionado con el producto exterior por kron(v,w) == vec(w * transpose(v)) o w * transpose(v) == reshape(kron(v,w), (length(w), length(v))). Nota cómo el orden de v y w difiere a la izquierda y a la derecha de estas expresiones (debido al almacenamiento por columnas). Para vectores complejos, el producto exterior w * v' también difiere por la conjugación de v.

Ejemplos

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> B = [im 1; 1 -im]
2×2 Matrix{Complex{Int64}}:
 0+1im  1+0im
 1+0im  0-1im

julia> kron(A, B)
4×4 Matrix{Complex{Int64}}:
 0+1im  1+0im  0+2im  2+0im
 1+0im  0-1im  2+0im  0-2im
 0+3im  3+0im  0+4im  4+0im
 3+0im  0-3im  4+0im  0-4im

julia> v = [1, 2]; w = [3, 4, 5];

julia> w*transpose(v)
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

julia> reshape(kron(v,w), (length(w), length(v)))
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

kron!(C, A, B)

Calcula el producto de Kronecker de A y B y almacena el resultado en C, sobrescribiendo el contenido existente de C. Esta es la versión en su lugar de kron.

exp(A::AbstractMatrix)

Calcula la exponencial de la matriz de A, definida por

\[e^A = \sum_{n=0}^{\infty} \frac{A^n}{n!}.\]

Para A simétrica o hermítica, se utiliza una descomposición en valores propios (eigen), de lo contrario se elige el algoritmo de escalado y cuadrado (ver ^[H05]).

Ejemplos

julia> A = Matrix(1.0I, 2, 2)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

julia> exp(A)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828

cis(A::AbstractMatrix)

Método más eficiente para exp(im*A) de la matriz cuadrada A (especialmente si A es Hermitiana o Simétrica real).

Véase también cispi, sincos, exp.

Ejemplos

julia> cis([π 0; 0 π]) ≈ -I
true

^(A::AbstractMatrix, p::Number)

Potencia de matriz, equivalente a $\exp(p\log(A))$

Ejemplos

julia> [1 2; 0 3]^3
2×2 Matrix{Int64}:
 1  26
 0  27

^(b::Número, A::MatrizAbstracta)

Exponencial de matriz, equivalente a $\exp(\log(b)A)$.

Ejemplos

julia> 2^[1 2; 0 3]
2×2 Matriz{Float64}:
 2.0  6.0
 0.0  8.0

julia> ℯ^[1 2; 0 3]
2×2 Matriz{Float64}:
 2.71828  17.3673
 0.0      20.0855

log(A::AbstractMatrix)

Si A no tiene valores propios reales negativos, calcula el logaritmo matricial principal de A, es decir, la matriz única $X$ tal que $e^X = A$ y $-\pi < Im(\lambda) < \pi$ para todos los valores propios $\lambda$ de $X$. Si A tiene valores propios no positivos, se devuelve una función matricial no principal siempre que sea posible.

Si A es simétrica o hermítica, se utiliza su descomposición en valores propios (eigen), si A es triangular se emplea una versión mejorada del método de escalado inverso y cuadrado (ver ^[AH12] y ^[AHR13]). Si A es real sin valores propios negativos, entonces se calcula la forma de Schur real. De lo contrario, se calcula la forma de Schur compleja. Luego se utiliza el algoritmo triangular superior (cuasi-)triangular en ^[AHR13] sobre el factor (cuasi-)triangular superior.

Ejemplos

julia> A = Matrix(2.7182818*I, 2, 2)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828

julia> log(A)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

sqrt(x)

Devuelve $\sqrt{x}$.

Lanza DomainError para argumentos Real negativos. Usa argumentos negativos complejos en su lugar. Ten en cuenta que sqrt tiene un corte de rama a lo largo del eje real negativo.

El operador prefijo √ es equivalente a sqrt.

Véase también: hypot.

Ejemplos

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError con -81.0:
Resultado NaN para entrada no-NaN.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> sqrt(-81 - 0.0im)  # -0.0im está por debajo del corte de rama
0.0 - 9.0im

julia> .√(1:4)
Vector de 4 elementos{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

sqrt(A::AbstractMatrix)

Si A no tiene valores propios reales negativos, calcula la raíz cuadrada principal de la matriz A, es decir, la matriz única $X$ con valores propios que tienen parte real positiva tal que $X^2 = A$. De lo contrario, se devuelve una raíz cuadrada no principal.

Si A es simétrica real o hermítica, se utiliza su descomposición en valores propios (eigen) para calcular la raíz cuadrada. Para tales matrices, los valores propios λ que parecen ser ligeramente negativos debido a errores de redondeo se tratan como si fueran cero. Más precisamente, las matrices con todos los valores propios ≥ -rtol*(max |λ|) se tratan como semidefinidas (produciendo una raíz cuadrada hermítica), con los valores propios negativos considerados como cero. rtol es un argumento de palabra clave para sqrt (solo en el caso hermítico/simétrico real) que por defecto es la precisión de la máquina escalada por size(A,1).

De lo contrario, la raíz cuadrada se determina por medio del método de Björck-Hammarling ^[BH83], que calcula la forma de Schur compleja (schur) y luego la raíz cuadrada compleja del factor triangular. Si existe una raíz cuadrada real, entonces se utiliza una extensión de este método ^[H87] que calcula la forma de Schur real y luego la raíz cuadrada real del factor cuasi-triangular.

Ejemplos

julia> A = [4 0; 0 4]
2×2 Matrix{Int64}:
 4  0
 0  4

julia> sqrt(A)
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

cbrt(A::AbstractMatrix{<:Real})

Calcula la raíz cúbica de valor real de una matriz de valor real A. Si T = cbrt(A), entonces tenemos T*T*T ≈ A, ver el ejemplo dado a continuación.

Si A es simétrica, es decir, de tipo HermOrSym{<:Real}, entonces se utiliza (eigen) para encontrar la raíz cúbica. De lo contrario, se utiliza una versión especializada del algoritmo de raíz p-ésima ^[S03], que explota la descomposición de Schur de valor real (schur) para calcular la raíz cúbica.

Ejemplos

julia> A = [0.927524 -0.15857; -1.3677 -1.01172]
2×2 Matrix{Float64}:
  0.927524  -0.15857
 -1.3677    -1.01172

julia> T = cbrt(A)
2×2 Matrix{Float64}:
  0.910077  -0.151019
 -1.30257   -0.936818

julia> T*T*T ≈ A
true

cos(A::AbstractMatrix)

Calcula el coseno de matriz de una matriz cuadrada A.

Si A es simétrica o hermítica, se utiliza su descomposición en valores propios (eigen) para calcular el coseno. De lo contrario, el coseno se determina llamando a exp.

Ejemplos

julia> cos(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

sin(A::AbstractMatrix)

Calcula el seno de matriz de una matriz cuadrada A.

Si A es simétrica o hermitiana, se utiliza su descomposición en valores propios (eigen) para calcular el seno. De lo contrario, el seno se determina llamando a exp.

Ejemplos

julia> sin(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

sincos(A::AbstractMatrix)

Calcula el seno y el coseno de matriz de una matriz cuadrada A.

Ejemplos

julia> S, C = sincos(fill(1.0, (2,2)));

julia> S
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

julia> C
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

tan(A::AbstractMatrix)

Calcula la tangente de matriz de una matriz cuadrada A.

Si A es simétrica o hermítica, se utiliza su descomposición en valores propios (eigen) para calcular la tangente. De lo contrario, la tangente se determina llamando a exp.

Ejemplos

julia> tan(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 -1.09252  -1.09252
 -1.09252  -1.09252

sec(A::AbstractMatrix)

Calcula la secante de matriz de una matriz cuadrada A.

csc(A::AbstractMatrix)

Calcula la cosecante de matriz de una matriz cuadrada A.

cot(A::AbstractMatrix)

Calcula la cotangente de matriz de una matriz cuadrada A.

cosh(A::AbstractMatrix)

Calcula el coseno hiperbólico de matriz de una matriz cuadrada A.

sinh(A::AbstractMatrix)

Calcula el seno hiperbólico de matriz de una matriz cuadrada A.

tanh(A::AbstractMatrix)

Calcula la tangente hiperbólica de una matriz cuadrada A.

sech(A::AbstractMatrix)

Calcula la secante hiperbólica de matriz del cuadrado A.

csch(A::AbstractMatrix)

Calcula la cosecante hiperbólica de matriz del cuadrado A.

coth(A::AbstractMatrix)

Calcula la cotangente hiperbólica de matriz del cuadrado A.

acos(A::AbstractMatrix)

Calcula el coseno inverso de una matriz cuadrada A.

Si A es simétrica o hermítica, se utiliza su descomposición en valores propios (eigen) para calcular el coseno inverso. De lo contrario, el coseno inverso se determina utilizando log y sqrt. Para la teoría y las fórmulas logarítmicas utilizadas para calcular esta función, consulte ^[AH16_1].

Ejemplos

julia> acos(cos([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-8.32667e-17im  0.1+0.0im
 -0.2+2.63678e-16im  0.3-3.46945e-16im

asin(A::AbstractMatrix)

Calcula el seno inverso de una matriz cuadrada A.

Si A es simétrica o hermítica, se utiliza su descomposición en valores propios (eigen) para calcular el seno inverso. De lo contrario, el seno inverso se determina utilizando log y sqrt. Para la teoría y las fórmulas logarítmicas utilizadas para calcular esta función, consulte ^[AH16_2].

Ejemplos

julia> asin(sin([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-4.16334e-17im  0.1-5.55112e-17im
 -0.2+9.71445e-17im  0.3-1.249e-16im

atan(A::AbstractMatrix)

Calcula la tangente inversa de una matriz cuadrada A.

Si A es simétrica o hermítica, se utiliza su descomposición en valores propios (eigen) para calcular la tangente inversa. De lo contrario, la tangente inversa se determina utilizando log. Para la teoría y las fórmulas logarítmicas utilizadas para calcular esta función, consulte ^[AH16_3].

Ejemplos

julia> atan(tan([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5+1.38778e-17im  0.1-2.77556e-17im
 -0.2+6.93889e-17im  0.3-4.16334e-17im

asec(A::AbstractMatrix)

Calcula la matriz secante inversa de A.

acsc(A::AbstractMatrix)

Calcula la cosecante de la matriz inversa de A.

acot(A::AbstractMatrix)

Calcula la matriz cotangente inversa de A.

acosh(A::AbstractMatrix)

Calcula el coseno hiperbólico inverso de una matriz cuadrada A. Para la teoría y las fórmulas logarítmicas utilizadas para calcular esta función, consulta ^[AH16_4].

asinh(A::AbstractMatrix)

Calcula el seno hiperbólico inverso de una matriz cuadrada A. Para la teoría y las fórmulas logarítmicas utilizadas para calcular esta función, consulta ^[AH16_5].

atanh(A::AbstractMatrix)

Calcula la tangente hiperbólica inversa de una matriz cuadrada A. Para la teoría y las fórmulas logarítmicas utilizadas para calcular esta función, consulta ^[AH16_6].

asech(A::AbstractMatrix)

Calcula la secante hiperbólica inversa de A.

acsch(A::AbstractMatrix)

Calcula la cosecante hiperbólica inversa de la matriz A.

acoth(A::AbstractMatrix)

Calcula la cotangente hiperbólica inversa de A.

lyap(A, C)

Calcula la solución X de la ecuación de Lyapunov continua AX + XA' + C = 0, donde ningún valor propio de A tiene una parte real cero y ningún par de valores propios son conjugados complejos negativos entre sí.

Ejemplos

julia> A = [3. 4.; 5. 6]
2×2 Matrix{Float64}:
 3.0  4.0
 5.0  6.0

julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
 1.0  1.0
 1.0  2.0

julia> X = lyap(A, B)
2×2 Matrix{Float64}:
  0.5  -0.5
 -0.5   0.25

julia> A*X + X*A' ≈ -B
true

sylvester(A, B, C)

Calcula la solución X de la ecuación de Sylvester AX + XB + C = 0, donde A, B y C tienen dimensiones compatibles y A y -B no tienen valores propios con la misma parte real.

Ejemplos

julia> A = [3. 4.; 5. 6]
2×2 Matrix{Float64}:
 3.0  4.0
 5.0  6.0

julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
 1.0  1.0
 1.0  2.0

julia> C = [1. 2.; -2. 1]
2×2 Matrix{Float64}:
  1.0  2.0
 -2.0  1.0

julia> X = sylvester(A, B, C)
2×2 Matrix{Float64}:
 -4.46667   1.93333
  3.73333  -1.8

julia> A*X + X*B ≈ -C
true

issuccess(F::Factorization)

Prueba que una factorización de una matriz tuvo éxito.

Ejemplos

julia> F = cholesky([1 0; 0 1]);

julia> issuccess(F)
true

issuccess(F::LU; allowsingular = false)

Prueba que la factorización LU de una matriz tuvo éxito. Por defecto, una factorización que produce un factor U válido pero deficiente en rango se considera un fallo. Esto se puede cambiar pasando allowsingular = true.

Ejemplos

julia> F = lu([1 2; 1 2], check = false);

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true

issymmetric(A) -> Bool

Prueba si una matriz es simétrica.

Ejemplos

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> issymmetric(a)
true

julia> b = [1 im; -im 1]
2×2 Matrix{Complex{Int64}}:
 1+0im  0+1im
 0-1im  1+0im

julia> issymmetric(b)
false

isposdef(A) -> Bool

Prueba si una matriz es definida positiva (y Hermitiana) intentando realizar una factorización de Cholesky de A.

Ver también isposdef!, cholesky.

Ejemplos

julia> A = [1 2; 2 50]
2×2 Matrix{Int64}:
 1   2
 2  50

julia> isposdef(A)
true

isposdef!(A) -> Bool

Prueba si una matriz es definida positiva (y Hermitiana) intentando realizar una factorización de Cholesky de A, sobrescribiendo A en el proceso. Ver también isposdef.

Ejemplos

julia> A = [1. 2.; 2. 50.];

julia> isposdef!(A)
true

julia> A
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  6.78233

istril(A::AbstractMatrix, k::Integer = 0) -> Bool

Prueba si A es triangular inferior comenzando desde la k-ésima superdiagonal.

Ejemplos

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> istril(a)
false

julia> istril(a, 1)
true

julia> c = [1 1 0; 1 1 1; 1 1 1]
3×3 Matrix{Int64}:
 1  1  0
 1  1  1
 1  1  1

julia> istril(c)
false

julia> istril(c, 1)
true

istriu(A::AbstractMatrix, k::Integer = 0) -> Bool

Prueba si A es triangular superior comenzando desde la k-ésima superdiagonal.

Ejemplos

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> istriu(a)
false

julia> istriu(a, -1)
true

julia> c = [1 1 1; 1 1 1; 0 1 1]
3×3 Matrix{Int64}:
 1  1  1
 1  1  1
 0  1  1

julia> istriu(c)
false

julia> istriu(c, -1)
true

isdiag(A) -> Bool

Prueba si una matriz es diagonal en el sentido de que iszero(A[i,j]) es verdadero a menos que i == j. Ten en cuenta que no es necesario que A sea cuadrada; si también deseas verificar eso, necesitas comprobar que size(A, 1) == size(A, 2).

Ejemplos

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> isdiag(a)
false

julia> b = [im 0; 0 -im]
2×2 Matrix{Complex{Int64}}:
 0+1im  0+0im
 0+0im  0-1im

julia> isdiag(b)
true

julia> c = [1 0 0; 0 2 0]
2×3 Matrix{Int64}:
 1  0  0
 0  2  0

julia> isdiag(c)
true

julia> d = [1 0 0; 0 2 3]
2×3 Matrix{Int64}:
 1  0  0
 0  2  3

julia> isdiag(d)
false

ishermitian(A) -> Bool

Prueba si una matriz es Hermitiana.

Ejemplos

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> ishermitian(a)
true

julia> b = [1 im; -im 1]
2×2 Matrix{Complex{Int64}}:
 1+0im  0+1im
 0-1im  1+0im

julia> ishermitian(b)
true

transpose(A)

Transposición perezosa. Mutar el objeto devuelto debería mutar apropiadamente A. A menudo, pero no siempre, produce Transpose(A), donde Transpose es un envoltorio de transposición perezosa. Tenga en cuenta que esta operación es recursiva.

Esta operación está destinada al uso en álgebra lineal; para manipulación de datos general, consulte permutedims, que no es recursiva.

Ejemplos

julia> A = [3 2; 0 0]
2×2 Matrix{Int64}:
 3  2
 0  0

julia> B = transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 3  0
 2  0

julia> B isa Transpose
true

julia> transpose(B) === A # la transposición de una transposición desenvuelve el padre
true

julia> Transpose(B) # sin embargo, el constructor siempre envuelve su argumento
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # modificar B modificará A automáticamente

julia> A
2×2 Matrix{Int64}:
 3  2
 4  0

Para matrices complejas, la operación adjoint es equivalente a una transposición conjugada.

julia> A = reshape([Complex(x, x) for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> adjoint(A) == conj(transpose(A))
true

La transpose de un AbstractVector es un vector fila:

julia> v = [1,2,3]
3-element Vector{Int64}:
 1
 2
 3

julia> transpose(v) # devuelve un vector fila
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # calcular el producto punto
14

Para una matriz de matrices, los bloques individuales se operan recursivamente:

julia> C = [1 3; 2 4]
2×2 Matrix{Int64}:
 1  3
 2  4

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # construir una matriz de bloques
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # los bloques se transponen recursivamente
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]

transpose(F::Factorization)

Transposición perezosa de la factorización F. Por defecto, devuelve una TransposeFactorization, excepto para Factorizations con eltype real, en cuyo caso devuelve una AdjointFactorization.

transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) donde {Tv,Ti}

Transpone la matriz A y la almacena en la matriz X. size(X) debe ser igual a size(transpose(A)). No se asigna memoria adicional más allá de redimensionar rowval y nzval de X, si es necesario.

Consulta halfperm!

transpose!(dest,src)

Transponer el arreglo src y almacenar el resultado en el arreglo preasignado dest, que debe tener un tamaño correspondiente a (size(src,2),size(src,1)). No se admite la transposición en el lugar y ocurrirán resultados inesperados si src y dest tienen regiones de memoria superpuestas.

Ejemplos

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> transpose!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3+2im  8+7im
 9+2im  4+6im

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

Transponer

Tipo de envoltura perezosa para una vista transpuesta del objeto de álgebra lineal subyacente, generalmente un AbstractVector/AbstractMatrix. Por lo general, el constructor Transpose no debe ser llamado directamente, usa transpose en su lugar. Para materializar la vista, usa copy.

Este tipo está destinado para uso en álgebra lineal; para manipulación de datos general, consulta permutedims.

Ejemplos

julia> A = [2 3; 0 0]
2×2 Matrix{Int64}:
 2  3
 0  0

julia> Transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 2  0
 3  0

TransposeFactorization

Tipo de envoltura perezosa para la transposición del objeto Factorization subyacente. Por lo general, el constructor TransposeFactorization no debe ser llamado directamente, use transpose(:: Factorization) en su lugar.

A'
adjoint(A)

Adjunto perezoso (transposición conjugada). Tenga en cuenta que adjoint se aplica recursivamente a los elementos.

Para los tipos numéricos, adjoint devuelve el conjugado complejo y, por lo tanto, es equivalente a la función identidad para números reales.

Esta operación está destinada al uso en álgebra lineal; para manipulación de datos general, consulte permutedims.

Ejemplos

julia> A = [3+2im 9+2im; 0  0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> B = A' # equivalentemente adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

julia> B isa Adjoint
true

julia> adjoint(B) === A # el adjunto de un adjunto desenvuelve el padre
true

julia> Adjoint(B) # sin embargo, el constructor siempre envuelve su argumento
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # modificar B modificará A automáticamente

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 4-5im  0+0im

Para matrices reales, la operación adjoint es equivalente a una transpose.

julia> A = reshape([x for x in 1:4], 2, 2)
2×2 Matrix{Int64}:
 1  3
 2  4

julia> A'
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  2
 3  4

julia> adjoint(A) == transpose(A)
true

El adjunto de un AbstractVector es un vector fila:

julia> x = [3, 4im]
2-element Vector{Complex{Int64}}:
 3 + 0im
 0 + 4im

julia> x'
1×2 adjoint(::Vector{Complex{Int64}}) with eltype Complex{Int64}:
 3+0im  0-4im

julia> x'x # calcular el producto punto, equivalentemente x' * x
25 + 0im

Para una matriz de matrices, los bloques individuales se operan recursivamente:

julia> A = reshape([x + im*x for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 Matrix{Matrix{Complex{Int64}}}:
 [1+1im 3+3im; 2+2im 4+4im]  [3+3im 9+9im; 6+6im 12+12im]
 [2+2im 6+6im; 4+4im 8+8im]  [4+4im 12+12im; 8+8im 16+16im]

julia> C'
2×2 adjoint(::Matrix{Matrix{Complex{Int64}}}) with eltype Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
 [1-1im 2-2im; 3-3im 4-4im]    [2-2im 4-4im; 6-6im 8-8im]
 [3-3im 6-6im; 9-9im 12-12im]  [4-4im 8-8im; 12-12im 16-16im]

adjunto(F::Factorización)

Adjunto perezoso de la factorización F. Por defecto, devuelve un envoltorio AdjointFactorization.

adjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

Transpone la matriz A y almacena el adjunto de los elementos en la matriz X. size(X) debe ser igual a size(transpose(A)). No se asigna memoria adicional más que el redimensionamiento de rowval y nzval de X, si es necesario.

Consulta halfperm!

adjoint!(dest,src)

Transponer conjugado el arreglo src y almacenar el resultado en el arreglo preasignado dest, que debe tener un tamaño correspondiente a (size(src,2),size(src,1)). No se admite la transposición en el lugar y ocurrirán resultados inesperados si src y dest tienen regiones de memoria superpuestas.

Ejemplos

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> adjoint!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3-2im  8-7im
 9-2im  4-6im

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

Adjunto

Tipo de envoltura perezosa para una vista adjunta del objeto de álgebra lineal subyacente, generalmente un AbstractVector/AbstractMatrix. Por lo general, el constructor Adjoint no debe ser llamado directamente, usa adjoint en su lugar. Para materializar la vista, usa copy.

Este tipo está destinado para uso en álgebra lineal; para manipulación de datos general, consulta permutedims.

Ejemplos

julia> A = [3+2im 9+2im; 0 0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> Adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) con el tipo eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

AdjointFactorization

Tipo de envoltura perezosa para el adjunto del objeto Factorization subyacente. Por lo general, el constructor AdjointFactorization no debe ser llamado directamente, usa adjoint(:: Factorization) en su lugar.

copy(A::Transpose)
copy(A::Adjoint)

Evalúa de manera ansiosa la transposición/adjunto de matriz perezosa. Ten en cuenta que la transposición se aplica recursivamente a los elementos.

Esta operación está destinada para el uso en álgebra lineal; para la manipulación de datos general, consulta permutedims, que no es recursiva.

Ejemplos

julia> A = [1 2im; -3im 4]
2×2 Matrix{Complex{Int64}}:
 1+0im  0+2im
 0-3im  4+0im

julia> T = transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 1+0im  0-3im
 0+2im  4+0im

julia> copy(T)
2×2 Matrix{Complex{Int64}}:
 1+0im  0-3im
 0+2im  4+0im

stride1(A) -> Int

Devuelve la distancia entre elementos sucesivos de la matriz en la dimensión 1 en unidades de tamaño de elemento.

Ejemplos

julia> A = [1,2,3,4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> LinearAlgebra.stride1(A)
1

julia> B = view(A, 2:2:4)
2-element view(::Vector{Int64}, 2:2:4) with eltype Int64:
 2
 4

julia> LinearAlgebra.stride1(B)
2

LinearAlgebra.checksquare(A)

Verifica que una matriz sea cuadrada y luego devuelve su dimensión común. Para múltiples argumentos, devuelve un vector.

Ejemplos

julia> A = fill(1, (4,4)); B = fill(1, (5,5));

julia> LinearAlgebra.checksquare(A, B)
2-element Vector{Int64}:
 4
 5

LinearAlgebra.peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)

peakflops calcula la tasa máxima de flops de la computadora utilizando precisión doble gemm!. Por defecto, si no se especifican argumentos, multiplica dos matrices Float64 de tamaño n x n, donde n = 4096. Si el BLAS subyacente utiliza múltiples hilos, se logran tasas de flops más altas. El número de hilos de BLAS se puede establecer con BLAS.set_num_threads(n).

Si se proporciona el argumento de palabra clave eltype, peakflops construirá matrices con elementos del tipo eltype para calcular la tasa máxima de flops.

Por defecto, peakflops utilizará el mejor tiempo de 3 pruebas. Si se proporciona el argumento de palabra clave ntrials, peakflops utilizará esa cantidad de pruebas para elegir el mejor tiempo.

Si el argumento de palabra clave parallel se establece en true, peakflops se ejecuta en paralelo en todos los procesadores de trabajo. Se devuelve la tasa de flops de toda la computadora paralela. Al ejecutarse en paralelo, solo se utiliza 1 hilo de BLAS. El argumento n sigue refiriéndose al tamaño del problema que se resuelve en cada procesador.

hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

Devuelve la parte hermitiana de la matriz cuadrada A, definida como (A + A') / 2, como una matriz Hermitian. Para matrices reales A, esto también se conoce como la parte simétrica de A; a veces también se le llama la "parte real del operador". El argumento opcional uplo controla el argumento correspondiente de la vista Hermitian. Para matrices reales, esta última es equivalente a una vista Symmetric.

Véase también hermitianpart! para la operación correspondiente en su lugar.

hermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

Sobrescribe la matriz cuadrada A en su lugar con su parte hermitiana (A + A') / 2, y devuelve Hermitian(A, uplo). Para matrices reales A, esto también se conoce como la parte simétrica de A.

Consulta también hermitianpart para la operación correspondiente fuera de lugar.

copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

Copia eficientemente los elementos de la matriz A a B con adjunción de la siguiente manera:

B[ir_dest, jr_dest] = adjoint(A)[jr_src, ir_src]

Los elementos B[ir_dest, jr_dest] son sobrescritos. Además, los parámetros de rango de índice deben satisfacer length(ir_dest) == length(jr_src) y length(jr_dest) == length(ir_src).

copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

Copia eficientemente los elementos de la matriz A a B con transposición de la siguiente manera:

B[ir_dest, jr_dest] = transpose(A)[jr_src, ir_src]

Los elementos B[ir_dest, jr_dest] son sobrescritos. Además, los parámetros de rango de índice deben satisfacer length(ir_dest) == length(jr_src) y length(jr_dest) == length(ir_src).

copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
                tM::AbstractChar,
                M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B

Copia eficientemente los elementos de la matriz M a B condicionado al parámetro de carácter tM de la siguiente manera:

Los elementos B[ir_dest, jr_dest] son sobrescritos. Además, los parámetros de rango de índice deben satisfacer length(ir_dest) == length(jr_src) y length(jr_dest) == length(ir_src).

Consulta también copyto! y copy_adjoint!.

mul!(Y, A, B) -> Y

Calcula el producto de matriz-matriz o matriz-vector $A B$ y almacena el resultado en Y, sobrescribiendo el valor existente de Y. Ten en cuenta que Y no debe estar aliasado con A o B.

Ejemplos

julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; Y = similar(B);

julia> mul!(Y, A, B) === Y
true

julia> Y
2×2 Matrix{Float64}:
 3.0  3.0
 7.0  7.0

julia> Y == A * B
true

Implementación

Para tipos de matriz y vector personalizados, se recomienda implementar mul! de 5 argumentos en lugar de implementar directamente mul! de 3 argumentos si es posible.

mul!(C, A, B, α, β) -> C

Multiplicación y suma de matrices o de matriz-vectores en su lugar combinada $A B α + C β$. El resultado se almacena en C sobrescribiéndolo. Tenga en cuenta que C no debe estar aliasado con A o B.

Ejemplos

julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; C = [1.0 2.0; 3.0 4.0];

julia> α, β = 100.0, 10.0;

julia> mul!(C, A, B, α, β) === C
true

julia> C
2×2 Matrix{Float64}:
 310.0  320.0
 730.0  740.0

julia> C_original = [1.0 2.0; 3.0 4.0]; # Una copia del valor original de C

julia> C == A * B * α + C_original * β
true

lmul!(a::Number, B::AbstractArray)

Escala un array B por un escalar a sobrescribiendo B en su lugar. Usa rmul! para multiplicar el escalar desde la derecha. La operación de escalado respeta la semántica de la multiplicación * entre a y un elemento de B. En particular, esto también se aplica a la multiplicación que involucra números no finitos como NaN y ±Inf.

Ejemplos

julia> B = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> lmul!(2, B)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> lmul!(0.0, [Inf])
1-element Vector{Float64}:
 NaN

lmul!(A, B)

Calcula el producto de matrices $AB$, sobrescribiendo B, y devuelve el resultado. Aquí, A debe ser de un tipo de matriz especial, como, por ejemplo, Diagonal, UpperTriangular o LowerTriangular, o de algún tipo ortogonal, ver QR.

Ejemplos

julia> B = [0 1; 1 0];

julia> A = UpperTriangular([1 2; 0 3]);

julia> lmul!(A, B);

julia> B
2×2 Matrix{Int64}:
 2  1
 3  0

julia> B = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> lmul!(F.Q, B)
2×2 Matrix{Float64}:
 3.0  4.0
 1.0  2.0

rmul!(A::AbstractArray, b::Number)

Escala un arreglo A por un escalar b sobrescribiendo A en su lugar. Usa lmul! para multiplicar el escalar desde la izquierda. La operación de escalado respeta la semántica de la multiplicación * entre un elemento de A y b. En particular, esto también se aplica a la multiplicación que involucra números no finitos como NaN y ±Inf.

Ejemplos

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rmul!(A, 2)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> rmul!([NaN], 0.0)
1-element Vector{Float64}:
 NaN

rmul!(A, B)

Calcula el producto de matrices $AB$, sobrescribiendo A, y devuelve el resultado. Aquí, B debe ser de un tipo de matriz especial, como, por ejemplo, Diagonal, UpperTriangular o LowerTriangular, o de algún tipo ortogonal, ver QR.

Ejemplos

julia> A = [0 1; 1 0];

julia> B = UpperTriangular([1 2; 0 3]);

julia> rmul!(A, B);

julia> A
2×2 Matrix{Int64}:
 0  3
 1  2

julia> A = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> rmul!(A, F.Q)
2×2 Matrix{Float64}:
 2.0  1.0
 4.0  3.0

ldiv!(Y, A, B) -> Y

Calcula A \ B en su lugar y almacena el resultado en Y, devolviendo el resultado.

El argumento A no debe ser una matriz. En su lugar, debe ser un objeto de factorización (por ejemplo, producido por factorize o cholesky). La razón de esto es que la factorización en sí misma es costosa y típicamente asigna memoria (aunque también se puede hacer en su lugar a través de, por ejemplo, lu!), y las situaciones críticas de rendimiento que requieren ldiv! generalmente también requieren un control detallado sobre la factorización de A.

Ejemplos

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = zero(X);

julia> ldiv!(Y, qr(A), X);

julia> Y ≈ A\X
true

ldiv!(A, B)

Calcula A \ B en su lugar y sobrescribiendo B para almacenar el resultado.

El argumento A no debe ser una matriz. En cambio, en lugar de matrices, debe ser un objeto de factorización (por ejemplo, producido por factorize o cholesky). La razón de esto es que la factorización en sí misma es costosa y típicamente asigna memoria (aunque también se puede hacer en su lugar a través de, por ejemplo, lu!), y las situaciones críticas de rendimiento que requieren ldiv! generalmente también requieren un control detallado sobre la factorización de A.

Ejemplos

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = copy(X);

julia> ldiv!(qr(A), X);

julia> X ≈ A\Y
true

ldiv!(a::Number, B::AbstractArray)

Divide cada entrada en un arreglo B por un escalar a sobrescribiendo B en su lugar. Usa rdiv! para dividir el escalar desde la derecha.

Ejemplos

julia> B = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> ldiv!(2.0, B)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

ldiv!(A::Tridiagonal, B::AbstractVecOrMat) -> B

Calcula A \ B en su lugar mediante eliminación gaussiana con pivoteo parcial y almacena el resultado en B, devolviendo el resultado. En el proceso, las diagonales de A se sobrescriben también.

rdiv!(A, B)

Calcula A / B en su lugar y sobrescribiendo A para almacenar el resultado.

El argumento B no debe ser una matriz. En su lugar, debe ser un objeto de factorización (por ejemplo, producido por factorize o cholesky). La razón de esto es que la factorización en sí misma es costosa y típicamente asigna memoria (aunque también se puede hacer en su lugar a través de, por ejemplo, lu!), y las situaciones críticas de rendimiento que requieren rdiv! generalmente también requieren un control detallado sobre la factorización de B.

rdiv!(A::AbstractArray, b::Number)

Divide cada entrada en un arreglo A por un escalar b sobrescribiendo A en su lugar. Usa ldiv! para dividir el escalar desde la izquierda.

Ejemplos

julia> A = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> rdiv!(A, 2.0)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

Interfaz a subrutinas BLAS.

set_num_threads(n::Integer)
set_num_threads(::Nothing)

Establece el número de hilos que la biblioteca BLAS debe usar igual a n::Integer.

También acepta nothing, en cuyo caso julia intenta adivinar el número predeterminado de hilos. Pasar nothing no se recomienda y existe principalmente por razones históricas.

get_num_threads()

Obtiene el número de hilos que la biblioteca BLAS está utilizando.

rot!(n, X, incx, Y, incy, c, s)

Sobrescribe X con c*X + s*Y y Y con -conj(s)*X + c*Y para los primeros n elementos del arreglo X con paso incx y los primeros n elementos del arreglo Y con paso incy. Devuelve X y Y.

scal!(n, a, X, incx)
scal!(a, X)

Sobrescribe X con a*X para los primeros n elementos del arreglo X con paso incx. Devuelve X.

Si n y incx no se proporcionan, se utilizan length(X) y stride(X,1).

scal(n, a, X, incx)
scal(a, X)

Devuelve X escalado por a para los primeros n elementos del arreglo X con un paso de incx.

Si n e incx no se proporcionan, se utilizan length(X) y stride(X,1).

blascopy!(n, X, incx, Y, incy)

Copia n elementos del arreglo X con paso incx al arreglo Y con paso incy. Devuelve Y.

dot(n, X, incx, Y, incy)

Producto punto de dos vectores que consisten en n elementos del arreglo X con paso incx y n elementos del arreglo Y con paso incy.

Ejemplos

julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0

dotu(n, X, incx, Y, incy)

Función Dot para dos vectores complejos que constan de n elementos del arreglo X con paso incx y n elementos del arreglo Y con paso incy.

Ejemplos

julia> BLAS.dotu(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
-10.0 + 10.0im

dotc(n, X, incx, U, incy)

Función Dot para dos vectores complejos, que consiste en n elementos del arreglo X con paso incx y n elementos del arreglo U con paso incy, conjugando el primer vector.

Ejemplos

julia> BLAS.dotc(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
10.0 - 10.0im

nrm2(n, X, incx)

2-norma de un vector que consiste en n elementos del arreglo X con paso incx.

Ejemplos

julia> BLAS.nrm2(4, fill(1.0, 8), 2)
2.0

julia> BLAS.nrm2(1, fill(1.0, 8), 2)
1.0

asum(n, X, incx)

Suma de las magnitudes de los primeros n elementos del arreglo X con paso incx.

Para un arreglo real, la magnitud es el valor absoluto. Para un arreglo complejo, la magnitud es la suma del valor absoluto de la parte real y el valor absoluto de la parte imaginaria.

Ejemplos

julia> BLAS.asum(5, fill(1.0im, 10), 2)
5.0

julia> BLAS.asum(2, fill(1.0im, 10), 5)
2.0

iamax(n, dx, incx)
iamax(dx)

Encuentra el índice del elemento de dx con el valor absoluto máximo. n es la longitud de dx, y incx es el paso. Si n y incx no se proporcionan, se asumen valores predeterminados de n=length(dx) y incx=stride1(dx).

gemv!(tA, alpha, A, x, beta, y)

Actualiza el vector y como alpha*A*x + beta*y o alpha*A'x + beta*y de acuerdo con tA. alpha y beta son escalares. Devuelve el y actualizado.

gemv(tA, alpha, A, x)

Devuelve alpha*A*x o alpha*A'x según tA. alpha es un escalar.

gemv(tA, A, x)

Devuelve A*x o A'x según tA.

gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)

Actualiza el vector y como alpha*A*x + beta*y o alpha*A'*x + beta*y de acuerdo con trans. La matriz A es una matriz de banda general de dimensión m por size(A,2) con kl sub-diagonales y ku super-diagonales. alpha y beta son escalares. Devuelve el y actualizado.

gbmv(trans, m, kl, ku, alpha, A, x)

Devuelve alpha*A*x o alpha*A'*x según trans. La matriz A es una matriz de banda general de dimensión m por size(A,2) con kl sub-diagonales y ku super-diagonales, y alpha es un escalar.

hemv!(ul, alpha, A, x, beta, y)

Actualiza el vector y como alpha*A*x + beta*y. Se asume que A es Hermitiana. Solo se utiliza el triángulo ul de A. alpha y beta son escalares. Devuelve el y actualizado.

hemv(ul, alpha, A, x)

Devuelve alpha*A*x. Se asume que A es Hermitiana. Solo se utiliza el triángulo ul de A. alpha es un escalar.

hemv(ul, A, x)

Devuelve A*x. Se asume que A es Hermitiana. Solo se utiliza el triángulo ul de A.

hpmv!(uplo, α, AP, x, β, y)

Actualiza el vector y como α*A*x + β*y, donde A es una matriz Hermitiana proporcionada en formato empaquetado AP.

Con uplo = 'U', el arreglo AP debe contener la parte triangular superior de la matriz Hermitiana empaquetada secuencialmente, columna por columna, de modo que AP[1] contenga A[1, 1], AP[2] y AP[3] contengan A[1, 2] y A[2, 2] respectivamente, y así sucesivamente.

Con uplo = 'L', el arreglo AP debe contener la parte triangular inferior de la matriz Hermitiana empaquetada secuencialmente, columna por columna, de modo que AP[1] contenga A[1, 1], AP[2] y AP[3] contengan A[2, 1] y A[3, 1] respectivamente, y así sucesivamente.

Las entradas escalares α y β deben ser números complejos o reales.

Las entradas de arreglo x, y y AP deben ser todas del tipo ComplexF32 o ComplexF64.

Devuelve el y actualizado.

symv!(ul, alpha, A, x, beta, y)

Actualiza el vector y como alpha*A*x + beta*y. Se asume que A es simétrica. Solo se utiliza el triángulo ul de A. alpha y beta son escalares. Devuelve el y actualizado.

symv(ul, alpha, A, x)

Devuelve alpha*A*x. Se asume que A es simétrica. Solo se utiliza el triángulo ul de A. alpha es un escalar.

symv(ul, A, x)

Devuelve A*x. Se asume que A es simétrica. Solo se utiliza el triángulo ul de A.

sbmv!(uplo, k, alpha, A, x, beta, y)

Actualiza el vector y como alpha*A*x + beta*y donde A es una matriz simétrica en banda de orden size(A,2) con k superdiagonales almacenadas en el argumento A. El diseño de almacenamiento para A se describe en el módulo de referencia BLAS, BLAS de nivel 2 en https://www.netlib.org/lapack/explore-html/. Solo se utiliza el triángulo uplo de A.

Devuelve el y actualizado.

sbmv(uplo, k, alpha, A, x)

Devuelve alpha*A*x donde A es una matriz de banda simétrica de orden size(A,2) con k super-diagonales almacenadas en el argumento A. Solo se utiliza el triángulo uplo de A.

sbmv(uplo, k, A, x)

Devuelve A*x donde A es una matriz de banda simétrica de orden size(A,2) con k superdiagonales almacenadas en el argumento A. Solo se utiliza el triángulo uplo de A.

spmv!(uplo, α, AP, x, β, y)

Actualiza el vector y como α*A*x + β*y, donde A es una matriz simétrica proporcionada en formato empaquetado AP.

Con uplo = 'U', el arreglo AP debe contener la parte triangular superior de la matriz simétrica empaquetada secuencialmente, columna por columna, de modo que AP[1] contenga A[1, 1], AP[2] y AP[3] contengan A[1, 2] y A[2, 2] respectivamente, y así sucesivamente.

Con uplo = 'L', el arreglo AP debe contener la parte triangular inferior de la matriz simétrica empaquetada secuencialmente, columna por columna, de modo que AP[1] contenga A[1, 1], AP[2] y AP[3] contengan A[2, 1] y A[3, 1] respectivamente, y así sucesivamente.

Las entradas escalares α y β deben ser reales.

Las entradas de arreglo x, y y AP deben ser todas de tipo Float32 o Float64.

Devuelve el y actualizado.

trmv!(ul, tA, dA, A, b)

Devuelve op(A)*b, donde op está determinado por tA. Solo se utiliza el triángulo ul de A. dA determina si los valores diagonales se leen o se asumen todos como uno. La multiplicación ocurre en su lugar en b.

trmv(ul, tA, dA, A, b)

Devuelve op(A)*b, donde op se determina por tA. Solo se utiliza el triángulo ul de A. dA determina si los valores diagonales se leen o se asumen todos como uno.

trsv!(ul, tA, dA, A, b)

Sobrescribe b con la solución a A*x = b o una de las otras dos variantes determinadas por tA y ul. dA determina si los valores diagonales se leen o se asumen como todos unos. Devuelve el b actualizado.

trsv(ul, tA, dA, A, b)

Devuelve la solución a A*x = b o una de las otras dos variantes determinadas por tA y ul. dA determina si los valores diagonales se leen o se asumen todos como uno.

ger!(alpha, x, y, A)

Actualización de rango-1 de la matriz A con los vectores x y y como alpha*x*y' + A.

her!(uplo, alpha, x, A)

Métodos solo para arreglos complejos. Actualización de rango 1 de la matriz Hermitiana A con el vector x como alpha*x*x' + A. uplo controla qué triángulo de A se actualiza. Devuelve A.

syr!(uplo, alpha, x, A)

Actualización de rango-1 de la matriz simétrica A con el vector x como alpha*x*transpose(x) + A. uplo controla qué triángulo de A se actualiza. Devuelve A.

spr!(uplo, α, x, AP)

Actualiza la matriz A como A+α*x*x', donde A es una matriz simétrica proporcionada en formato empaquetado AP y x es un vector.

Con uplo = 'U', el arreglo AP debe contener la parte triangular superior de la matriz simétrica empaquetada secuencialmente, columna por columna, de modo que AP[1] contenga A[1, 1], AP[2] y AP[3] contengan A[1, 2] y A[2, 2] respectivamente, y así sucesivamente.

Con uplo = 'L', el arreglo AP debe contener la parte triangular inferior de la matriz simétrica empaquetada secuencialmente, columna por columna, de modo que AP[1] contenga A[1, 1], AP[2] y AP[3] contengan A[2, 1] y A[3, 1] respectivamente, y así sucesivamente.

La entrada escalar α debe ser real.

Las entradas de arreglo x y AP deben ser todas de tipo Float32 o Float64. Devuelve el AP actualizado.

gemmt!(uplo, tA, tB, alpha, A, B, beta, C)

Actualiza la parte triangular inferior o superior especificada por uplo de C como alpha*A*B + beta*C o las otras variantes según tA y tB. Devuelve el C actualizado.

gemmt(uplo, tA, tB, alpha, A, B)

Devuelve la parte triangular inferior o superior especificada por uplo de A*B o las otras tres variantes según tA y tB.

gemmt(uplo, tA, tB, A, B)

Devuelve la parte triangular inferior o superior especificada por uplo de A*B o las otras tres variantes según tA y tB.

gemm!(tA, tB, alpha, A, B, beta, C)

Actualiza C como alpha*A*B + beta*C o las otras tres variantes según tA y tB. Devuelve el C actualizado.

gemm(tA, tB, alpha, A, B)

Devuelve alpha*A*B o las otras tres variantes según tA y tB.

gemm(tA, tB, A, B)

Devuelve A*B o las otras tres variantes según tA y tB.