Jdi na navigaci předmětu

05: Vícerozměrná pole a maticové typy

Tento notebook je výukovým materiálem v předmětu BI-JUL.21 vyučovaném v zimním semestru akademického roku 2023/2024 Tomášem Kalvodou. Tvorba těchto materiálů byla podpořena NVS FIT.

Hlavní stránkou předmětu, kde jsou i další notebooky a zajímavé informace, je jeho Course Pages stránka.

versioninfo()

Julia Version 1.9.3
Commit bed2cd540a1 (2023-08-24 14:43 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 8 × Intel(R) Core(TM) i5-8250U CPU @ 1.60GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-14.0.6 (ORCJIT, skylake)
  Threads: 2 on 8 virtual cores

1. Vícerozměrná pole (`Array`)

Vícerozměrné pole si lze představovat jako "kolekci" objektů uložených ve vícerozměrné mřížce (matice/tabulka, kvádr,...).

I pole mají svůj parametrický typ, který určuje jaké objekty dokáží uchovávat a jaký mají rozměr.

Nejobecnějším případem je přirozeně Array{Any}, resp. Array{Any, n}, kde $n$ označuje dimenzionalitu (rozměry) pole. Pole těchto typů pojmou libovolné objekty, tj. objekty typu Any. Obecně objekty typu Array{T} představují vícerozměrná pole s prvky typu T.

Array{Any} <: Array

true

Array{Any, 2} <: Array{Any}

true

Jak už bylo zmíněno v třetí lekci, k prvkům, nebo částem, pole přistupujeme pomocí hranatých závorek. Nejrpve se ale pusťme do konstrukce prvních polí, aby pak bylo co indexovat.

1.1 Vytváření a indexování polí

Neinicializované pole s rozměry dims a prvky typu T vytvoříme pomocí příkazu Array{T}(undef, dims...). dims může být tuple, nebo popořadě velikosti jednotlivých "dimenzí". Ukažme si to na příkladech:

# 1d array of Int64s with 5 elements
Array{Int64}(undef, 5)

5-element Vector{Int64}:
  1
  2
  3
 -1
 19

Ihned poznamenejme, že Vector{T} jen šikovná zkratka pro jednodimenzionální pole s prvky typu T.

Vector{Any} == Array{Any, 1}

true

Nyní se přesuňme k dvojrozměrným polím.

# 2d 10x5 array of Float64s
Array{Float64}(undef, 10, 5)

10×5 Matrix{Float64}:
 6.94455e-310  6.94455e-310  6.94455e-310  6.94451e-310  6.94455e-310
 6.94455e-310  6.94455e-310  6.94451e-310  6.94455e-310  6.94455e-310
 6.94455e-310  6.94455e-310  6.94455e-310  6.94451e-310  6.94455e-310
 6.94451e-310  6.94455e-310  6.94455e-310  6.94455e-310  6.94455e-310
 6.94455e-310  6.94455e-310  6.94455e-310  6.94455e-310  6.94455e-310
 6.94455e-310  6.94455e-310  6.94455e-310  6.94455e-310  6.94455e-310
 6.94451e-310  6.94455e-310  6.94455e-310  6.94455e-310  6.94455e-310
 6.94455e-310  6.94451e-310  6.94455e-310  6.94455e-310  6.94455e-310
 6.94455e-310  6.94451e-310  6.94455e-310  6.94455e-310  6.94455e-310
 6.94451e-310  6.94451e-310  6.94451e-310  6.94455e-310  6.94455e-310

Podobně jako výše, Matrix{T} je pouze konvenční krycí název pro dvourozměrné pole.

Matrix{Any} == Array{Any, 2}

true

Od tří dimenzí dále už výpis pole samozřejmě není úplně přehledný, je ale možný.

# 3d 4x4x4 array of strings
Array{String}(undef, (4, 4, 4))

4×4×4 Array{String, 3}:
[:, :, 1] =
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef

[:, :, 2] =
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef

[:, :, 3] =
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef

[:, :, 4] =
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef

Array{Any}(undef, (4, 4, 4))

4×4×4 Array{Any, 3}:
[:, :, 1] =
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef

[:, :, 2] =
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef

[:, :, 3] =
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef

[:, :, 4] =
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef
 #undef  #undef  #undef  #undef

Tato pole nejsou inicializována, jejich hodnoty jsou "náhodné", podle toho co zbylo na místě původní paměti. Vzhledem k explicitnímu zmínění slovíčka undef v předchozích příkazech by se mohlo zdát, že můžeme prvky polí tímto způsobem předvyplnit požadovanou hodnotou, ale není tomu tak:

Array{Int64}(42, 5)

MethodError: no method matching (Array{Int64})(::Int64, ::Int64)

Closest candidates are:
  (Array{T})(::LinearAlgebra.UniformScaling, ::Integer, ::Integer) where T
   @ LinearAlgebra /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/uniformscaling.jl:512
  (Array{T})(::UndefInitializer, ::Int64) where T
   @ Core boot.jl:491
  (Array{T})(::UndefInitializer, ::Int64, ::Int64) where T
   @ Core boot.jl:492
  ...


Stacktrace:
 [1] top-level scope
   @ In[12]:1

Viz metodu fill níže.

Vytváření polí s požadovanými prvky (Maticové literály)

Jednorozměrná (vektory) a dvourozměrná (matice) pole můžeme zadat explicitně pomocí hranatých závorek, před kterými můžeme případně uvést požadovaný typ prvků. K oddělení prvků máme bohaté možnosti: používáme čárky (,), mezery, konce řádků, nebo středníky (;). Tímto způsobem můžeme kontrolovat rozměry pole.

[1, 2, 3]

3-element Vector{Int64}:
 1
 2
 3

[1, 2, 3.]

3-element Vector{Float64}:
 1.0
 2.0
 3.0

transpose([1,2,3])

1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

[1.0; 2.0; 3.0]

3-element Vector{Float64}:
 1.0
 2.0
 3.0

Float64[1, 2, 3]

3-element Vector{Float64}:
 1.0
 2.0
 3.0

Ale pozor, následující pole je už dvourozměrné:

[1 2 3]

1×3 Matrix{Int64}:
 1  2  3

Dvourozměrná pole zadáváme po řádcích oddělených středníky, nebo koncemi řádků:

[1 0; 0 1]

2×2 Matrix{Int64}:
 1  0
 0  1

[1 0, 0 1]

syntax: unexpected comma in array expression

Stacktrace:
 [1] top-level scope
   @ In[22]:1

Float64[
    1 2 3
    4 5 6
]

2×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0

Tento způsob se samozřejmě hodí jen pro malá pole. Častěji potřebujeme pracovat například s maticemi s velkým počtem prvků a takovéto explicitní vypisování by bylo komplikované. Typicky třeba známe předpis pro $ij$ -tý prvek. Pak můžeme použít analog Pythonovského list comprehension.

Například Float64 5x5 verzi Hilbertovy matice, které má na $ij$ -tém políčku hodnotu $\frac{1}{i+j-1}$ můžeme definovat takto:

H = [ 1/(i+j-1) for i = 1:5, j = 1:5 ]

5×5 Matrix{Float64}:
 1.0       0.5       0.333333  0.25      0.2
 0.5       0.333333  0.25      0.2       0.166667
 0.333333  0.25      0.2       0.166667  0.142857
 0.25      0.2       0.166667  0.142857  0.125
 0.2       0.166667  0.142857  0.125     0.111111

Zde první index je řádkový a druhý sloupcový, jak bude patrné z následujícího příkladu

[ (i, j) for i = 1:4, j = 1:5]

4×5 Matrix{Tuple{Int64, Int64}}:
 (1, 1)  (1, 2)  (1, 3)  (1, 4)  (1, 5)
 (2, 1)  (2, 2)  (2, 3)  (2, 4)  (2, 5)
 (3, 1)  (3, 2)  (3, 3)  (3, 4)  (3, 5)
 (4, 1)  (4, 2)  (4, 3)  (4, 4)  (4, 5)

[ (i, j) for i = 1:4, j = 1:4, k = 1:2]

4×4×2 Array{Tuple{Int64, Int64}, 3}:
[:, :, 1] =
 (1, 1)  (1, 2)  (1, 3)  (1, 4)
 (2, 1)  (2, 2)  (2, 3)  (2, 4)
 (3, 1)  (3, 2)  (3, 3)  (3, 4)
 (4, 1)  (4, 2)  (4, 3)  (4, 4)

[:, :, 2] =
 (1, 1)  (1, 2)  (1, 3)  (1, 4)
 (2, 1)  (2, 2)  (2, 3)  (2, 4)
 (3, 1)  (3, 2)  (3, 3)  (3, 4)
 (4, 1)  (4, 2)  (4, 3)  (4, 4)

[ (i, j) for i = 1:4, j = 1:3, k = 1:2, l=1:2]

Před hranatou závorkou můžeme opět vynutit typ prvků:

UInt32[ j for j = 1:10 ]

10-element Vector{UInt32}:
 0x00000001
 0x00000002
 0x00000003
 0x00000004
 0x00000005
 0x00000006
 0x00000007
 0x00000008
 0x00000009
 0x0000000a

Dejte pozor na ne/přítomnost hranatých závorek, například následující buňka nevyústí v matici:

[ [ j+k for j=1:3 ] for k=1:3 ]

3-element Vector{Vector{Int64}}:
 [2, 3, 4]
 [3, 4, 5]
 [4, 5, 6]

Lze přidávat i podmínky jako v Pythonu:

[ j for j = 1:10 if iseven(j) ]

5-element Vector{Int64}:
  2
  4
  6
  8
 10

Indexování polí

Prvky pole jsou standardně indexovány od $1$ . K prvkům pole přistupujeme pomocí hranatých závorek. K indexování můžeme použít i rozsah (range) a získat tak část pole (slice, řez). Stejným způsobem můžeme prvky, nebo celé bloky matice, modifikovat pomocí přiřazení. Ukažme si to na následující Töplitzově matici (konstantní hodnoty na diagonále i všech vedlejších diagonálách):

T = [ 5 - i + j for i = 1:4, j = 1:4 ]

4×4 Matrix{Int64}:
 5  6  7  8
 4  5  6  7
 3  4  5  6
 2  3  4  5

Hodnoty v rozích matice:

println("Levý horní:  ", T[1, 1])
println("Pravý horní: ", T[1, 4])
println("Levý dolní:  ", T[4, 1])
println("Pravý dolní: ", T[4, 4])

Levý horní:  5
Pravý horní: 8
Levý dolní:  2
Pravý dolní: 5

T[1, 5]

BoundsError: attempt to access 4×4 Matrix{Int64} at index [1, 5]

Stacktrace:
 [1] getindex(::Matrix{Int64}, ::Int64, ::Int64)
   @ Base ./essentials.jl:14
 [2] top-level scope
   @ In[32]:1

Změníme hodnotu v pravo nahoře:

T[1, 4] = -2
T

4×4 Matrix{Int64}:
 5  6  7  -2
 4  5  6   7
 3  4  5   6
 2  3  4   5

2x3 podmatice v levém horním rohu:

1:2

1:2

T[1:2, 1:3]

2×3 Matrix{Int64}:
 5  6  7
 4  5  6

Změna 2x2 bloku vpravo dole na jednotkovou matici 2x2:

T[3:4, 3:4] = [1 0; 0 1]
T

4×4 Matrix{Int64}:
 5  6  7  -2
 4  5  6   7
 3  4  1   0
 2  3  0   1

Pokud chceme celý řádek/sloupec, pak pro tyto účely můžeme použít pouze :. Rozsah "až do konce" můžeme vyjádřit pomocí end:

T[:, 2:end]

4×3 Matrix{Int64}:
 6  7  -2
 5  6   7
 4  1   0
 3  0   1

T[:, 2:-1]

4×0 Matrix{Int64}

T[:,1:2:end]

4×2 Matrix{Int64}:
 5  7
 4  6
 3  1
 2  0

T[:, 2:-1:-1]

BoundsError: attempt to access 4×4 Matrix{Int64} at index [1:4, 2:-1:-1]

Stacktrace:
 [1] throw_boundserror(A::Matrix{Int64}, I::Tuple{Base.Slice{Base.OneTo{Int64}}, StepRange{Int64, Int64}})
   @ Base ./abstractarray.jl:744
 [2] checkbounds
   @ ./abstractarray.jl:709 [inlined]
 [3] _getindex
   @ ./multidimensional.jl:860 [inlined]
 [4] getindex(::Matrix{Int64}, ::Function, ::StepRange{Int64, Int64})
   @ Base ./abstractarray.jl:1296
 [5] top-level scope
   @ In[42]:1

T[:, 2:-1:1]

4×2 Matrix{Int64}:
 6  5
 5  4
 4  3
 3  2

Nyní probereme metody, které se hodí při vytváření nových "obecných" polí. V případě matic máme více možností, kterým se budeme věnovat v příslušné lekci.

Konkatenace polí (`vcat` a `hcat`)

V metamatickém zápisu často používáme blokový zápis matic. Jeho analogem je konkatenace.

Mějme tři pole:

A = [1, 1, 1]

3-element Vector{Int64}:
 1
 1
 1

B = [2 2]

1×2 Matrix{Int64}:
 2  2

C = [3 3; 3 3; 3 3]

3×2 Matrix{Int64}:
 3  3
 3  3
 3  3

Pokud má operace rozměrově smysl, můžeme pole spojovat horizontálně:

[A C A]

3×4 Matrix{Int64}:
 1  3  3  1
 1  3  3  1
 1  3  3  1

hcat(A, C, A)

3×4 Matrix{Int64}:
 1  3  3  1
 1  3  3  1
 1  3  3  1

Nebo vertikálně:

[B; C; B]

5×2 Matrix{Int64}:
 2  2
 3  3
 3  3
 3  3
 2  2

vcat(B, C, B)

5×2 Matrix{Int64}:
 2  2
 3  3
 3  3
 3  3
 2  2

A oba přístupy lze dohromady i kombinovat právě v něčem, co připomíná blokový zápis:

[ B B; C C]

4×4 Matrix{Int64}:
 2  2  2  2
 3  3  3  3
 3  3  3  3
 3  3  3  3

[
    B B
    C C
]

4×4 Matrix{Int64}:
 2  2  2  2
 3  3  3  3
 3  3  3  3
 3  3  3  3

`push!` a `pop!`

Do jednorozměrného pole lze přidávat prvky pomocí push! a ubírat je pomocí pop! (odzadu):

a = [1, 2, 3]

push!(a, 4)

a

4-element Vector{Int64}:
 1
 2
 3
 4

x = pop!(a)

println(x)
a

3-element Vector{Int64}:
 1
 2
 3

Dále máme i metodu append!, která ale spojuje více jednorzměrných polí dohromady.

append!(a, [5, 6])

a

5-element Vector{Int64}:
 1
 2
 3
 5
 6

append!(a, 42)

6-element Vector{Int64}:
  1
  2
  3
  5
  6
 42

@which append!(a, 42)

append!(a::AbstractVector, iter) in Base at array.jl:1126

Existují i další související metody jako pushfirst!, popfirst!, popat!, insert! a další.

`fill` a `fill!`

K uniformní inicializaci prvků pole slouží dvě metody:

fill(x, dims...): vytvoří nové pole s prvky x a rozměry dims.
fill!(A, x): zaplní již existující pole A prvky x

# 1d array of 5 elemens equal to 42
fill(42, 5)

5-element Vector{Int64}:
 42
 42
 42
 42
 42

# 2d 3x4 array of 0.5s
fill(0.5, 3, 4)

3×4 Matrix{Float64}:
 0.5  0.5  0.5  0.5
 0.5  0.5  0.5  0.5
 0.5  0.5  0.5  0.5

A = Array{String}(undef, 2, 2)
println(A)

fill!(A, "Hello!")
println(A)

[#undef #undef; #undef #undef]
["Hello!" "Hello!"; "Hello!" "Hello!"]

`zeros` a `ones`

Často chceme předvyplnit matice jedničkami, nebo nulami. Přesně k tomuto účelu slouží metody zeros(T, dims...) a ones(T, dims...). První argument, tedy typ, je nepovinný, výchozí hodnota je Float.

zeros(2, 2)

2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

ones(3)

3-element Vector{Float64}:
 1.0
 1.0
 1.0

Kdybychom chtěli stejné matice, ovšem s Int64 prvky, stačí tento požadavek explicitně zmínit:

zeros(Int64, 2, 2)

2×2 Matrix{Int64}:
 0  0
 0  0

ones(Int64, 3)

3-element Vector{Int64}:
 1
 1
 1

Pro vytvoření pouze nuly nebo jedničky v daném typu slouží analogické metody zero a one.

zero(Float64)

0.0

one(Int64)

ones(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

one(Matrix{Int64}(undef, 2, 2))

2×2 Matrix{Int64}:
 1  0
 0  1

Ale viz I v další lekci.

`copy` a `deepcopy`

Tyto metody asi nepotřebují vysvětlení. Vytvoří kopii, resp. hlubokou kopii, daného pole. Názorná ukázka:

A = Array{Any}(undef, 2)
a = 42
b = [1, 2]

A[1] = a
A[2] = b

A

2-element Vector{Any}:
 42
   [1, 2]

C = copy(A)
D = deepcopy(A)

a    = 11
b[1] = 9999

println(C)
println(D)

Any[42, [9999, 2]]
Any[42, [1, 2]]

`rand` a `randn`

Náhodně generovaným hodnotám, resp. pravděpodobnosti a statistice, se budeme podrobně věnovat později během semestru. Zde si zmíníme jenom dvě metody pro vytváření "náhodných" matic.

První z nich, rand(T, dims...) vytvoří pole dimenzí dims s prvky typu T rovnoměrně rozloženými (u podtypů AbstractFloat v intervalu $[0, 1)$ ), první typový argument je opět nepovinný a jeho výchozí hodnota je Float64.

rand(Int64, 4)

4-element Vector{Int64}:
  4772610011388109269
 -3571279284080149532
 -6271570679144981586
 -2060692245812105270

rand(5, 5)

5×5 Matrix{Float64}:
 0.559959  0.972308  0.540684  0.0916941  0.664898
 0.133505  0.141973  0.964641  0.555466   0.381102
 0.153139  0.925109  0.285147  0.902314   0.948959
 0.840954  0.625575  0.423901  0.984069   0.209668
 0.952297  0.685319  0.993663  0.781325   0.658258

rand([1, 2, "Ahoj!"])

Příkaz randn(T, dims...) se od předchozího liší tím, že generuje prvky podle normálního rozdělení (se střední hodnotou $0$ a standardní odchylkou $1$ , má dobrý smysl jen pro podtypy AbstractFloat).

randn(10)

10-element Vector{Float64}:
  1.6781230441265529
  0.05708700794606069
  0.19602272406677881
  0.31252981727112616
  0.7284656687677958
 -0.5674979659563325
 -1.090176125282962
 -0.4420776850654396
  1.665969892637253
 -0.4123321160322748

Následující pokus přirozeně skončí nezdarem:

randn(Int64, 2, 2)

MethodError: no method matching randn(::Random.TaskLocalRNG, ::Type{Int64})

Closest candidates are:
  randn(::Random.AbstractRNG, ::Type{T}, ::Tuple{Vararg{Int64, N}} where N) where T
   @ Random /usr/share/julia/stdlib/v1.9/Random/src/normal.jl:247
  randn(::Random.AbstractRNG, ::Type{T}, ::Integer, ::Integer...) where T
   @ Random /usr/share/julia/stdlib/v1.9/Random/src/normal.jl:250
  randn(::Random.AbstractRNG)
   @ Random /usr/share/julia/stdlib/v1.9/Random/src/normal.jl:38
  ...


Stacktrace:
 [1] randn!
   @ /usr/share/julia/stdlib/v1.9/Random/src/normal.jl:208 [inlined]
 [2] randn
   @ /usr/share/julia/stdlib/v1.9/Random/src/normal.jl:250 [inlined]
 [3] randn(::Type{Int64}, ::Int64, ::Int64)
   @ Random /usr/share/julia/stdlib/v1.9/Random/src/normal.jl:252
 [4] top-level scope
   @ In[92]:1

Pokud rand předáme pole, pak náhodně vybere jeden jeho prevek:

for j = 1:10
    println(rand([1, 2, 3, 4]))
end

for j = 1:10
    println(rand([-1 0; 1 2]))
end

To by jako exkurze do světa náhody pro tento okamžik stačilo. Podrobněji se do něj vrátíme hned příště.

`range`

Pro vytváření jednorozměrných polí se často hodí metoda range(start; stop=stop, length=n), pomocí níž lze vytvořit pole s rovnoměrně rozmístěnými prvky:

range(1, stop=5)

1:5

range(1, stop=6, length=10)

1.0:0.5555555555555556:6.0

Další užitečné metody

Pro práci s poli se mohou hodit následující metody:

eltype(A): typ prvků pole
length(A): počet prvků pole
ndims(A): počet rozměrů ("dimenzí") pole
size(A): tuple s velikostí jednotlivých rozměrů pole
size(A, n): velikost $n$ tého rozměru pole
axes(A): tuple s hodnotami indexů v jednotlivých rozměrech (o přeindexování polí později)

Ukázka:

A = rand(4, 3, 2)

4×3×2 Array{Float64, 3}:
[:, :, 1] =
 0.551218  0.253859  0.677131
 0.558399  0.744952  0.919791
 0.982651  0.725544  0.529571
 0.573337  0.388952  0.295793

[:, :, 2] =
 0.28629   0.345275   0.924147
 0.444232  0.266164   0.868263
 0.174838  0.895783   0.39991
 0.362193  0.0065022  0.167784

eltype(A)

Float64

length(A)

4 * 3 * 2

length([[1, 2], [3, 4]])

ndims(A)

size(A)

(4, 3, 2)

println(size(A, 1))
println(size(A, 2))
println(size(A, 3))

4
3
2

Tj. nemusíme dělat ošklivé:

size(A)[2]

axes(A)

(Base.OneTo(4), Base.OneTo(3), Base.OneTo(2))

axes(A, 2)

Base.OneTo(3)

N.B.:

Base.OneTo(4) == 1:4

true

1.2 Cvičení

Vytvořte matici A rozměru $10 \times 10$ mající na antidiagonálách postupně konstanty $1$ , $2$ , $3$ ,..., $19$ .
Vytvořte matici B rozměru $5 \times 10$ , která má všechny prvky nulové, pouze na "okraji" (obdélník) má jedničky.
Vytvořte čtvercovou matici C rozměru $20 \times 20$ , která je složena ze čtyř stejně velkých bloků: vlevo nahoře je blok náhodně vygenerovaných strojových čísel, vpravo nahoře matice naplněná jedničkami, vlevo dole nulová matice a vpravo dole diagonální matice s počátečními ciframi čísla $\pi$ na diagonále.
Vytvořte čtvercovou matici D rozměru $10 \times 10$ , která bude v levém horním trojúhelníku mít Pascalův trojúhelník. Prvky vypočtete Pascalovou "konstrukcí", ne počítáním kombinačních čísel.

A = [ i + j - 1 for i = 1:10, j = 1:10 ]

10×10 Matrix{Int64}:
  1   2   3   4   5   6   7   8   9  10
  2   3   4   5   6   7   8   9  10  11
  3   4   5   6   7   8   9  10  11  12
  4   5   6   7   8   9  10  11  12  13
  5   6   7   8   9  10  11  12  13  14
  6   7   8   9  10  11  12  13  14  15
  7   8   9  10  11  12  13  14  15  16
  8   9  10  11  12  13  14  15  16  17
  9  10  11  12  13  14  15  16  17  18
 10  11  12  13  14  15  16  17  18  19

B = ones(Int64, 5, 10)
B[2:end-1, 2:end-1] = zeros(Int64, size(B, 1) - 2, size(B, 2) - 2)
B

5×10 Matrix{Int64}:
 1  1  1  1  1  1  1  1  1  1
 1  0  0  0  0  0  0  0  0  1
 1  0  0  0  0  0  0  0  0  1
 1  0  0  0  0  0  0  0  0  1
 1  1  1  1  1  1  1  1  1  1

# případně pomocí broadcastingu
B = ones(Int64, 5, 10)
B[2:end-1, 2:end-1] .= 0
B

5×10 Matrix{Int64}:
 1  1  1  1  1  1  1  1  1  1
 1  0  0  0  0  0  0  0  0  1
 1  0  0  0  0  0  0  0  0  1
 1  0  0  0  0  0  0  0  0  1
 1  1  1  1  1  1  1  1  1  1

pi

π = 3.1415926535897...

pid = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]

C = [
    rand(10, 10) ones(10, 10)
    zeros(10, 10) [ i == j ? pid[i] : 0 for i = 1:10, j = 1:10 ]
]

20×20 Matrix{Float64}:
 0.48111    0.850418  0.928892  …  1.0  1.0  1.0  1.0  1.0  1.0  1.0
 0.722266   0.293092  0.769403     1.0  1.0  1.0  1.0  1.0  1.0  1.0
 0.0362526  0.134042  0.989395     1.0  1.0  1.0  1.0  1.0  1.0  1.0
 0.231743   0.115928  0.416758     1.0  1.0  1.0  1.0  1.0  1.0  1.0
 0.271504   0.909809  0.439642     1.0  1.0  1.0  1.0  1.0  1.0  1.0
 0.90566    0.253802  0.555089  …  1.0  1.0  1.0  1.0  1.0  1.0  1.0
 0.536257   0.902659  0.670156     1.0  1.0  1.0  1.0  1.0  1.0  1.0
 0.0996675  0.405568  0.202647     1.0  1.0  1.0  1.0  1.0  1.0  1.0
 0.426387   0.342002  0.59076      1.0  1.0  1.0  1.0  1.0  1.0  1.0
 0.731609   0.559183  0.867365     1.0  1.0  1.0  1.0  1.0  1.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       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.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  0.0  0.0  0.0
 0.0        0.0       0.0          0.0  5.0  0.0  0.0  0.0  0.0  0.0
 0.0        0.0       0.0       …  0.0  0.0  9.0  0.0  0.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
 0.0        0.0       0.0          0.0  0.0  0.0  0.0  6.0  0.0  0.0
 0.0        0.0       0.0          0.0  0.0  0.0  0.0  0.0  5.0  0.0
 0.0        0.0       0.0          0.0  0.0  0.0  0.0  0.0  0.0  3.0

# D == Domácí úkol

2. Operace s poli/maticemi a jejich prvky

S poli a jejich prvky lze provádět celou řadu nejen matematických operací. Většinou jsme motivování operacemi s vektory a maticemi (na rozdíl od jiných programovacích jazyků).

2.1 Sčítání `+` a odčítání `-`

Pole lze přirozeně po složkách sčítat (+), odčítat (-). Tyto operátory fungují jak unárně, tak binárně. Pole musí být stejného rozměru.

A = [1 2; 3 4]

2×2 Matrix{Int64}:
 1  2
 3  4

B = [5 6 7; 8 9 10]

2×3 Matrix{Int64}:
 5  6   7
 8  9  10

C = [1 1; -1 -1]

2×2 Matrix{Int64}:
  1   1
 -1  -1

Součet a rozdíl po složkách, pokud si odpovídají rozměry:

A + A

2×2 Matrix{Int64}:
 2  4
 6  8

A - C

2×2 Matrix{Int64}:
 0  1
 4  5

"Opačná matice":

-A

2×2 Matrix{Int64}:
 -1  -2
 -3  -4

A + B

DimensionMismatch: dimensions must match: a has dims (Base.OneTo(2), Base.OneTo(2)), b has dims (Base.OneTo(2), Base.OneTo(3)), mismatch at 2

Stacktrace:
 [1] promote_shape
   @ ./indices.jl:178 [inlined]
 [2] promote_shape(a::Matrix{Int64}, b::Matrix{Int64})
   @ Base ./indices.jl:169
 [3] +(A::Matrix{Int64}, Bs::Matrix{Int64})
   @ Base ./arraymath.jl:14
 [4] top-level scope
   @ In[139]:1

[1, 2, 3] + [4, 5, 6]

3-element Vector{Int64}:
 5
 7
 9

[1, 2, 3] - [4, 5, 6]

3-element Vector{Int64}:
 -3
 -3
 -3

Násobení `*`

Hvězdička má význam "násobení" a to má více významů. Pole můžeme násobit číslem (skalárem), hvězdičku v tomto případě lze i vynechat:

4 * A

2×2 Matrix{Int64}:
  4   8
 12  16

-2A

2×2 Matrix{Int64}:
 -2  -4
 -6  -8

Dále má hvězdička význam maticového násobení v pravém slova smyslu, tj. matice musí být správného rozměru:

A * A

2×2 Matrix{Int64}:
  7  10
 15  22

A * B

2×3 Matrix{Int64}:
 21  24  27
 47  54  61

B * A

DimensionMismatch: matrix A has dimensions (2,3), matrix B has dimensions (2,2)

Stacktrace:
 [1] _generic_matmatmul!(C::Matrix{Int64}, tA::Char, tB::Char, A::Matrix{Int64}, B::Matrix{Int64}, _add::LinearAlgebra.MulAddMul{true, true, Bool, Bool})
   @ LinearAlgebra /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/matmul.jl:856
 [2] generic_matmatmul!(C::Matrix{Int64}, tA::Char, tB::Char, A::Matrix{Int64}, B::Matrix{Int64}, _add::LinearAlgebra.MulAddMul{true, true, Bool, Bool})
   @ LinearAlgebra /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/matmul.jl:844
 [3] mul!
   @ /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/matmul.jl:303 [inlined]
 [4] mul!
   @ /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/matmul.jl:276 [inlined]
 [5] *(A::Matrix{Int64}, B::Matrix{Int64})
   @ LinearAlgebra /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/matmul.jl:141
 [6] top-level scope
   @ In[138]:1

Inverze `inv`

Maticovou inverzi lze počítat pouze pro regulární matice.

inv([1 2; 3 4])

2×2 Matrix{Float64}:
 -2.0   1.0
  1.5  -0.5

[1 2; 3 4] * inv([1 2; 3 4])

2×2 Matrix{Float64}:
 1.0          0.0
 8.88178e-16  1.0

inv([1 1; 1 1])

LinearAlgebra.SingularException(2)

Stacktrace:
 [1] checknonsingular
   @ /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/factorization.jl:19 [inlined]
 [2] checknonsingular
   @ /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/factorization.jl:22 [inlined]
 [3] #lu!#170
   @ /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/lu.jl:82 [inlined]
 [4] lu!
   @ /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/lu.jl:80 [inlined]
 [5] #lu#176
   @ /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/lu.jl:299 [inlined]
 [6] lu (repeats 2 times)
   @ /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/lu.jl:298 [inlined]
 [7] inv(A::Matrix{Int64})
   @ LinearAlgebra /usr/share/julia/stdlib/v1.9/LinearAlgebra/src/dense.jl:917
 [8] top-level scope
   @ In[145]:1

Vidíte, že je-li typem prvků matice integer, výsledkem bude matice strojových čísel. Podobné chování jsme už viděli i u obyčejného dělení. I pro jednotkovou matici, kde k popsání inverze strojová čísla potřeba nejsou, k tomuto efektu dojde:

inv([1 0; 0 1])

2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

Invertovat ale můžeme i přímo v aritmetice racionálních čísel.

ratA    = Rational{Int64}[1 1; 1 -1]
ratAinv = inv(ratA)

2×2 Matrix{Rational{Int64}}:
 1//2   1//2
 1//2  -1//2

ratA * ratAinv

2×2 Matrix{Rational{Int64}}:
 1//1  0//1
 0//1  1//1

H = [ 1 // (i+j-1) for i = 1:8, j = 1:8 ]

8×8 Matrix{Rational{Int64}}:
 1//1  1//2  1//3   1//4   1//5   1//6   1//7   1//8
 1//2  1//3  1//4   1//5   1//6   1//7   1//8   1//9
 1//3  1//4  1//5   1//6   1//7   1//8   1//9   1//10
 1//4  1//5  1//6   1//7   1//8   1//9   1//10  1//11
 1//5  1//6  1//7   1//8   1//9   1//10  1//11  1//12
 1//6  1//7  1//8   1//9   1//10  1//11  1//12  1//13
 1//7  1//8  1//9   1//10  1//11  1//12  1//13  1//14
 1//8  1//9  1//10  1//11  1//12  1//13  1//14  1//15

inv(H)

8×8 Matrix{Rational{Int64}}:
      64//1      -2016//1       20160//1  …       192192//1      -51480//1
   -2016//1      84672//1     -952560//1       -10594584//1     2882880//1
   20160//1    -952560//1    11430720//1       141261120//1   -38918880//1
  -92400//1    4656960//1   -58212000//1      -776936160//1   216216000//1
  221760//1  -11642400//1   149688000//1      2118916800//1  -594594000//1
 -288288//1   15567552//1  -204324120//1  …  -3030051024//1   856215360//1
  192192//1  -10594584//1   141261120//1      2175421248//1  -618377760//1
  -51480//1    2882880//1   -38918880//1      -618377760//1   176679360//1

Dělení `/`, resp. `\`

Přesněji, mezi maticovými operandy jde o násobení maticovou inverzí zprava, resp. zleva.

A / A

2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

A \ B

2×3 Matrix{Float64}:
 -2.0  -3.0  -4.0
  3.5   4.5   5.5

inv(A) * B

2×3 Matrix{Float64}:
 -2.0  -3.0  -4.0
  3.5   4.5   5.5

Umocňování `^`

Matice lze umocňovat na celočíselné exponenty, se standardními omezeními.

A^2

2×2 Matrix{Int64}:
  7  10
 15  22

A * A

2×2 Matrix{Int64}:
  7  10
 15  22

Provádění operací po složkách pomocí `.` (broadcasting)

Binární operace i metody lze provádět a aplikovat po složkách, resp. na prvcích matice, pomocí symbolu ..

Například můžeme vynásobit odpovídající si prvky obdélníkové matice (které by v pravém slova smyslu maticově násobit nešlo):

2×3 Matrix{Int64}:
 5  6   7
 8  9  10

B .* B

2×3 Matrix{Int64}:
 25  36   49
 64  81  100

Operand ani nemusí být maticový:

4 .* B

2×3 Matrix{Int64}:
 20  24  28
 32  36  40

4 * B

2×3 Matrix{Int64}:
 20  24  28
 32  36  40

4 .+ B

2×3 Matrix{Int64}:
  9  10  11
 12  13  14

4 + B

MethodError: no method matching +(::Int64, ::Matrix{Int64})
For element-wise addition, use broadcasting with dot syntax: scalar .+ array

Closest candidates are:
  +(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:578
  +(::T, ::T) where T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}
   @ Base int.jl:87
  +(::Union{Int16, Int32, Int64, Int8}, ::BigInt)
   @ Base gmp.jl:545
  ...


Stacktrace:
 [1] top-level scope
   @ In[164]:1

2×3 Matrix{Int64}:
 5  6   7
 8  9  10

B .<< 1

2×3 Matrix{Int64}:
 10  12  14
 16  18  20

Můžeme například aplikovat sinus na všechny prvky matice:

sin.(A)

2×2 Matrix{Float64}:
 0.841471   0.909297
 0.14112   -0.756802

Pozor! Následující kód je naprosto v pořádku, většinu elementárních funkcí lze zavést i pro operátory (čtvercové matice):

sin(A)

2×2 Matrix{Float64}:
 -0.465581  -0.148424
 -0.222637  -0.688218

Tento přístup (broadcasting) funguje i pro funkce mající více či méně argumentů, nebo pro další binární operátory!

f = (x) -> x^3

#31 (generic function with 1 method)

2×2 Matrix{Int64}:
 1  2
 3  4

f.(A)

2×2 Matrix{Int64}:
  1   8
 27  64

map(f, A)

2×2 Matrix{Int64}:
  1   8
 27  64

2×2 Matrix{Int64}:
 1  2
 3  4

2×2 Matrix{Int64}:
  1   1
 -1  -1

min.(A, C)

2×2 Matrix{Int64}:
  1   1
 -1  -1

Maskování

Porovnáváním (například pomocí <) matic prvek po prvku můžeme vytvořit masku, pomocí které lze poté z matice extrahovat požadované prvky.

2×2 Matrix{Int64}:
 1  2
 3  4

C = [0 3; 4 -1]

2×2 Matrix{Int64}:
 0   3
 4  -1

mask = A .< C

2×2 BitMatrix:
 0  1
 1  0

V zápisu výše jde v podstatě o infixovou notaci, explicitněji:

isless.(A, C)

2×2 BitMatrix:
 0  1
 1  0

Indexováním pomocí takovéto matice Dostaneme pouze prvky se zkoumanou vlastností:

A[mask]

2-element Vector{Int64}:
 3
 2

Jeden z operandů opět nutně nemusí být maticový:

C .< 2

2×2 BitMatrix:
 1  0
 0  1

C[C .< 2]

2-element Vector{Int64}:
  0
 -1

Nebo (všimněte si, že nedostaneme matici s Boolean prvky, jak bychom možná očekávali):

mask = iseven.(A)

2×2 BitMatrix:
 0  1
 0  1

A[mask]

2-element Vector{Int64}:
 2
 4

Alternativně bychom k podobnému účelu mohli použít metodu filter:

filter(iseven, A)

2-element Vector{Int64}:
 2
 4

Porovnání rychlosti

Explicitní for loop vs. broadcasting.

using BenchmarkTools

function f1(A::Matrix{T}) where { T <: Number }
    A[1, :] .*= A[1, :]
end

function f2(A::Matrix{T}) where { T <: Number }
    for j in axes(A, 2)
        A[1, j] *= A[1, j]
    end
end

function f3(A::Matrix{T}) where { T <: Number }
    A[1, :] = A[1, :] .* A[1, :]
end

mat = rand(2, 1_000_000)

2×1000000 Matrix{Float64}:
 0.765489  0.911187  0.256699   0.168963  …  0.0202292  0.673459  0.813332
 0.531653  0.287934  0.0655423  0.655347     0.97103    0.450013  0.426892

@benchmark f1($mat)

BenchmarkTools.Trial: 695 samples with 1 evaluation.
 Range (min … max):  4.515 ms … 12.686 ms  ┊ GC (min … max): 0.00% … 14.96%
 Time  (median):     6.969 ms              ┊ GC (median):    0.00%
 Time  (mean ± σ):   7.177 ms ±  1.837 ms  ┊ GC (mean ± σ):  6.53% ±  8.01%

  ▂▆     █▁           ▂▁            ▁                         
  ██▇▄▅▆████▆▇█▇▃▆█▆█▅██▆▇▇▅▇▆▆▃▆▆▅██▅▆▅▅▅▆▂▃▄▂▄▃▃▄▂▃▂▄▃▃▃▂▃ ▃
  4.52 ms        Histogram: frequency by time        11.4 ms <

 Memory estimate: 15.26 MiB, allocs estimate: 4.

@benchmark f2($mat)

BenchmarkTools.Trial: 2898 samples with 1 evaluation.
 Range (min … max):  1.122 ms …   3.959 ms  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     1.497 ms               ┊ GC (median):    0.00%
 Time  (mean ± σ):   1.715 ms ± 557.341 μs  ┊ GC (mean ± σ):  0.00% ± 0.00%

   █▃                                                          
  ▃███▅█▇▇▇██▇▆▄▄▃▂▃▂▂▃▃▂▃▃▃▂▃▂▂▂▂▂▂▂▂▃▂▂▂▂▃▃▂▂▂▂▂▂▂▂▂▂▂▂▂▁▂▁ ▂
  1.12 ms         Histogram: frequency by time        3.25 ms <

 Memory estimate: 0 bytes, allocs estimate: 0.

@benchmark f3($mat)

BenchmarkTools.Trial: 528 samples with 1 evaluation.
 Range (min … max):  5.500 ms … 15.222 ms  ┊ GC (min … max): 0.00% … 9.07%
 Time  (median):     9.214 ms              ┊ GC (median):    6.68%
 Time  (mean ± σ):   9.469 ms ±  2.229 ms  ┊ GC (mean ± σ):  9.17% ± 8.83%

   ▁  ▁▇▄   ▂▃▅▁▃▁▂▄▇▄▃▅█▃ ▃▃▄▄▁▄▃▃ ▃▁   ▂ ▁ ▁  ▇             
  ▆█▄▁████████████████████▇████████▇██▆▅▆█▅█▃█▆████▇█▃▅▃▃▃▁▃ ▆
  5.5 ms         Histogram: frequency by time        14.4 ms <

 Memory estimate: 22.89 MiB, allocs estimate: 6.

Zde vidíme, že Julia má ráda rychlé výpočetní for smyčky, není nutná snaha o vektorizaci, jak je tomu třeba u Pythonu nebo Matlabu (kde pak díky tomu dané operace probíhají rychle mimo Python/Matlab díky C/FORTRAN).

Maskování vs. filter.

function my_filter(A::Matrix{T}, number::T) where { T <: Number }
    A[A .< number]
end

my_filter (generic function with 1 method)

@benchmark my_filter($mat, 0.5)

BenchmarkTools.Trial: 612 samples with 1 evaluation.
 Range (min … max):  6.231 ms … 12.860 ms  ┊ GC (min … max): 0.00% … 12.30%
 Time  (median):     7.880 ms              ┊ GC (median):    0.00%
 Time  (mean ± σ):   8.160 ms ±  1.452 ms  ┊ GC (mean ± σ):  5.51% ±  7.87%

   ▅▃▃▃█▇ ▁▁▁ ▁ ▁ ▁▅▁  ▂▁  ▁                                  
  ▇██████▆█████▇█▇███▇▆██▇██▇▅▅▅▆▃▅▃▃▃▃▂▃▄▃▃▃▅▅▄▅▆▅▅▄▃▂▁▃▃▁▁ ▄
  6.23 ms        Histogram: frequency by time        11.7 ms <

 Memory estimate: 11.68 MiB, allocs estimate: 6.

@benchmark filter((x) -> x < 0.5, $mat)

BenchmarkTools.Trial: 1165 samples with 1 evaluation.
 Range (min … max):  2.742 ms … 8.616 ms  ┊ GC (min … max):  0.00% … 23.75%
 Time  (median):     4.144 ms             ┊ GC (median):     0.00%
 Time  (mean ± σ):   4.280 ms ± 1.187 ms  ┊ GC (mean ± σ):  11.53% ± 13.73%

  ▄█  ▁            ▃                                         
  ██▇▆█▆█▆▇█▆▄▅▄▃▃▇██▄▅▄▆▇▅▅▆▄▄▂▅▄▃▄▅▃▄▄▃▃▃▂▃▂▃▃▂▁▂▂▂▃▂▁▂▂▁ ▃
  2.74 ms        Histogram: frequency by time       7.36 ms <

 Memory estimate: 15.26 MiB, allocs estimate: 3.

Cvičení: Monte Carlo výpočet operátorové normy symetrické matice

Pro reálnou čtvercovou matici $\mathbb{A}$ definujeme její operátorovou normu předpisem $\|\mathbb{A}\| = \sup \big\{ \|\mathbb{A}x\| \mid x \in \mathbb{R}^n, \ \|x\| = 1 \big\}.$ Na pravé straně mají normy význam Euklidovké normy na $\mathbb{R}^n$ .

Jinak řečeno, každá hodnota $\| \mathbb{A} x\|$ pro jednotkový vektor $x$ představuje spodní odhad $\|\mathbb{A}\|$ .

Implementujte metodu, která se náhodnou volbou různých vektorů snaží dostat co nejlepší odhad této normy.

Zatím nepoužívejme nástroje z LinearAlgebra, vystačíme si se základními nástroji pro práci s poli. Připomeňme, že Euklidovská norma vektoru $x\in\mathbb{R}^n$ je $\sqrt{\sum_{j=1}^n x_j^2}$ .

using ProgressMeter

function rands2(n::Int64)
    x = rand(n) .- 0.5
    return x / sqrt(sum(x .* x))
end

"""
Náhodný vektor na jednotkové `n`-dimenzionální sféře.
"""
function rands(n::Int64)
    v = ones(n)
    f = () -> 2 * (rand() - 0.5)

    v[1] = f()
    v[2] = sqrt(1 - v[1]^2)
    
    for j = 2:n-2
        r = f()
        v[j], v[j+1] = v[j] * r, v[j] * sqrt(1 - r^2)
    end
    
    if n > 2
        r = f()
        v[n-1], v[n] = v[n-1] * r, v[n-1] * rand([-1, 1]) * sqrt(1 - r^2)
    end
    
    return v
end

"""
Spodní odhad operátorové normy pomocí Monte Carlo přístupu.
"""
function mc_op_norm(A::Matrix{Float64}, trials::Int64)
    size(A, 1) == size(A, 2) || error("`A` is not a square matrix!")
    
    max_norm = 0.0
    
    @showprogress 1 "Tossing coins furiously..." for j = 1:trials
        x = A * rands(size(A, 1))
        val = sum(x .* x)
        val > max_norm && (max_norm = val)
    end
    
    return sqrt(max_norm)
end

mc_op_norm

Test náhodného generátoru.

rands2(2)

2-element Vector{Float64}:
 0.1596747502393053
 0.9871696784930215

x = rands(2)
println(x)
sum(x .* x)

[0.1534959640825031, 0.9881492746596452]

1.0

x = rands(10)
println(x)
sum(x .* x)

[0.9688394223498531, 0.1847919689876727, -0.0932264929858843, 0.13139845835841618, 0.01994440054081354, -0.01767881676524913, -0.015564354671605824, 0.008950993553152953, 0.008942747060182783, 0.011519818704312923]

1.0

Normy některých matic. Začněme nulovou maticí.

mc_op_norm(zeros(3, 3), 10)

0.0

Diagonální matice.

mc_op_norm([-4. 0; 0 3], 1_000_000)

3.99999824853683

A ještě jedna zajímavá matice:

mc_op_norm([1. 4; 5 6], 10^6)

8.683348976410041

sqrt(39 + 5sqrt(53))

8.683348976426238

Pro $n$ rostoucí do nekonečna se norma následujících matic blíží $2$ .

J(n) = Float64[ abs(j-k) == 1 ? 1 : 0 for j=1:n, k=1:n ]

J (generic function with 1 method)

J(5)

5×5 Matrix{Float64}:
 0.0  1.0  0.0  0.0  0.0
 1.0  0.0  1.0  0.0  0.0
 0.0  1.0  0.0  1.0  0.0
 0.0  0.0  1.0  0.0  1.0
 0.0  0.0  0.0  1.0  0.0

mc_op_norm(J(2), 10^6)

1.0

mc_op_norm(J(20), 10^6)

1.9064637689253612

mc_op_norm(J(20), 10^7)

Tossing coins furiously... 100%|█████████████████████████| Time: 0:00:07

1.9141709073257525

mc_op_norm(J(30), 10^9)

Tossing coins furiously...   2%|▍                        |  ETA: 0:19:16

InterruptException:

Stacktrace:
  [1] Array
    @ ./boot.jl:477 [inlined]
  [2] Array
    @ ./boot.jl:486 [inlined]
  [3] similar
    @ ./abstractarray.jl:884 [inlined]
  [4] similar
    @ ./abstractarray.jl:883 [inlined]
  [5] _array_for
    @ ./array.jl:671 [inlined]
  [6] _array_for
    @ ./array.jl:674 [inlined]
  [7] vect
    @ ./array.jl:126 [inlined]
  [8] rands(n::Int64)
    @ Main ./In[1]:25
  [9] macro expansion
    @ ./In[1]:40 [inlined]
 [10] macro expansion
    @ ~/.julia/packages/ProgressMeter/vnCY0/src/ProgressMeter.jl:957 [inlined]
 [11] mc_op_norm(A::Matrix{Float64}, trials::Int64)
    @ Main ./In[1]:39
 [12] top-level scope
    @ In[16]:1

Pro rostoucí rozměry by tato hodnota měla konvergovat k $2$ .

Cvičení 2.3: Erastothenovo síto

Pomocí maskování (indexování pomocí BitArray) lze elegantně využít k implementaci jednoduchého Erastothenova síta.

Erastothenovo síto nám umožňuje nalézt všechna prvočísla menší nebo rovna zadané mezi (n). Základní verze bez optimalizací je následující

Jednička není prvočíslo.
Dalším číslem je dvojka, tedy prvočíslo, zahodíme všechny další násobky dvou.
Dalším nevyškrtnutým číslem je trojka, tedy prvočíslo, zahodíme všechny další násobky tří.
Čtyřku jsme už vyškrtli, takže se dostaneme k pětce, prvočíslu, a opět zahodíme všechny další násobky pěti.
atd.

I. Implementujte metodu erastothenes(n) počítající všechna prvnočísla menší nebo rovna n.

# N.B. BitArray: 
m = BitArray([1 0; 1 0])
println(eltype(m))
println(m[1,1] == true)

# Range se chová jako vektor
(1:5)[[true, true, false, false, true]]

function erastothenes(n::Integer)
    mask = ones(Bool, n)
    mask[1] = false
    
    for j = 2:ceil(Int64,sqrt(n))
        if mask[j]
            for k = 2j:j:n
                mask[k] = 0
            end
        end
    end
    
    return (1:n)[mask]
end

erastothenes(50)

II. Spočtěte všechna prvnočísla menší nebo rovna milion (OEIS:A000040).

ps = erastothenes(100_000_000)

III. S pomocí napočtených dat nalezněte všechna prvočíselná dvojčata v uvedeném rozsahu (tj. prvočísla lišící se o $2$ ; OEIS:A077800). Implementujte metodu, která nalezne všechna dvojčata lišící se o zadané číslo. Tato metoda bude vracet pole tuplů (dvojčat).

function twins(primes::Vector{Int64}, gap::Int64)
    # ...
end

twins(ps, 2)

twins(ps, 4)

Řešení některých příkladů

Možné řešení Erastothenova síta:

function erastothenes(n::Integer)
    mask = ones(Bool, n)
    mask[1] = 0

    for k = 2:n
        if mask[k]
            for j = 2k:k:n
                mask[j] = 0
            end
        end
    end
    
    (1:n)[mask]
end

Možné řešení twins metody.

function twins(primes::Vector{Int64}, gap::Int64)
    twins = []
    
    for j in 2:length(primes)
        if primes[j] - primes[j-1] == gap
            push!(twins, (ps[j-1], ps[j]))
        end
    end

    return twins
end

Monte Carlo.

using ProgressMeter

"""
Náhodný vektor na jednotkové `n`-dimenzionální sféře.
"""
function rands(n::Int64)
    v = ones(n)
    f = () -> 2 * (rand() - 0.5)

    v[1] = f()
    v[2] = sqrt(1 - v[1]^2)
    
    for j = 2:n-2
        r = f()
        v[j], v[j+1] = v[j] * r, v[j] * sqrt(1 - r^2)
    end
    
    if n > 2
        r = f()
        v[n-1], v[n] = v[n-1] * r, v[n-1] * rand([-1, 1]) * sqrt(1 - r^2)
    end
    
    return v
end

"""
Spodní odhad operátorové normy pomocí Monte Carlo přístupu.
"""
function mc_op_norm(A::Matrix{Float64}, trials::Int64)
    size(A, 1) == size(A, 2) || error("`A` is not a square matrix!")
    
    max_val = 0.0
    
    @showprogress 1 "Tossing coins furiously..." for j = 1:trials
        v = A * rands(size(A, 1))
        val = sum(v .* v)
        
        val > max_val && (max_val = val)
    end
    
    sqrt(max_val)
end

Reference

V oficiální dokumentaci je tato problematika shrnuta v kapitole Multi-dimensional Arrays

05: Vícerozměrná pole a maticové typy

1. Vícerozměrná pole (Array)

1.1 Vytváření a indexování polí

Vytváření polí s požadovanými prvky (Maticové literály)

Indexování polí

Konkatenace polí (vcat a hcat)

push! a pop!

fill a fill!

zeros a ones

copy a deepcopy

rand a randn

range