using LinearAlgebra

function QRMGS(A)
    sizeA=size(A)
    Q = zeros(sizeA) #(m,n)
    R = zeros(sizeA[2],sizeA[2]) #(n,n)
    for i = 1:sizeA[2]
        R[i,i] = norm(A[:,i])
        Q[:,i] = A[:,i]/R[i,i]
        for j = i + 1: sizeA[2]
            R[i,j] = Q[:,i]'A[:,j]
            A[:,j] = A[:,j] - Q[:,i]R[i,j]
        end
    end
    return Q, R
end

QRMGS (generic function with 1 method)

begin
function Housev(x)
    n = length(x)
    v = ones(size(x))
    v[2:n] = x[2:n]
    σ = norm(x[2:n])^2
    if σ == 0
        β = 0
    else
        μ = √(x[1]^2+σ)
        if x[1] ≤ 0
            v[1] = x[1] - μ
        else
            v[1] = -σ/(x[1]+μ)
        end
        β = 2*v[1]^2/(σ+v[1]^2)
        v = v/(v[1])
    end
    return v, β
end
end

Housev (generic function with 1 method)

begin
	function HessenbergForm(A)
    n = size(A)[1]
    H = copy(A)
    U = Matrix(1.0*I, n, n)
    for k = 1:n-2
        v, β = Housev(H[k+1:n, k])
        H[k+1:n, k:n] = (I - β*v*v')*H[k+1:n, k:n]
        H[1:n, k+1:n] = H[1:n, k+1:n]*(I - β*v*v')

        #U es necesaria para la verificar que la función devuelve los resultados correctos
        U[1:n, k+1:n] = U[1:n, k+1:n]*(I - β*v*v')
    end
    return H, U
end
end

HessenbergForm (generic function with 1 method)

n₁,m₁= 4, 4
M = 335

println("Matriz inicial A: \n")
A = [1.0 2.0 3.0 4.0;
     4.0 5.0 6.0 7.0;
     2.0 1.0 5.0 0.0;
     4.0 2.0 1.0 0.0]
display(A)

println("\n Matriz de Hessenberg de A: \n")
H,U=HessenbergForm(A); display(H)

Q₁, R₁ = QRMGS(H)

for k in 1:M                   # iteraciones de prueba
    Q, R = QRMGS(H)             # factoriza Aₖ = Qₖ Rₖ
    H = R * Q                   # calcula Aₖ₊₁ = Rₖ Qₖ
    if k % 100 == 0 || (k==334) || (k==335)|| (k==1)
      println("---------\nPaso de iteración QR numero $k: \n")
      display(round.(H,digits = 5))
      println("")
    end
end

Matriz inicial A:

4×4 Matrix{Float64}:
 1.0  2.0  3.0  4.0
 4.0  5.0  6.0  7.0
 2.0  1.0  5.0  0.0
 4.0  2.0  1.0  0.0

 Matriz de Hessenberg de A:

4×4 Matrix{Float64}:
 1.0          5.0          -1.53952   1.27667
 6.0          8.55556      -0.108475  3.69859
 8.88178e-16  5.91817      -2.16888   1.14276
 1.33227e-15  2.00005e-16   0.142756  3.61332

---------
Paso de iteración QR numero 1:

4×4 Matrix{Float64}:
 1.0       3.07066  -4.0329    3.21041
 6.79492  -0.57958   0.7612   -0.60596
 0.0       0.19692   0.09178  -0.07306
 0.0      -0.0       1.75084   2.19939

---------
Paso de iteración QR numero 100:

4×4 Matrix{Float64}:
 4.7514    3.76913  1.7852    1.87887
 0.10759  -4.55115  3.45327   2.85483
 0.0       0.0      1.84821  -2.0626
 0.0      -0.0      0.0       0.66313

---------
Paso de iteración QR numero 200:

4×4 Matrix{Float64}:
 4.79419   3.66306  1.82427   1.91115
 0.00152  -4.59394  3.43279   2.83332
 0.0       0.0      1.84821  -2.0626
 0.0      -0.0      0.0       0.66313

function shifted_qr!(A, M; report_iters = Int[])
    H,U =HessenbergForm(A)
    n = size(H,1)
    I_n = Matrix{Float64}(I, n, n)
    for k in 1:M
        # 1) elegimos el shift μ_k como la entrada (n,n)
        μ = H[2,2]
        # 2) factorizamos H - μ I = Q R
        Q, R = QRMGS(H - μ*I_n)

        H = R*Q + μ*I_n

        if k in report_iters
            println("---------\nPaso $k, μ = $μ)):")
            display(round.(H, digits = 5))

        end
    end
    return H
end

# --- Ejemplo de uso ---
M = 335
report = [1,2,3, 22, 23, 100, 200, 300, 335]

A = [1.0 2.0 3.0 4.0;
     4.0 5.0 6.0 7.0;
     2.0 1.0 5.0 0.0;
     4.0 2.0 1.0 0.0]

println("Matriz inicial A:")
display(A)

# Reducción a Hessenberg
H,U = HessenbergForm(A)
println("\nForma Hessenberg H₁:")
display(round.(H, digits = 5))


# Shifted QR
println("\nIteración Shifted QR:")
H_final = shifted_qr!(H, M; report_iters = report)

println("\n Los valores propios de A son: \n")
eigvals(A)

Matriz inicial A:

4×4 Matrix{Float64}:
 1.0  2.0  3.0  4.0
 4.0  5.0  6.0  7.0
 2.0  1.0  5.0  0.0
 4.0  2.0  1.0  0.0

Forma Hessenberg H₁:

4×4 Matrix{Float64}:
 1.0  5.0      -1.53952  1.27667
 6.0  8.55556  -0.10848  3.69859
 0.0  5.91817  -2.16888  1.14276
 0.0  0.0       0.14276  3.61332

Iteración Shifted QR:
---------
Paso 1, μ = 8.555555555555555)):

4×4 Matrix{Float64}:
 -1.43501  2.37205  2.11204  -1.22695
  4.15746  2.15697  9.36579  -2.40085
 -0.0      3.60106  6.75457  -2.62507
 -0.0      0.0      0.1767    3.52347

---------
Paso 2, μ = 2.1569669868326606)):

4×4 Matrix{Float64}:
 -2.60847   6.50935   0.23091  -1.02363
  3.04463  10.0958   -1.14307  -3.42448
 -0.0       4.35198  -0.04766  -0.93481
 -0.0       0.0       0.05103   3.56033

---------
Paso 3, μ = 10.095800525879717)):

4×4 Matrix{Float64}:
 -4.08373  -1.48766  -2.77124  -0.25783
  1.0741    2.19782   7.45287   2.22042
 -0.0       2.21011   9.25572   3.18638
 -0.0       0.0       0.141     3.63019

function implicit_double_shift_qr!(H::Matrix{Float64}, M::Int; report_iters=Int[])
    n = size(H,1)
    I_n = Matrix{Float64}(I, n, n)

    for k in 1:M
        # 1) compute shifts s = tr(G), t = det(G)
        G = @view H[n-1:n, n-1:n]
        s = tr(G)
        t = det(G)

        # 2) form first column of M = H^2 - s*H + t*I
        w = H[:,1]
        u = H * w
        x = u[1] - s*w[1] + t
        y = u[2] - s*w[2]
        z = n >= 3 ? u[3] : 0.0

        # 3) apply P0 to create the bulge
        v0 = [x, y, z]; v0, β0 = Housev(v0)
        H[1:3, 1:n] .-= β0 * v0 * (v0' * H[1:3, 1:n])
        H[1:n, 1:3] .-= β0 * (H[1:n, 1:3] * v0) * v0'

        # 4) chase the bulge down
        for j in 1:n-3
            xj = H[j+1, j]
            yj = H[j+2, j]
            zj = j+3 <= n ? H[j+3, j] : 0.0
            vj = [xj, yj, zj]; vj, βj = Housev(vj)
            H[j+1:j+3, j:n] .-= βj * vj * (vj' * H[j+1:j+3, j:n])
            H[1:n, j+1:j+3] .-= βj * (H[1:n, j+1:j+3] * vj) * vj'
        end

        # 5) report if desired
        if k in report_iters
            println("---------\nPaso $k (s=$s, t=$t):")
            display(round.(H; digits = 5))
        end
    end

    return H
end

# ----------------- Ejemplo -----------------
A = [1.0 2.0 3.0 4.0;
     4.0 5.0 6.0 7.0;
     2.0 1.0 5.0 0.0;
     4.0 2.0 1.0 0.0]

println("Matriz inicial A:")
display(A)

H,U = HessenbergForm(A)
println("\nHessenberg H₁:")
display(H)

# Ejecutar 10 pasos, mostrando H en iteraciones
H_final = implicit_double_shift_qr!(H, 335; report_iters=[1,2,3,4,5,100,200,334,335])

println("\nH final:")
display(H_final)

Matriz inicial A:

4×4 Matrix{Float64}:
 1.0  2.0  3.0  4.0
 4.0  5.0  6.0  7.0
 2.0  1.0  5.0  0.0
 4.0  2.0  1.0  0.0

Hessenberg H₁:

4×4 Matrix{Float64}:
 1.0          5.0          -1.53952   1.27667
 6.0          8.55556      -0.108475  3.69859
 8.88178e-16  5.91817      -2.16888   1.14276
 1.33227e-15  2.00005e-16   0.142756  3.61332

---------
Paso 1 (s=1.4444444444444469, t=-7.99999999999999):

4×4 Matrix{Float64}:
  9.37819   8.44184  -1.11223  3.68217
  2.33272  -0.90982  -2.82217  1.61347
  0.0      -1.50789  -0.99432  0.48362
 -0.0       0.14557   0.44977  3.52595

---------
Paso 2 (s=2.5316332637790686, t=-3.7234293463807635):

4×4 Matrix{Float64}:
 10.9442    4.92043  -4.3942   3.79601
  0.48246  -3.7215   -0.86635  1.23702
  0.0       0.50435   0.26702  0.0048
  0.0       0.44652   0.29106  3.51027

---------
Paso 3 (s=3.7772837039765204, t=0.9358999651429256):

4×4 Matrix{Float64}:
 11.0348   5.32426  -3.81398  3.5777
  0.1814  -3.62441  -1.22513  1.55777
  0.0      0.02075   0.19317  0.16928
 -0.0      0.79968   0.44811  3.39647

using LinearAlgebra

function deflate!(H, tol)
    n = size(H,1)
    for i in 2:n
        if abs(H[i,i-1]) <= tol*(abs(H[i-1,i-1]) + abs(H[i,i]))
            H[i,i-1] = 0.0
        end
    end
end

function francis_step!(H)
    n = size(H,1)
    # extraer 2×2 final
    G = H[n-1:n, n-1:n]
    s = tr(G); t = det(G)
    # primer bulge
    w = H[:,1]; u = H * w
    m1 = u[1] - s*w[1] + t
    m2 = u[2] - s*w[2]
    m3 = n >= 3 ? u[3] : 0.0
    v, β = Housev([m1, m2, m3])
    H[1:3,1:n] .-= β * v * (v' * H[1:3,1:n])
    H[1:n,1:3] .-= β * (H[1:n,1:3] * v) * v'
    # bulge‑chasing
    for j in 1:n-3
        xj = H[j+1,j]; yj = H[j+2,j]; zj = j+3<=n ? H[j+3,j] : 0.0
        vj, βj = Housev([xj, yj, zj])
        H[j+1:j+3, j:n] .-= βj * vj * (vj' * H[j+1:j+3, j:n])
        H[1:n, j+1:j+3] .-= βj * (H[1:n, j+1:j+3] * vj) * vj'
    end
end

H,U = HessenbergForm([1.0 2.0 3.0 4.0;
                   4.0 5.0 6.0 7.0;
                   2.0 1.0 5.0 0.0;
                   4.0 2.0 1.0 0.0])
println("Antes de un paso d e Francis:")
display(H)

francis_step!(H)
println("\nDespués de un paso de Francis:")
display(H)

Antes de un paso d e Francis:

4×4 Matrix{Float64}:
 1.0          5.0          -1.53952   1.27667
 6.0          8.55556      -0.108475  3.69859
 8.88178e-16  5.91817      -2.16888   1.14276
 1.33227e-15  2.00005e-16   0.142756  3.61332

Después de un paso de Francis:

4×4 Matrix{Float64}:
  9.37819       8.44184   -1.11223   3.68217
  2.33272      -0.909822  -2.82217   1.61347
  2.22045e-16  -1.50789   -0.994317  0.483619
 -1.38778e-17   0.145575   0.44977   3.52595

using LinearAlgebra

# 4) Algoritmo QR completo
function qr_algorithm(A; tol=1e-12, maxiter=1000)
    # 4.1 reducción a Hessenberg
    H, U = HessenbergForm(A)
    Q = U               # Q acumula P₁…Pₙ₋₂
    n = size(H,1)
    # 4.2 bucle principal
    iter = 0
    while iter < maxiter
        iter += 1
        # deflación
        deflate!(H, tol)
        # encontrar bloque irreducible
        # busc: última fila i tal que H[i+1,i]==0 → p=i, luego q siguiente
        p = findlast(i->i<n && H[i+1,i]==0.0, 1:n)  ; p = p === nothing ? 0 : p
        q = findfirst(i->i<n && H[i+1,i]==0.0, p+1:n); q = q === nothing ? n : q
        m = q - p
        if m <= 2
            # bloque 1×1 o 2×2 listo, avanzar p
            p += m
            if p >= n-1
                break
            else
                continue
            end
        end
        # Francis step sobre H[p+1:p+m, p+1:p+m]
        # extraemos submatriz, la transformamos y la reinyectamos
        Hsub = H[p+1:p+m, p+1:p+m]
        francis_step!(Hsub)
        H[p+1:p+m, p+1:p+m] .= Hsub
        # acumular Q: Q[:, p+1:p+m] *= Z  (aprox usando same P’s)
        # aquí podrías re-aplicar los mismos reflectores a U[:, p+1:p+m]
        # pero para simplificar omitimos la acumulación exacta
    end
    # 4.3 triangularizar bloques 2×2 (si quieres ordenar)
    return Q, H
end

# ---------------- ejemplo ----------------
A = [1.0 2.0 3.0 4.0;
     4.0 5.0 6.0 7.0;
     2.0 1.0 5.0 0.0;
     4.0 2.0 1.0 0.0]

Q, T = qr_algorithm(A; tol=1e-10, maxiter=500)
println("QT*A*Q = T ?")
display(Q' * A * Q)
display(T)

QT*A*Q = T ?

4×4 Matrix{Float64}:
  1.0          5.0          -1.53952   1.27667
  6.0          8.55556      -0.108475  3.69859
  1.77636e-15  5.91817      -2.16888   1.14276
 -2.22045e-16  3.02824e-16   0.142756  3.61332

4×4 Matrix{Float64}:
 11.1055        5.98259      -4.15793    0.941075
  0.0          -3.85559       0.823463  -1.1548
 -4.03897e-28   0.0           0.932093   1.33903
 -1.03398e-25  -2.33915e-10   1.49066    2.81798

import Pkg; Pkg.add("PrettyTables")

    Updating registry at `~/.julia/registries/General.toml`
   Resolving package versions...
    Updating `~/.julia/environments/v1.10/Project.toml`
  [08abe8d2] + PrettyTables v2.4.0
  No Changes to `~/.julia/environments/v1.10/Manifest.toml`

using LinearAlgebra, Random, Statistics
using PrettyTables, Plots

function run_experiment(n; tol=1e-10, maxiter=500, reps=5)
    times  = Float64[]
    errors = Float64[]

    for rep in 1:reps
        A = randn(n,n)
        λ_ref = eigvals(A) |> x->sort(x, by=z->(real(z), imag(z)))

        t0 = time()
        Q, T = qr_algorithm(A; tol=tol, maxiter=maxiter)   # solo dos retornos
        push!(times, time() - t0)

        # extraer eigenvalues de T (bloques 1×1 y 2×2)
        λ_approx = ComplexF64[]
        i = 1
        while i ≤ n
            if i<n && abs(T[i+1,i]) > tol
                append!(λ_approx, eigvals(T[i:i+1, i:i+1]))
                i += 2
            else
                push!(λ_approx, T[i,i])
                i += 1
            end
        end
        sort!(λ_approx, by=z->(real(z), imag(z)))
        push!(errors, maximum(abs.(λ_ref .- λ_approx)))
    end

    return (
      n          = n,
      tol        = tol,
      time_mean  = mean(times),
      time_std   = std(times),
      err_mean   = mean(errors),
      err_std    = std(errors),
    )
end

sizes = [100, 500, 1000]
tols  = [1e-6, 1e-8, 1e-10]
results = [ run_experiment(n; tol=tol, maxiter=1000, reps=5)
            for n in sizes, tol in tols ]

# ————————————————————————————————
# Mostrar tabla
# ————————————————————————————————
header = ["n", "tol", "⟨time⟩","σ(time)","⟨err⟩","σ(err)"]
data = [ (r.n, r.tol,
          round(r.time_mean; digits=4), round(r.time_std; digits=4),
          round(r.err_mean; digits=2),  round(r.err_std; digits=2))
         for r in vec(results) ]

data_matrix = reduce(vcat, [collect(row)' for row in data])


pretty_table(data_matrix, header=header; alignment=:l)

┌──────┬─────────┬─────────┬─────────┬───────┬────────┐
│ n    │ tol     │ ⟨time⟩  │ σ(time) │ ⟨err⟩ │ σ(err) │
├──────┼─────────┼─────────┼─────────┼───────┼────────┤
│ 100  │ 1.0e-6  │ 0.0598  │ 0.028   │ 15.24 │ 0.42   │
│ 500  │ 1.0e-6  │ 6.8763  │ 0.8453  │ 28.3  │ 1.07   │
│ 1000 │ 1.0e-6  │ 85.8292 │ 2.1737  │ 40.65 │ 2.24   │
│ 100  │ 1.0e-8  │ 0.0455  │ 0.0085  │ 13.67 │ 1.09   │
│ 500  │ 1.0e-8  │ 7.1965  │ 0.7334  │ 29.46 │ 1.76   │
│ 1000 │ 1.0e-8  │ 85.2746 │ 0.8337  │ 42.19 │ 3.63   │
│ 100  │ 1.0e-10 │ 0.0576  │ 0.0203  │ 13.43 │ 1.83   │
│ 500  │ 1.0e-10 │ 6.6466  │ 0.5463  │ 29.53 │ 1.59   │
│ 1000 │ 1.0e-10 │ 86.4145 │ 0.9153  │ 41.96 │ 2.2    │
└──────┴─────────┴─────────┴─────────┴───────┴────────┘

using Pkg
Pkg.add("BenchmarkTools")
using BenchmarkTools

   Resolving package versions...
   Installed BenchmarkTools ─ v1.6.0
    Updating `~/.julia/environments/v1.10/Project.toml`
  [6e4b80f9] + BenchmarkTools v1.6.0
    Updating `~/.julia/environments/v1.10/Manifest.toml`
  [6e4b80f9] + BenchmarkTools v1.6.0
  [9abbd945] + Profile
Precompiling packages...
   3627.1 ms  ✓ BenchmarkTools
  1 dependency successfully precompiled in 8 seconds. 463 already precompiled.

using LinearAlgebra, BenchmarkTools

function benchmark_qr(n; tol=1e-10, maxiter=1000)
    A = randn(n, n)
    println("Benchmark para n=$n, tol=$tol:")
    bench = @benchmark qr_algorithm($A; tol=$tol, maxiter=$maxiter)
    display(bench)
    return bench
end

benchmarks = Dict()
for n in [50, 100, 200]
    for tol in [1e-6, 1e-8]
        key = (n, tol)
        println("\n-----------------------------")
        println("Ejecutando para n=$n y tol=$tol")
        bench = benchmark_qr(n; tol=tol)
        benchmarks[key] = bench
    end
end

-----------------------------
Ejecutando para n=50 y tol=1.0e-6
Benchmark para n=50, tol=1.0e-6:

BenchmarkTools.Trial: 468 samples with 1 evaluation per sample.
 Range (min … max):   5.757 ms … 39.002 ms  ┊ GC (min … max): 0.00% … 38.69%
 Time  (median):      9.428 ms              ┊ GC (median):    0.00%
 Time  (mean ± σ):   10.608 ms ±  5.279 ms  ┊ GC (mean ± σ):  8.38% ± 13.10%

  ▇▂█▅▂ ▂▇▇▆▆ ▁▃   ▂▁      ▂                                   
  █████▇████████▆▇▄██▁▄▄▇▇▇█▄▇▇▇▄██▇▄▇▆▄▁▁▄▁▁▄▁▁▁▁▁▁▁▁▁▄▄▄▄▁▄ ▇
  5.76 ms      Histogram: log(frequency) by time      32.8 ms <

 Memory estimate: 10.68 MiB, allocs estimate: 23342.

-----------------------------
Ejecutando para n=50 y tol=1.0e-8
Benchmark para n=50, tol=1.0e-8:

BenchmarkTools.Trial: 307 samples with 1 evaluation per sample.
 Range (min … max):  12.866 ms … 33.446 ms  ┊ GC (min … max): 0.00% … 23.02%
 Time  (median):     14.472 ms              ┊ GC (median):    0.00%
 Time  (mean ± σ):   16.274 ms ±  3.904 ms  ┊ GC (mean ± σ):  9.86% ± 13.18%

   ██ ▁ ▁▁                                                     
  ▅████▇██▆▇▅▅▂▂▃▄▃▃▃▃▁▁▁▁▁▁▁▁▂▃▂▁▄▃▇▄▄▁▃▂▃▃▁▁▃▃▂▃▃▃▃▃▃▂▂▂▂▁▂ ▃
  12.9 ms         Histogram: frequency by time        26.4 ms <

 Memory estimate: 19.68 MiB, allocs estimate: 98866.

-----------------------------
Ejecutando para n=100 y tol=1.0e-6
Benchmark para n=100, tol=1.0e-6:

BenchmarkTools.Trial: 91 samples with 1 evaluation per sample.
 Range (min … max):  45.979 ms … 69.315 ms  ┊ GC (min … max):  0.00% … 12.93%
 Time  (median):     55.015 ms              ┊ GC (median):    12.26%
 Time  (mean ± σ):   55.034 ms ±  4.255 ms  ┊ GC (mean ± σ):  10.54% ±  4.69%

                       ▄█▅ ▃                                   
  ▅▁▁▃▃▄▄▄▁▄▃▁▁▁▁▁▁▁▃▇▇███▇█▆▁▄▅▅▁▁▃▄▃▁▁▁▁▁▁▃▁▁▁▁▁▁▁▁▁▃▁▁▁▃▁▃ ▁
  46 ms           Histogram: frequency by time        69.2 ms <

 Memory estimate: 73.23 MiB, allocs estimate: 164704.

-----------------------------
Ejecutando para n=100 y tol=1.0e-8
Benchmark para n=100, tol=1.0e-8:

BenchmarkTools.Trial: 77 samples with 1 evaluation per sample.
 Range (min … max):  49.036 ms … 82.195 ms  ┊ GC (min … max):  0.00% … 11.37%
 Time  (median):     67.469 ms              ┊ GC (median):    12.77%
 Time  (mean ± σ):   65.543 ms ±  6.255 ms  ┊ GC (mean ± σ):  11.97% ±  2.72%

                 ▂█▂              ▂▄███▆ ▂                     
  ▄▁▁▁▄▁▁▁▁▁▁▁▁▄▄███▄▆▁▄▁▆▁▁▁▄▄▁▄▆██████▁█▁▄▆▄▁▁▁▁▁▁▁▁▁▁▁▁▁▄▄ ▁
  49 ms           Histogram: frequency by time        81.3 ms <

 Memory estimate: 85.52 MiB, allocs estimate: 99244.

-----------------------------
Ejecutando para n=200 y tol=1.0e-6
Benchmark para n=200, tol=1.0e-6:

BenchmarkTools.Trial: 19 samples with 1 evaluation per sample.
 Range (min … max):  254.024 ms … 382.987 ms  ┊ GC (min … max): 5.95% … 6.36%
 Time  (median):     287.051 ms               ┊ GC (median):    6.12%
 Time  (mean ± σ):   281.468 ms ±  29.808 ms  ┊ GC (mean ± σ):  6.10% ± 0.93%

  █▁             ▄  ▄                                            
  ██▁▁▁▆▁▆▆▁▁▁▁▁▁█▆▆█▁▁▁▁▆▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▆ ▁
  254 ms           Histogram: frequency by time          383 ms <

 Memory estimate: 363.23 MiB, allocs estimate: 86423.

Paso k	$e_k$	$e_{k+1}$	r_k = $e_{k+1}$/$e_k$
1	6.00000	4.15746	0.69291
2	4.15746	3.04463	0.73255

Algoritmo de factorización QR Trasladado¶

Prerrequisitos: Gram Schmidt modificado, Reflectores de Householder y forma de Hessenberg superior¶

Explicación clara del algoritmo¶

¿Cuál es la utilidad de añadir traslados al algoritmo de factorización QR?¶

QR con traslado único¶

QR con traslado doble implícito¶

QR Completo¶

Experimentos numéricos¶

Conclusiones¶

Declaración de uso de IA¶

Referencias¶