text:
### A Pluto.jl notebook ###
# v0.16.1

using Markdown
using InteractiveUtils

# This Pluto notebook uses @bind for interactivity. When running this notebook outside of Pluto, the following 'mock version' of @bind gives bound variables a default value (instead of an error).
macro bind(def, element)
    quote
        local el = $(esc(element))
        global $(esc(def)) = Core.applicable(Base.get, el) ? Base.get(el) : missing
        el
    end
end

# ╔═╡ af807a43-e828-46e5-b50a-8da60591dec2
begin
	using PlutoUI # user-interface do Pluto.jl
	using Plots  # Julia package para gráficos
	using Dierckx  # Julia package para interpolação/extrapolação de dados
end

# ╔═╡ a417311b-4195-46ad-b106-a8f82057d292
html"<button onclick='present()'>present</button>"

# ╔═╡ 2d599785-a7a3-4e46-8394-276c444c2749
md"""
# Máquinas de corrente contínua (Ex. 4)
Geradores de corrente contínua, exercício 4:
"""

# ╔═╡ 8b049710-8cc2-11eb-33cf-ef396ec1944e
md"""
**Um gerador de excitação composta ligado em longa derivação e fluxo de excitação
série aditivo apresenta as seguintes características:**
"""

# ╔═╡ 70dcec10-8cc3-11eb-0ce1-15f38b9fb0f9
(Pn, Un, nₙ, Ri, Rs, Rd, Nd, Ns)=(8.75e3, 250, 1500, 1.3, 0.1, 223.0, 2000, 50)

# ╔═╡ 0786377e-8cc3-11eb-1413-e90fac064ffd
begin
	Iexc=[0.0, 0.2, 0.4, 0.6, 0.8, 0.9, 1.0, 1.1, 1.3, 1.5, 1.7]
	E₀_1500=[15.0, 100.0, 170.0, 220.0, 250.0, 260.0, 270.0, 280.0, 290.0, 300.0, 310.0]
	Iexc,E₀_1500
end

# ╔═╡ caeb9440-8cc3-11eb-0a47-e32ddfbb60df
md"""
**Considere ainda um interruptor em paralelo com o enrolamento indutor série.**
"""

# ╔═╡ f2e30e10-8cc3-11eb-3254-09eecb58cdd7
md"""
## a) recta de excitação 💻
**Calcule o valor da tensão em vazio sem reóstato de excitação. Explique se o estado do interruptor influencia o valor da tensão de vazio do gerador.**
"""

# ╔═╡ 666c6610-8d8c-11eb-1f12-536379ec8b3b
md"""
Em vazio a FMMs << FMMd logo o fluxo de excitação série é desprezável, não influenciando a FEM e por conseguinte a tensão de vazio, $$U_0$$.
"""

# ╔═╡ 0b45bb10-8cc4-11eb-2168-9bfabd9aea3b
begin
	H1=("Rexc", @bind Rexc PlutoUI.Slider(Rd:(E₀_1500[2,1]/Iexc[2,1]), default=Rd, show_value=true))
	H1
end

# ╔═╡ 29c3b5f0-8cc5-11eb-3b39-45ba828a66b0
begin
	#plotly()
	plot(Iexc,E₀_1500,title="U₀=f(Id), n=1500rpm", xflip=false, ylims=(0,350), xlabel = "Id(A)", ylabel="U₀(V)", xlims=(0,2), label=false, minorticks=0.1, minorgrid=true)
	plot!(Iexc,Rexc.*Iexc,label="Reta de excitação", legend=:bottomright)
	end

# ╔═╡ 720eea10-8d8c-11eb-0979-1b1316767fba
md"""
Para $$R_c=0Ω$$ verifica-se que a interseção da recta de excitação com a característica magnética se dá em (1.3A; 290V).
"""

# ╔═╡ 74552610-8cc7-11eb-3438-8d5790fb6fa1
md"""
## b)
**Com o interruptor desligado, calcule o valor da q.d.t. devido à reação magnética do induzido, sabendo que nas condições nominais se obtém uma regulação plana.**
"""

# ╔═╡ ba697470-8d77-11eb-01a1-05692e12dad7
md"""
Regulação plana, significa que a tensão em carga, $$U_{c}$$, é igual à tensão de vazio,  $$U_{0}$$. Por conseguinte, a regulação, $$\varepsilon$$, vem dada por:

$$\varepsilon= \frac{U_{0}-U_{c}  }{U_{n} } 100$$
"""

# ╔═╡ 89ab7d70-8cc7-11eb-0e2a-a99ca72b7067
begin
	U₀=Un; Uc=Un;
	reg=100(U₀-Uc)/Un
end;

# ╔═╡ 0d1c74a0-8d79-11eb-06ca-4f9339798195
md"""
Então, $$\varepsilon$$=$(reg)%
"""

# ╔═╡ 632a0760-8cff-11eb-2cbc-5b8728778ab4
Id0=Idc=0.8;

# ╔═╡ 40678f20-8d79-11eb-3ba3-2d7c17b7e853
md"""
Na situação de regulação plana verifica-se que $$I_{dc}=I_{d0}$$. Ou seja, para $$U_{0}=I_{c}=U_{n}$$, tem-se consultando a característica magnética, para $$E_{0}=250$$V, uma $$I_{dc}=I_{d0}$$=$(Id0)A
"""

# ╔═╡ 20c65f10-8d7a-11eb-0554-d3a401d3de0b
md"""
No entanto, o fluxo total da máquina, no ponto de funcionamente em carga, é caracterizado também pela contribuição de fluxo magnético criado no enrolamento de excitação série (montagem de excitação composta com fluxo aditivo). Assim, é necessário verificar a FMM do enrolamento série e a sua contribuição para a FEM, $$E_{0}$$, na situação de carga nominal, no presente caso:

$$I_{exc}=I_{d}+\frac{N_{s}}{N_{d}}I_{s}$$
"""

# ╔═╡ d7c5e840-8d00-11eb-103f-1d4805f37322
begin
	In=Pn/Un
	Ii=In+Idc
	Idserie=Ii*Ns/Nd
	Idserie=round(Idserie, digits=2)
	Iexcₜ=Idc+Idserie
end;

# ╔═╡ 522cbe90-8d7b-11eb-0547-1350c8c001f1
md"""
Verifica-se assim, que o fluxo total (derivação + série) é produzido por uma corrente de excitação equivalente, vista pelo enrolamento $$N_{d}$$ de: $$I_{exc}$$=$(Iexcₜ)A.
"""

# ╔═╡ 8aeb506e-8cc7-11eb-3b1f-53d9e2714ac1
md"""
## c) Influência de $$n$$ e $$R_c$$ em $$U=f(I)$$ 💻
**Com o interruptor desligado explicite qualitativamente a característica exterior do gerador.**

**Qual a variação do ponto de funcionamento da característica externa para uma dada
resistência de carga, nas seguintes situações:**
1. **aumento da velocidade de accionamento;**
2. **diminuição do reóstato de campo derivação.**
"""

# ╔═╡ ae5296e0-8d8f-11eb-2651-e5f054a07785
md"""
!!! info
	No enunciado original é considerado interruptor ligado, o que corrresponde ao gerador de excitação derivação. Nesta versão propõe-se a análise com o interruptor desligado, consequentemente o gerador encontra-se ligado com excitação composta.  \
	Analise a trajetória do ponto de funcionamento (característica externa), actuando na "carga" (corrente).
"""

# ╔═╡ 96ffd350-8ccb-11eb-36f7-b301d582a92d
begin
	H2=("Carga", @bind Icarga PlutoUI.Slider(0:1:In*1.4, default=In/2, show_value=false))
	H3=("Rcampo", @bind Rcampo PlutoUI.Slider(0:1:300, default=100, show_value=true))
	H4=("Velocidade", @bind rpm PlutoUI.Slider(500:2000, default=1500, show_value=true))
	H2, H3, H4
end

# ╔═╡ 56bcde02-8ccb-11eb-3c79-e1d6a15804a2
E₀ₙ=round.((rpm/nₙ).*E₀_1500, digits=1)

# ╔═╡ 457a92d0-8ccc-11eb-2c37-05033ffdb46f
begin
	FMMs=Ns*Icarga
	Id_=Ns*Icarga/Nd
end;

# ╔═╡ 6cbad1f0-8cc9-11eb-3671-892059ad8beb
begin
	I=0:1:60
	Id=0:0.001:2
	xx0=-Id_.+Id
	mxx0=(Rcampo+Rd).*xx0
	y=Icarga*(Ri+Rs).+mxx0
	E0n_i=Spline1D(Iexc,E₀ₙ)
	E0n_ii=E0n_i(Id)
	A=(E0n_ii-y)
	a=findall(i->(-1 < i < 1), A)
	Iex_fluxo=0.001*a[1,1]
	E0n_ex=Spline1D(Iexc,E₀ₙ)
	E0n_fluxo=E0n_ex(Iex_fluxo)
	Id_fluxo=Iex_fluxo-Id_
	U1p=(Rcampo+Rd)*Id_fluxo
	#plots
	P1=plot([Icarga], seriestype = :vline, linecolor=:red, ylabel="U(V)", ylims=(0,400), xlims=(0,60), label=false,linestyle=:dash)
	plot!(I, (Ri+Rs).*I, linewidth=2, linecolor=:green, legend=:none)
	plot!([Icarga*(Ri+Rs)], seriestype=:hline, linecolor=:green, ylims=(0,400), xlims=(0,60), label=false,linestyle=:dash, legend=:none)
	plot!([Icarga], [U1p],markershape=:circle, label=false, legend=:none)
	plot!([U1p], seriestype = :hline, xlims=(0,60),linestyle=:dashdot, linecolor=:purple, legend=:none)
	P2=plot(Iexc,E₀ₙ, xflip=true, ylims=(0,400), ylabel="U₀(V)", xlims=(0,2), linewidth=2, legend=:none)
	plot!(Id, (Rcampo+Rd).*Id, xlims=(0,2),ylims=(0,400), linecolor=:black, linewidth=2, label=false, legend=:none)
	plot!([Id_], seriestype = :vline, ylims=(0,400),linestyle=:dashdot, linewidth=2, linecolor=:red, label="Id_=$(Id_)A")
	plot!([Icarga*(Ri+Rs)], seriestype=:hline, linecolor=:green, ylims=(0,400), xlims=(0,2), label=false,linestyle=:dash, legend=:none)
	plot!(Id, y, linecolor=:black, ylims=(0,400), xlims=(0,2), label=false, linestyle=:dot, linewidth=2)
	plot!([Iex_fluxo], seriestype = :vline, ylims=(0,400),linestyle=:dashdot, linecolor=:purple, legend=:none)
	plot!([Id_fluxo], seriestype = :vline, ylims=(0,400),linestyle=:dashdot, linecolor=:purple, legend=:none)
	plot!([U1p], seriestype = :hline, xlims=(0,2),linestyle=:dashdot, linecolor=:purple, legend=:none)
	P3=plot(Id, Nd.*Id, yflip=true, xflip=true, linewidth=2, ylabel="FMMd(Acond)",xlims=(0,2), ylims=(0,3000), xlabel = "Id(A)", label=false, legend=:none)
	plot!([FMMs], seriestype=:hline, ylims=(0,3000), linecolor=:red, linestyle=:dash, label=false,legend=:none)
	plot!([Id_], seriestype = :vline, ylims=(0,3000),linestyle=:dashdot, linewidth=2, linecolor=:red,label=false, legend=:none)
	#plot!([Icarga], seriestype = :vline, xlabel = "I(A)", ylims=(0,3000), label=false,linestyle=:dash)

	P4=plot(I, Ns.*I, yflip=true, linewidth=2, ylabel="FMMs(Acond)",xlims=(0,60), label=false, legend=:none)
	plot!([FMMs], seriestype = :hline, ylims=(0,3000), linecolor=:red, linestyle=:dash, label=false)
	plot!([Icarga], seriestype = :vline, xlabel = "I(A)", ylims=(0,3000), label=false,linestyle=:dash, linecolor=:red, legend=:none)
	plot(P2, P1, P3, P4, layout = (2, 2))
end

# ╔═╡ f9817760-8d00-11eb-1611-377bc26b25bb
begin
	E0_est=Spline1D(Iexc,E₀_1500)
	E0_carga=E0n_i(Iexcₜ)
	E0_carga=round(E0_carga, digits=1)
end;

# ╔═╡ ada1fba0-8d7b-11eb-3ae0-6553fa34863e
md"""
Consultando a característica magnética verifica-se para $$I_{exc}$$ = $(Iexcₜ)A, uma FEM em carga de:

   $$E_{0}$$ = $(E0_carga)V"""

# ╔═╡ 4a66bc70-8d02-11eb-0534-b9a896d03598
begin
	ΔUₜ=E0_carga-Uc
	ΔE=ΔUₜ-(Ri+Rs)Ii
	ΔE=round(ΔE, digits=1)
end;

# ╔═╡ 98e72b80-8d7c-11eb-0848-330bcfa4e60e
md"""
Queda de tensão total dada por: $$\Delta U_t=E_0-U_c$$, permite por decomposição das q.d.t. presentes na máquina, determinar a q.d.t. devido à reacção magnética do induzido, com $$\Delta{E}$$:

$$\Delta{E}=\Delta U_{t}-\Delta U_{r}-\Delta U_{esc}$$
Na presente montagem (longa derivação), $$\Delta U_r=(R_i+R_s)I_i$$   e   $$\Delta U_{esc} \simeq {0}$$.

Resolvendo, obtém-se: $$\Delta {E}$$ = $(ΔE)V.
"""

# ╔═╡ 052779bc-3fb2-4482-83cd-e7113726e597

# ╔═╡ d3e64e5a-19ac-4858-b0d1-118e4fd40f16
md"""
# Setup
"""

# ╔═╡ a7f8c518-ea6c-4aab-b117-86fdbfba1414
TableOfContents(title="📚 Índice, Exercício 4")

# ╔═╡ 7c6183ee-93bc-4797-a92e-8c8c6f4be07c
md"""
!!! info
	No índice deste *notebook*, os tópicos assinalados com "💻" permitem interacção com o utilizador.
"""

# ╔═╡ 1984de4e-a917-441a-9617-bb5e6e4c69b8
md"""
## _Julia packages_
*Links to package help*: [Dierckx](https://github.com/kbarbary/Dierckx.jl), [Plots](http://docs.juliaplots.org/latest/), [PlutoUI](https://juliahub.com/docs/PlutoUI/abXFp/0.7.6/)
"""

# ╔═╡ bf6ede73-b315-4d89-a39c-10190c83fbc3
md"""
!!! info
	## Programação _Julia_ e _notebooks Pluto_
	Saber mais sobre: [_Julia_/_Pluto_](https://github.com/Ricardo-Luis/notebooks/blob/main/ME2/README.md)
"""

# ╔═╡ e618fc88-0095-46cb-a353-4098950a2f49
version=VERSION;

# ╔═╡ dbf9d2bc-a925-4649-94bd-2bf2a184fb6e
md"""
## _Notebook_

*Notebook* realizado em linguagem de programação *Julia* versão $(version) para a unidade curricular de Máquinas Elétricas 2 (ISEL\LEE) \
**Ricardo Luís** (Professor Adjunto, ISEL\DEEEA\GDME) \
ISEL, 12/Out/2021
"""

# ╔═╡ 91e58ccc-54a3-48f1-b70c-29a2cf0492aa
md"""
Este conteúdo possui licença [![](https://img.shields.io/badge/License-CC%20BY--SA%204.0-lightgrey.svg)](http://creativecommons.org/licenses/by-sa/4.0/).
"""

# ╔═╡ 00000000-0000-0000-0000-000000000001
PLUTO_PROJECT_TOML_CONTENTS = """
[deps]
Dierckx = "39dd38d3-220a-591b-8e3c-4c3a8c710a94"
Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
PlutoUI = "7f904dfe-b85e-4ff6-b463-dae2292396a8"

[compat]
Dierckx = "~0.5.1"
Plots = "~1.22.4"
PlutoUI = "~0.7.15"
"""

# ╔═╡ 00000000-0000-0000-0000-000000000002
PLUTO_MANIFEST_TOML_CONTENTS = """
# This file is machine-generated - editing it directly is not advised

[[Adapt]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "84918055d15b3114ede17ac6a7182f68870c16f7"
uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
version = "3.3.1"

[[ArgTools]]
uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"

[[Artifacts]]
uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"

[[Base64]]
uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

[[Bzip2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "19a35467a82e236ff51bc17a3a44b69ef35185a2"
uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0"
version = "1.0.8+0"

[[Cairo_jll]]
deps = ["Artifacts", "Bzip2_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"]
git-tree-sha1 = "f2202b55d816427cd385a9a4f3ffb226bee80f99"
uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a"
version = "1.16.1+0"

[[ColorSchemes]]
deps = ["ColorTypes", "Colors", "FixedPointNumbers", "Random"]
git-tree-sha1 = "a851fec56cb73cfdf43762999ec72eff5b86882a"
uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4"
version = "3.15.0"

[[ColorTypes]]
deps = ["FixedPointNumbers", "Random"]
git-tree-sha1 = "024fe24d83e4a5bf5fc80501a314ce0d1aa35597"
uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f"
version = "0.11.0"

[[Colors]]
deps = ["ColorTypes", "FixedPointNumbers", "Reexport"]
git-tree-sha1 = "417b0ed7b8b838aa6ca0a87aadf1bb9eb111ce40"
uuid = "5ae59095-9a9b-59fe-a467-6f913c188581"
version = "0.12.8"

[[Compat]]
deps = ["Base64", "Dates", "DelimitedFiles", "Distributed", "InteractiveUtils", "LibGit2", "Libdl", "LinearAlgebra", "Markdown", "Mmap", "Pkg", "Printf", "REPL", "Random", "SHA", "Serialization", "SharedArrays", "Sockets", "SparseArrays", "Statistics", "Test", "UUIDs", "Unicode"]
git-tree-sha1 = "31d0151f5716b655421d9d75b7fa74cc4e744df2"
uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
version = "3.39.0"

[[CompilerSupportLibraries_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"

[[Contour]]
deps = ["StaticArrays"]
git-tree-sha1 = "9f02045d934dc030edad45944ea80dbd1f0ebea7"
uuid = "d38c429a-6771-53c6-b99e-75d170b6e991"
version = "0.5.7"

[[DataAPI]]
git-tree-sha1 = "cc70b17275652eb47bc9e5f81635981f13cea5c8"
uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
version = "1.9.0"

[[DataStructures]]
deps = ["Compat", "InteractiveUtils", "OrderedCollections"]
git-tree-sha1 = "7d9d316f04214f7efdbb6398d545446e246eff02"
uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
version = "0.18.10"

[[DataValueInterfaces]]
git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6"
uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464"
version = "1.0.0"

[[Dates]]
deps = ["Printf"]
uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"

[[DelimitedFiles]]
deps = ["Mmap"]
uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"

[[Dierckx]]
deps = ["Dierckx_jll"]
git-tree-sha1 = "5fefbe52e9a6e55b8f87cb89352d469bd3a3a090"
uuid = "39dd38d3-220a-591b-8e3c-4c3a8c710a94"
version = "0.5.1"

[[Dierckx_jll]]
deps = ["CompilerSupportLibraries_jll", "Libdl", "Pkg"]
git-tree-sha1 = "a580560f526f6fc6973e8bad2b036514a4e3b013"
uuid = "cd4c43a9-7502-52ba-aa6d-59fb2a88580b"
version = "0.0.1+0"

[[Distributed]]
deps = ["Random", "Serialization", "Sockets"]
uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b"

[[Downloads]]
deps = ["ArgTools", "LibCURL", "NetworkOptions"]
uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"

[[EarCut_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "3f3a2501fa7236e9b911e0f7a588c657e822bb6d"
uuid = "5ae413db-bbd1-5e63-b57d-d24a61df00f5"
version = "2.2.3+0"

[[Expat_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b3bfd02e98aedfa5cf885665493c5598c350cd2f"
uuid = "2e619515-83b5-522b-bb60-26c02a35a201"
version = "2.2.10+0"

[[FFMPEG]]
deps = ["FFMPEG_jll"]
git-tree-sha1 = "b57e3acbe22f8484b4b5ff66a7499717fe1a9cc8"
uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a"
version = "0.4.1"

[[FFMPEG_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "Pkg", "Zlib_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"]
git-tree-sha1 = "d8a578692e3077ac998b50c0217dfd67f21d1e5f"
uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5"
version = "4.4.0+0"

[[FixedPointNumbers]]
deps = ["Statistics"]
git-tree-sha1 = "335bfdceacc84c5cdf16aadc768aa5ddfc5383cc"
uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
version = "0.8.4"

[[Fontconfig_jll]]
deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "21efd19106a55620a188615da6d3d06cd7f6ee03"
uuid = "a3f928ae-7b40-5064-980b-68af3947d34b"
version = "2.13.93+0"

[[Formatting]]
deps = ["Printf"]
git-tree-sha1 = "8339d61043228fdd3eb658d86c926cb282ae72a8"
uuid = "59287772-0a20-5a39-b81b-1366585eb4c0"
version = "0.4.2"

[[FreeType2_jll]]
deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "87eb71354d8ec1a96d4a7636bd57a7347dde3ef9"
uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7"
version = "2.10.4+0"

[[FriBidi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "aa31987c2ba8704e23c6c8ba8a4f769d5d7e4f91"
uuid = "559328eb-81f9-559d-9380-de523a88c83c"
version = "1.0.10+0"

[[GLFW_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libglvnd_jll", "Pkg", "Xorg_libXcursor_jll", "Xorg_libXi_jll", "Xorg_libXinerama_jll", "Xorg_libXrandr_jll"]
git-tree-sha1 = "dba1e8614e98949abfa60480b13653813d8f0157"
uuid = "0656b61e-2033-5cc2-a64a-77c0f6c09b89"
version = "3.3.5+0"

[[GR]]
deps = ["Base64", "DelimitedFiles", "GR_jll", "HTTP", "JSON", "Libdl", "LinearAlgebra", "Pkg", "Printf", "Random", "Serialization", "Sockets", "Test", "UUIDs"]
git-tree-sha1 = "c2178cfbc0a5a552e16d097fae508f2024de61a3"
uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71"
version = "0.59.0"

[[GR_jll]]
deps = ["Artifacts", "Bzip2_jll", "Cairo_jll", "FFMPEG_jll", "Fontconfig_jll", "GLFW_jll", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Libtiff_jll", "Pixman_jll", "Pkg", "Qt5Base_jll", "Zlib_jll", "libpng_jll"]
git-tree-sha1 = "cafe0823979a5c9bff86224b3b8de29ea5a44b2e"
uuid = "d2c73de3-f751-5644-a686-071e5b155ba9"
version = "0.61.0+0"

[[GeometryBasics]]
deps = ["EarCut_jll", "IterTools", "LinearAlgebra", "StaticArrays", "StructArrays", "Tables"]
git-tree-sha1 = "58bcdf5ebc057b085e58d95c138725628dd7453c"
uuid = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
version = "0.4.1"

[[Gettext_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "XML2_jll"]
git-tree-sha1 = "9b02998aba7bf074d14de89f9d37ca24a1a0b046"
uuid = "78b55507-aeef-58d4-861c-77aaff3498b1"
version = "0.21.0+0"

[[Glib_jll]]
deps = ["Artifacts", "Gettext_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "7bf67e9a481712b3dbe9cb3dac852dc4b1162e02"
uuid = "7746bdde-850d-59dc-9ae8-88ece973131d"
version = "2.68.3+0"

[[Graphite2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "344bf40dcab1073aca04aa0df4fb092f920e4011"
uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472"
version = "1.3.14+0"

[[Grisu]]
git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2"
uuid = "42e2da0e-8278-4e71-bc24-59509adca0fe"
version = "1.0.2"

[[HTTP]]
deps = ["Base64", "Dates", "IniFile", "Logging", "MbedTLS", "NetworkOptions", "Sockets", "URIs"]
git-tree-sha1 = "14eece7a3308b4d8be910e265c724a6ba51a9798"
uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3"
version = "0.9.16"

[[HarfBuzz_jll]]
deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg"]
git-tree-sha1 = "8a954fed8ac097d5be04921d595f741115c1b2ad"
uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566"
version = "2.8.1+0"

[[Hyperscript]]
deps = ["Test"]
git-tree-sha1 = "8d511d5b81240fc8e6802386302675bdf47737b9"
uuid = "47d2ed2b-36de-50cf-bf87-49c2cf4b8b91"
version = "0.0.4"

[[HypertextLiteral]]
git-tree-sha1 = "f6532909bf3d40b308a0f360b6a0e626c0e263a8"
uuid = "ac1192a8-f4b3-4bfe-ba22-af5b92cd3ab2"
version = "0.9.1"

[[IOCapture]]
deps = ["Logging", "Random"]
git-tree-sha1 = "f7be53659ab06ddc986428d3a9dcc95f6fa6705a"
uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89"
version = "0.2.2"

[[IniFile]]
deps = ["Test"]
git-tree-sha1 = "098e4d2c533924c921f9f9847274f2ad89e018b8"
uuid = "83e8ac13-25f8-5344-8a64-a9f2b223428f"
version = "0.5.0"

[[InteractiveUtils]]
deps = ["Markdown"]
uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"

[[IterTools]]
git-tree-sha1 = "05110a2ab1fc5f932622ffea2a003221f4782c18"
uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
version = "1.3.0"

[[IteratorInterfaceExtensions]]
git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856"
uuid = "82899510-4779-5014-852e-03e436cf321d"
version = "1.0.0"

[[JLLWrappers]]
deps = ["Preferences"]
git-tree-sha1 = "642a199af8b68253517b80bd3bfd17eb4e84df6e"
uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"
version = "1.3.0"

[[JSON]]
deps = ["Dates", "Mmap", "Parsers", "Unicode"]
git-tree-sha1 = "8076680b162ada2a031f707ac7b4953e30667a37"
uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
version = "0.21.2"

[[JpegTurbo_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "d735490ac75c5cb9f1b00d8b5509c11984dc6943"
uuid = "aacddb02-875f-59d6-b918-886e6ef4fbf8"
version = "2.1.0+0"

[[LAME_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "f6250b16881adf048549549fba48b1161acdac8c"
uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d"
version = "3.100.1+0"

[[LZO_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "e5b909bcf985c5e2605737d2ce278ed791b89be6"
uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac"
version = "2.10.1+0"

[[LaTeXStrings]]
git-tree-sha1 = "c7f1c695e06c01b95a67f0cd1d34994f3e7db104"
uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
version = "1.2.1"

[[Latexify]]
deps = ["Formatting", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "Printf", "Requires"]
git-tree-sha1 = "a4b12a1bd2ebade87891ab7e36fdbce582301a92"
uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316"
version = "0.15.6"

[[LibCURL]]
deps = ["LibCURL_jll", "MozillaCACerts_jll"]
uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"

[[LibCURL_jll]]
deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"

[[LibGit2]]
deps = ["Base64", "NetworkOptions", "Printf", "SHA"]
uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"

[[LibSSH2_jll]]
deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8"

[[Libdl]]
uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

[[Libffi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "761a393aeccd6aa92ec3515e428c26bf99575b3b"
uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490"
version = "3.2.2+0"

[[Libgcrypt_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgpg_error_jll", "Pkg"]
git-tree-sha1 = "64613c82a59c120435c067c2b809fc61cf5166ae"
uuid = "d4300ac3-e22c-5743-9152-c294e39db1e4"
version = "1.8.7+0"

[[Libglvnd_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll", "Xorg_libXext_jll"]
git-tree-sha1 = "7739f837d6447403596a75d19ed01fd08d6f56bf"
uuid = "7e76a0d4-f3c7-5321-8279-8d96eeed0f29"
version = "1.3.0+3"

[[Libgpg_error_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "c333716e46366857753e273ce6a69ee0945a6db9"
uuid = "7add5ba3-2f88-524e-9cd5-f83b8a55f7b8"
version = "1.42.0+0"

[[Libiconv_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "42b62845d70a619f063a7da093d995ec8e15e778"
uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531"
version = "1.16.1+1"

[[Libmount_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "9c30530bf0effd46e15e0fdcf2b8636e78cbbd73"
uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9"
version = "2.35.0+0"

[[Libtiff_jll]]
deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Pkg", "Zlib_jll", "Zstd_jll"]
git-tree-sha1 = "340e257aada13f95f98ee352d316c3bed37c8ab9"
uuid = "89763e89-9b03-5906-acba-b20f662cd828"
version = "4.3.0+0"

[[Libuuid_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "7f3efec06033682db852f8b3bc3c1d2b0a0ab066"
uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700"
version = "2.36.0+0"

[[LinearAlgebra]]
deps = ["Libdl"]
uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

[[Logging]]
uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"

[[MacroTools]]
deps = ["Markdown", "Random"]
git-tree-sha1 = "5a5bc6bf062f0f95e62d0fe0a2d99699fed82dd9"
uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
version = "0.5.8"

[[Markdown]]
deps = ["Base64"]
uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"

[[MbedTLS]]
deps = ["Dates", "MbedTLS_jll", "Random", "Sockets"]
git-tree-sha1 = "1c38e51c3d08ef2278062ebceade0e46cefc96fe"
uuid = "739be429-bea8-5141-9913-cc70e7f3736d"
version = "1.0.3"

[[MbedTLS_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"

[[Measures]]
git-tree-sha1 = "e498ddeee6f9fdb4551ce855a46f54dbd900245f"
uuid = "442fdcdd-2543-5da2-b0f3-8c86c306513e"
version = "0.3.1"

[[Missings]]
deps = ["DataAPI"]
git-tree-sha1 = "bf210ce90b6c9eed32d25dbcae1ebc565df2687f"
uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28"
version = "1.0.2"

[[Mmap]]
uuid = "a63ad114-7e13-5084-954f-fe012c677804"

[[MozillaCACerts_jll]]
uuid = "14a3606d-f60d-562e-9121-12d972cd8159"

[[NaNMath]]
git-tree-sha1 = "bfe47e760d60b82b66b61d2d44128b62e3a369fb"
uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
version = "0.3.5"

[[NetworkOptions]]
uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"

[[Ogg_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "7937eda4681660b4d6aeeecc2f7e1c81c8ee4e2f"
uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051"
version = "1.3.5+0"

[[OpenSSL_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "15003dcb7d8db3c6c857fda14891a539a8f2705a"
uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95"
version = "1.1.10+0"

[[Opus_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "51a08fb14ec28da2ec7a927c4337e4332c2a4720"
uuid = "91d4177d-7536-5919-b921-800302f37372"
version = "1.3.2+0"

[[OrderedCollections]]
git-tree-sha1 = "85f8e6578bf1f9ee0d11e7bb1b1456435479d47c"
uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
version = "1.4.1"

[[PCRE_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b2a7af664e098055a7529ad1a900ded962bca488"
uuid = "2f80f16e-611a-54ab-bc61-aa92de5b98fc"
version = "8.44.0+0"

[[Parsers]]
deps = ["Dates"]
git-tree-sha1 = "a8709b968a1ea6abc2dc1967cb1db6ac9a00dfb6"
uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
version = "2.0.5"

[[Pixman_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b4f5d02549a10e20780a24fce72bea96b6329e29"
uuid = "30392449-352a-5448-841d-b1acce4e97dc"
version = "0.40.1+0"

[[Pkg]]
deps = ["Artifacts", "Dates", "Downloads", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"

[[PlotThemes]]
deps = ["PlotUtils", "Requires", "Statistics"]
git-tree-sha1 = "a3a964ce9dc7898193536002a6dd892b1b5a6f1d"
uuid = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a"
version = "2.0.1"

[[PlotUtils]]
deps = ["ColorSchemes", "Colors", "Dates", "Printf", "Random", "Reexport", "Statistics"]
git-tree-sha1 = "b084324b4af5a438cd63619fd006614b3b20b87b"
uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043"
version = "1.0.15"

[[Plots]]
deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "GeometryBasics", "JSON", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "PlotThemes", "PlotUtils", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs"]
git-tree-sha1 = "6841db754bd01a91d281370d9a0f8787e220ae08"
uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
version = "1.22.4"

[[PlutoUI]]
deps = ["Base64", "Dates", "Hyperscript", "HypertextLiteral", "IOCapture", "InteractiveUtils", "JSON", "Logging", "Markdown", "Random", "Reexport", "UUIDs"]
git-tree-sha1 = "633f8a37c47982bff23461db0076a33787b17ecd"
uuid = "7f904dfe-b85e-4ff6-b463-dae2292396a8"
version = "0.7.15"

[[Preferences]]
deps = ["TOML"]
git-tree-sha1 = "00cfd92944ca9c760982747e9a1d0d5d86ab1e5a"
uuid = "21216c6a-2e73-6563-6e65-726566657250"
version = "1.2.2"

[[Printf]]
deps = ["Unicode"]
uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"

[[Qt5Base_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "Fontconfig_jll", "Glib_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "OpenSSL_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libxcb_jll", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_keysyms_jll", "Xorg_xcb_util_renderutil_jll", "Xorg_xcb_util_wm_jll", "Zlib_jll", "xkbcommon_jll"]
git-tree-sha1 = "ad368663a5e20dbb8d6dc2fddeefe4dae0781ae8"
uuid = "ea2cea3b-5b76-57ae-a6ef-0a8af62496e1"
version = "5.15.3+0"

[[REPL]]
deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"

[[Random]]
deps = ["Serialization"]
uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"

[[RecipesBase]]
git-tree-sha1 = "44a75aa7a527910ee3d1751d1f0e4148698add9e"
uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
version = "1.1.2"

[[RecipesPipeline]]
deps = ["Dates", "NaNMath", "PlotUtils", "RecipesBase"]
git-tree-sha1 = "7ad0dfa8d03b7bcf8c597f59f5292801730c55b8"
uuid = "01d81517-befc-4cb6-b9ec-a95719d0359c"
version = "0.4.1"

[[Reexport]]
git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b"
uuid = "189a3867-3050-52da-a836-e630ba90ab69"
version = "1.2.2"

[[Requires]]
deps = ["UUIDs"]
git-tree-sha1 = "4036a3bd08ac7e968e27c203d45f5fff15020621"
uuid = "ae029012-a4dd-5104-9daa-d747884805df"
version = "1.1.3"

[[SHA]]
uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"

[[Scratch]]
deps = ["Dates"]
git-tree-sha1 = "0b4b7f1393cff97c33891da2a0bf69c6ed241fda"
uuid = "6c6a2e73-6563-6170-7368-637461726353"
version = "1.1.0"

[[Serialization]]
uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"

[[SharedArrays]]
deps = ["Distributed", "Mmap", "Random", "Serialization"]
uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383"

[[Showoff]]
deps = ["Dates", "Grisu"]
git-tree-sha1 = "91eddf657aca81df9ae6ceb20b959ae5653ad1de"
uuid = "992d4aef-0814-514b-bc4d-f2e9a6c4116f"
version = "1.0.3"

[[Sockets]]
uuid = "6462fe0b-24de-5631-8697-dd941f90decc"

[[SortingAlgorithms]]
deps = ["DataStructures"]
git-tree-sha1 = "b3363d7460f7d098ca0912c69b082f75625d7508"
uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c"
version = "1.0.1"

[[SparseArrays]]
deps = ["LinearAlgebra", "Random"]
uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"

[[StaticArrays]]
deps = ["LinearAlgebra", "Random", "Statistics"]
git-tree-sha1 = "3c76dde64d03699e074ac02eb2e8ba8254d428da"
uuid = "90137ffa-7385-5640-81b9-e52037218182"
version = "1.2.13"

[[Statistics]]
deps = ["LinearAlgebra", "SparseArrays"]
uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"

[[StatsAPI]]
git-tree-sha1 = "1958272568dc176a1d881acb797beb909c785510"
uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0"
version = "1.0.0"

[[StatsBase]]
deps = ["DataAPI", "DataStructures", "LinearAlgebra", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"]
git-tree-sha1 = "8cbbc098554648c84f79a463c9ff0fd277144b6c"
uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
version = "0.33.10"

[[StructArrays]]
deps = ["Adapt", "DataAPI", "StaticArrays", "Tables"]
git-tree-sha1 = "2ce41e0d042c60ecd131e9fb7154a3bfadbf50d3"
uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"
version = "0.6.3"

[[TOML]]
deps = ["Dates"]
uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"

[[TableTraits]]
deps = ["IteratorInterfaceExtensions"]
git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39"
uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c"
version = "1.0.1"

[[Tables]]
deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "TableTraits", "Test"]
git-tree-sha1 = "fed34d0e71b91734bf0a7e10eb1bb05296ddbcd0"
uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
version = "1.6.0"

[[Tar]]
deps = ["ArgTools", "SHA"]
uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"

[[Test]]
deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

[[URIs]]
git-tree-sha1 = "97bbe755a53fe859669cd907f2d96aee8d2c1355"
uuid = "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4"
version = "1.3.0"

[[UUIDs]]
deps = ["Random", "SHA"]
uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"

[[Unicode]]
uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"

[[Wayland_jll]]
deps = ["Artifacts", "Expat_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg", "XML2_jll"]
git-tree-sha1 = "3e61f0b86f90dacb0bc0e73a0c5a83f6a8636e23"
uuid = "a2964d1f-97da-50d4-b82a-358c7fce9d89"
version = "1.19.0+0"

[[Wayland_protocols_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Wayland_jll"]
git-tree-sha1 = "2839f1c1296940218e35df0bbb220f2a79686670"
uuid = "2381bf8a-dfd0-557d-9999-79630e7b1b91"
version = "1.18.0+4"

[[XML2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "1acf5bdf07aa0907e0a37d3718bb88d4b687b74a"
uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a"
version = "2.9.12+0"

[[XSLT_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgcrypt_jll", "Libgpg_error_jll", "Libiconv_jll", "Pkg", "XML2_jll", "Zlib_jll"]
git-tree-sha1 = "91844873c4085240b95e795f692c4cec4d805f8a"
uuid = "aed1982a-8fda-507f-9586-7b0439959a61"
version = "1.1.34+0"

[[Xorg_libX11_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll", "Xorg_xtrans_jll"]
git-tree-sha1 = "5be649d550f3f4b95308bf0183b82e2582876527"
uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc"
version = "1.6.9+4"

[[Xorg_libXau_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4e490d5c960c314f33885790ed410ff3a94ce67e"
uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec"
version = "1.0.9+4"

[[Xorg_libXcursor_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXfixes_jll", "Xorg_libXrender_jll"]
git-tree-sha1 = "12e0eb3bc634fa2080c1c37fccf56f7c22989afd"
uuid = "935fb764-8cf2-53bf-bb30-45bb1f8bf724"
version = "1.2.0+4"

[[Xorg_libXdmcp_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4fe47bd2247248125c428978740e18a681372dd4"
uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05"
version = "1.1.3+4"

[[Xorg_libXext_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "b7c0aa8c376b31e4852b360222848637f481f8c3"
uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3"
version = "1.3.4+4"

[[Xorg_libXfixes_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "0e0dc7431e7a0587559f9294aeec269471c991a4"
uuid = "d091e8ba-531a-589c-9de9-94069b037ed8"
version = "5.0.3+4"

[[Xorg_libXi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXfixes_jll"]
git-tree-sha1 = "89b52bc2160aadc84d707093930ef0bffa641246"
uuid = "a51aa0fd-4e3c-5386-b890-e753decda492"
version = "1.7.10+4"

[[Xorg_libXinerama_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll"]
git-tree-sha1 = "26be8b1c342929259317d8b9f7b53bf2bb73b123"
uuid = "d1454406-59df-5ea1-beac-c340f2130bc3"
version = "1.1.4+4"

[[Xorg_libXrandr_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll"]
git-tree-sha1 = "34cea83cb726fb58f325887bf0612c6b3fb17631"
uuid = "ec84b674-ba8e-5d96-8ba1-2a689ba10484"
version = "1.5.2+4"

[[Xorg_libXrender_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "19560f30fd49f4d4efbe7002a1037f8c43d43b96"
uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa"
version = "0.9.10+4"

[[Xorg_libpthread_stubs_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "6783737e45d3c59a4a4c4091f5f88cdcf0908cbb"
uuid = "14d82f49-176c-5ed1-bb49-ad3f5cbd8c74"
version = "0.1.0+3"

[[Xorg_libxcb_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "XSLT_jll", "Xorg_libXau_jll", "Xorg_libXdmcp_jll", "Xorg_libpthread_stubs_jll"]
git-tree-sha1 = "daf17f441228e7a3833846cd048892861cff16d6"
uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b"
version = "1.13.0+3"

[[Xorg_libxkbfile_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "926af861744212db0eb001d9e40b5d16292080b2"
uuid = "cc61e674-0454-545c-8b26-ed2c68acab7a"
version = "1.1.0+4"

[[Xorg_xcb_util_image_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "0fab0a40349ba1cba2c1da699243396ff8e94b97"
uuid = "12413925-8142-5f55-bb0e-6d7ca50bb09b"
version = "0.4.0+1"

[[Xorg_xcb_util_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll"]
git-tree-sha1 = "e7fd7b2881fa2eaa72717420894d3938177862d1"
uuid = "2def613f-5ad1-5310-b15b-b15d46f528f5"
version = "0.4.0+1"

[[Xorg_xcb_util_keysyms_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "d1151e2c45a544f32441a567d1690e701ec89b00"
uuid = "975044d2-76e6-5fbe-bf08-97ce7c6574c7"
version = "0.4.0+1"

[[Xorg_xcb_util_renderutil_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "dfd7a8f38d4613b6a575253b3174dd991ca6183e"
uuid = "0d47668e-0667-5a69-a72c-f761630bfb7e"
version = "0.3.9+1"

[[Xorg_xcb_util_wm_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "e78d10aab01a4a154142c5006ed44fd9e8e31b67"
uuid = "c22f9ab0-d5fe-5066-847c-f4bb1cd4e361"
version = "0.4.1+1"

[[Xorg_xkbcomp_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxkbfile_jll"]
git-tree-sha1 = "4bcbf660f6c2e714f87e960a171b119d06ee163b"
uuid = "35661453-b289-5fab-8a00-3d9160c6a3a4"
version = "1.4.2+4"

[[Xorg_xkeyboard_config_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xkbcomp_jll"]
git-tree-sha1 = "5c8424f8a67c3f2209646d4425f3d415fee5931d"
uuid = "33bec58e-1273-512f-9401-5d533626f822"
version = "2.27.0+4"

[[Xorg_xtrans_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "79c31e7844f6ecf779705fbc12146eb190b7d845"
uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10"
version = "1.4.0+3"

[[Zlib_jll]]
deps = ["Libdl"]
uuid = "83775a58-1f1d-513f-b197-d71354ab007a"

[[Zstd_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "cc4bf3fdde8b7e3e9fa0351bdeedba1cf3b7f6e6"
uuid = "3161d3a3-bdf6-5164-811a-617609db77b4"
version = "1.5.0+0"

[[libass_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "5982a94fcba20f02f42ace44b9894ee2b140fe47"
uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0"
version = "0.15.1+0"

[[libfdk_aac_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "daacc84a041563f965be61859a36e17c4e4fcd55"
uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280"
version = "2.0.2+0"

[[libpng_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "94d180a6d2b5e55e447e2d27a29ed04fe79eb30c"
uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f"
version = "1.6.38+0"

[[libvorbis_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll", "Pkg"]
git-tree-sha1 = "c45f4e40e7aafe9d086379e5578947ec8b95a8fb"
uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a"
version = "1.3.7+0"

[[nghttp2_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"

[[p7zip_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"

[[x264_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4fea590b89e6ec504593146bf8b988b2c00922b2"
uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a"
version = "2021.5.5+0"

[[x265_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "ee567a171cce03570d77ad3a43e90218e38937a9"
uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76"
version = "3.5.0+0"

[[xkbcommon_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Wayland_jll", "Wayland_protocols_jll", "Xorg_libxcb_jll", "Xorg_xkeyboard_config_jll"]
git-tree-sha1 = "ece2350174195bb31de1a63bea3a41ae1aa593b6"
uuid = "d8fb68d0-12a3-5cfd-a85a-d49703b185fd"
version = "0.9.1+5"
"""

# ╔═╡ Cell order:
# ╟─a417311b-4195-46ad-b106-a8f82057d292
# ╟─2d599785-a7a3-4e46-8394-276c444c2749
# ╟─8b049710-8cc2-11eb-33cf-ef396ec1944e
# ╠═70dcec10-8cc3-11eb-0ce1-15f38b9fb0f9
# ╠═0786377e-8cc3-11eb-1413-e90fac064ffd
# ╟─caeb9440-8cc3-11eb-0a47-e32ddfbb60df
# ╟─f2e30e10-8cc3-11eb-3254-09eecb58cdd7
# ╟─666c6610-8d8c-11eb-1f12-536379ec8b3b
# ╟─0b45bb10-8cc4-11eb-2168-9bfabd9aea3b
# ╟─29c3b5f0-8cc5-11eb-3b39-45ba828a66b0
# ╟─720eea10-8d8c-11eb-0979-1b1316767fba
# ╟─74552610-8cc7-11eb-3438-8d5790fb6fa1
# ╟─ba697470-8d77-11eb-01a1-05692e12dad7
# ╟─0d1c74a0-8d79-11eb-06ca-4f9339798195
# ╠═89ab7d70-8cc7-11eb-0e2a-a99ca72b7067
# ╟─40678f20-8d79-11eb-3ba3-2d7c17b7e853
# ╠═632a0760-8cff-11eb-2cbc-5b8728778ab4
# ╟─20c65f10-8d7a-11eb-0554-d3a401d3de0b
# ╟─522cbe90-8d7b-11eb-0547-1350c8c001f1
# ╠═d7c5e840-8d00-11eb-103f-1d4805f37322
# ╟─ada1fba0-8d7b-11eb-3ae0-6553fa34863e
# ╠═f9817760-8d00-11eb-1611-377bc26b25bb
# ╟─98e72b80-8d7c-11eb-0848-330bcfa4e60e
# ╠═4a66bc70-8d02-11eb-0534-b9a896d03598
# ╟─8aeb506e-8cc7-11eb-3b1f-53d9e2714ac1
# ╟─ae5296e0-8d8f-11eb-2651-e5f054a07785
# ╠═56bcde02-8ccb-11eb-3c79-e1d6a15804a2
# ╟─96ffd350-8ccb-11eb-36f7-b301d582a92d
# ╟─457a92d0-8ccc-11eb-2c37-05033ffdb46f
# ╟─6cbad1f0-8cc9-11eb-3671-892059ad8beb
# ╟─052779bc-3fb2-4482-83cd-e7113726e597
# ╟─d3e64e5a-19ac-4858-b0d1-118e4fd40f16
# ╠═a7f8c518-ea6c-4aab-b117-86fdbfba1414
# ╟─7c6183ee-93bc-4797-a92e-8c8c6f4be07c
# ╟─1984de4e-a917-441a-9617-bb5e6e4c69b8
# ╠═af807a43-e828-46e5-b50a-8da60591dec2
# ╟─bf6ede73-b315-4d89-a39c-10190c83fbc3
# ╟─dbf9d2bc-a925-4649-94bd-2bf2a184fb6e
# ╟─e618fc88-0095-46cb-a353-4098950a2f49
# ╟─91e58ccc-54a3-48f1-b70c-29a2cf0492aa
# ╟─00000000-0000-0000-0000-000000000001
# ╟─00000000-0000-0000-0000-000000000002

max_stars_repo_name: Ricardo-Luis/notebooks

max_issues_repo_name: Ricardo-Luis/notebooks

max_forks_repo_name: Ricardo-Luis/notebooks


text:
using SpaceGroups
using Test

@testset "SpaceGroups.jl" begin
    include("ico.jl")
end

ext: jl


text:
## rd_kafka_topic_conf_t

function kafka_topic_conf_new()
    return ccall((:rd_kafka_topic_conf_new, LIBRDKAFKA), Ptr{Cvoid}, ())
end

function kafka_topic_conf_destroy(conf::Ptr{Cvoid})
    ccall((:rd_kafka_topic_conf_destroy, LIBRDKAFKA), Cvoid, (Ptr{Cvoid},), conf)
end

function kafka_topic_conf_set(conf::Ptr{Cvoid}, key::String, val::String)
    err_str = Array{UInt8}(undef, 512)
    return ccall((:rd_kafka_topic_conf_set, LIBRDKAFKA), Cvoid,
                 (Ptr{Cvoid}, Cstring, Cstring, Ptr{UInt8}, Csize_t),
                 conf, key, val, pointer(err_str), sizeof(err_str))
end

function kafka_topic_conf_get(conf::Ptr{Cvoid}, key::String)
    dest = Array{UInt8}(undef, 512)
    sz_ref = Ref{Csize_t}(0)
    ccall((:rd_kafka_topic_conf_get, LIBRDKAFKA), Cvoid,
          (Ptr{Cvoid}, Cstring, Ptr{UInt8}, Ptr{Csize_t}),
          conf, key, pointer(dest), sz_ref)
    return unsafe_string(pointer(dest))
end

# rd_kafka_topic_t

function kafka_topic_new(rk::Ptr{Cvoid}, topic::String, topic_conf::Ptr{Cvoid})
    return ccall((:rd_kafka_topic_new, LIBRDKAFKA), Ptr{Cvoid},
                 (Ptr{Cvoid}, Cstring, Ptr{Cvoid}),
                 rk, topic, topic_conf)
end

function kafka_topic_destroy(rkt::Ptr{Cvoid})
    ccall((:rd_kafka_topic_destroy, LIBRDKAFKA), Cvoid, (Ptr{Cvoid},), rkt)
end

## TODO: rd_kafka_poll - should be called, but I'm not sure yet when

function kafka_poll(rk::Ptr{Cvoid}, timeout::Integer)
    return ccall((:rd_kafka_poll, LIBRDKAFKA), Cint,
                 (Ptr{Cvoid}, Cint),
                 rk, timeout)

end

# int rd_kafka_produce(rd_kafka_topic_t *rkt, int32_t partition,
#                     int msgflags,
#                     void *payload, size_t len,
#                     const void *key, size_t keylen,
#                     void *msg_opaque);

function produce(rkt::Ptr{Cvoid}, partition::Integer,
                 key::Vector{UInt8}, payload::Vector{UInt8})
    flags = Cint(0)
    errcode = ccall((:rd_kafka_produce, LIBRDKAFKA), Cint,
                    (Ptr{Cvoid}, Int32, Cint,
                     Ptr{Cvoid}, Csize_t,
                     Ptr{Cvoid}, Csize_t,
                     Ptr{Cvoid}),
                    rkt, Int32(partition), flags,
                    pointer(payload), length(payload),
                    pointer(key), length(key),
                    C_NULL)
    if errcode != 0
        error("Produce request failed with error code: $errcode")
    end
end

## topic list

function kafka_topic_partition_list_new(sz::Integer=0)
    rkparlist = ccall((:rd_kafka_topic_partition_list_new, LIBRDKAFKA), Ptr{Cvoid},
                       (Cint,), sz)
    return rkparlist
end

function kafka_topic_partition_list_destroy(rkparlist::Ptr{Cvoid})
    ccall((:rd_kafka_topic_partition_list_destroy, LIBRDKAFKA), Cvoid, (Ptr{Cvoid},), rkparlist)
end

function kafka_topic_partition_list_add(rkparlist::Ptr{Cvoid},
                                        topic::String, partition::Integer)
    ccall((:rd_kafka_topic_partition_list_add, LIBRDKAFKA), Ptr{Cvoid},
          (Ptr{Cvoid}, Cstring, Int32,), rkparlist, topic, partition)
end

## partition assignment
function kafka_assignment(rk::Ptr{Cvoid}, rkparlist::Ptr{Cvoid})
    errcode = ccall((:rd_kafka_assignment, LIBRDKAFKA), Cint,
                    (Ptr{Cvoid}, Ptr{Cvoid}), rk, rkparlist)
    if errcode != 0
        error("Assignment retrieval failed with error $errcode")
    end
end

## subscribe

function kafka_subscribe(rk::Ptr{Cvoid}, rkparlist::Ptr{Cvoid})
    errcode = ccall((:rd_kafka_subscribe, LIBRDKAFKA), Cint,
                    (Ptr{Cvoid}, Ptr{Cvoid}), rk, rkparlist)
    if errcode != 0
        error("Subscription failed with error $errcode")
    end
end

struct CKafkaMessage
    err::Cint
    rkt::Ptr{Cvoid}
    partition::Int32
    payload::Ptr{UInt8}
    len::Csize_t
    key::Ptr{UInt8}
    key_len::Csize_t
    offset::Int64
    _private::Ptr{Cvoid}
end

function kafka_consumer_poll(rk::Ptr{Cvoid}, timeout::Integer)
    msg_ptr = ccall((:rd_kafka_consumer_poll, LIBRDKAFKA), Ptr{CKafkaMessage},
                    (Ptr{Cvoid}, Cint), rk, timeout)
    if msg_ptr != Ptr{CKafkaMessage}(0)
        return msg_ptr
    else
        return nothing
    end
end

function kafka_message_destroy(msg_ptr::Ptr{CKafkaMessage})
    ccall((:rd_kafka_message_destroy, LIBRDKAFKA), Cvoid, (Ptr{Cvoid},), msg_ptr)
end


text:
function _precompile_()
    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
    Base.precompile(Tuple{typeof(line_visualization),Observable{Vector{Point{2, Float32}}},Dict{Symbol, Any}})   # time: 0.22955656
    Base.precompile(Tuple{typeof(assemble_robj),Dict{Symbol, Any},GLVisualizeShader,GeometryBasics.HyperRectangle{3, Float32},UInt32,Nothing,Nothing})   # time: 0.112225175
    Base.precompile(Tuple{typeof(to_index_buffer),Observable{Vector{Int64}}})   # time: 0.09670886
    Base.precompile(Tuple{typeof(ticks),Vector{T} where T,Int64})   # time: 0.07404702
    Base.precompile(Tuple{typeof(vec2quaternion),Observable{Vector{Quaternionf0}}})   # time: 0.043232486
    isdefined(GLVisualize, Symbol("#GLVisualizeShader#8#10")) && Base.precompile(Tuple{getfield(GLVisualize, Symbol("#GLVisualizeShader#8#10")),Dict{String, String},Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},Type{GLVisualizeShader},String,Vararg{String, N} where N})   # time: 0.035577767
    Base.precompile(Tuple{typeof(_position_calc),Observable{Vector{Point{3, Float32}}},Type{GLBuffer}})   # time: 0.016643895
    Base.precompile(Tuple{typeof(_position_calc),Observable{Vector{Point{2, Float32}}},Type{GLBuffer}})   # time: 0.013070196
    Base.precompile(Tuple{typeof(vec2quaternion),Observable{Quaternionf0}})   # time: 0.012976533
    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:view,), Tuple{Dict{String, String}}},Type{GLVisualizeShader},String,String,String,String,String})   # time: 0.009165488
    Base.precompile(Tuple{typeof(visualize),Any,Any,Any})   # time: 0.00876585
    Base.precompile(Tuple{typeof(ticks),Vector{Float64},Int64})   # time: 0.008059256
    Base.precompile(Tuple{typeof(position_calc),Observable{Vector{Point{3, Float32}}},Vararg{Any, N} where N})   # time: 0.00481658
    Base.precompile(Tuple{typeof(assemble_shader),Any})   # time: 0.004637692
    Base.precompile(Tuple{typeof(position_calc),Observable{Vector{Point{2, Float32}}},Vararg{Any, N} where N})   # time: 0.004362621
    Base.precompile(Tuple{typeof(primitive_uv_offset_width),Circle{Float32}})   # time: 0.0011835
    Base.precompile(Tuple{typeof(primitive_offset),Observable{Circle{Float32}},Any})   # time: 0.001028085
end


text:
info("Loading HttpServer methods...")

export WebSocketHandler

"""
Called by HttpServer. Responds to a WebSocket handshake request.
If the connection is acceptable, sends status code 101
and headers according to RFC 6455. Function returns
a WebSocket instance with the open socket as one of the fields.

Otherwise responds with '400' and returns false.

Any other response means 'decline', so a reason can be given.
The function returns 'true' to HttpServer, which then calls the
user's websocket handler.

It is recommended to do further checks of the upgrade request in the
user handler function.
   - "Origin" header: Included by clients in browsers, e.g: => "http://localhost:8000"
   - "Sec-WebSocket-Protocol" header: If included, e.g.: => "myOwnProtocol"
   -  "Sec-WebSocket-Extensions" => "permessage-deflate"

A WebSocketHandler may include:
  .function
  .acceptURI
  .acceptsubprotocol
  . acceptsource
  . acceptOrin.
Typical headers:
  -
   "Connection"               => "keep-alive, Upgrade"
   "Sec-WebSocket-Version"    => "13"
   "http_minor"               => "1"
   "Keep-Alive"               => "1"
   "User-Agent"               => "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:59.0) Gecko/20100101 Fi…
   "Accept-Encoding"          => "gzip, deflate"
   "Cache-Control"            => "no-cache"
   "Origin"                   => "http://localhost:8000"
   "Sec-WebSocket-Key"        => "R9b6CHWxy9cg3H+1WuCFCA=="
   "Sec-WebSocket-Protocol"   => "relay_frontend"
   "Sec-WebSocket-Extensions" => "permessage-deflate"
   "Host"                     => "localhost:8000"
   "Upgrade"                  => "websocket"
   "Pragma"                   => "no-cache"
   "http_major"               => "1"
   "Accept"                   => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
   "Accept-Language"          => "en-US,en;q=0.5"
 """
function websocket_handshake(request, client)
    response = HttpServer.Response(101)
    if get(request.headers, "Sec-WebSocket-Version", "13") != "13"
        response = HttpServer.Response(400)
        response.headers["Sec-WebSocket-Version"] = "13"
        Base.write(client.sock, response)
        return false
    end
    if haskey(request.headers, "Sec-WebSocket-Protocol")
        if hasprotocol(request.headers["Sec-WebSocket-Protocol"])
            response.headers["Sec-WebSocket-Protocol"] =  request.headers["Sec-WebSocket-Protocol"]
        else
            Base.write(client.sock, HttpServer.Response(400))
            return false
        end
    end

    if !haskey(request.headers, "Sec-WebSocket-Key")
        Base.write(client.sock, HttpServer.Response(400))
        return false
    end
    key = request.headers["Sec-WebSocket-Key"]
    if length(base64decode(key)) != 16 # Key must be 16 bytes
        Base.write(client.sock, HttpServer.Response(400))
        return false
    end
    resp_key = generate_websocket_key(key)

    response.headers["Upgrade"] = "websocket"
    response.headers["Connection"] = "Upgrade"
    response.headers["Sec-WebSocket-Accept"] = resp_key

    Base.write(client.sock, response)
    return true
end

"""
WebSocketHandler(f::Function) <: HttpServer.WebSocketInterface

A simple Function-wrapper for HttpServer.

The provided argument should be of the form
    `f(Request, WebSocket) => nothing`

Request is intended for gatekeeping, ref. RFC 6455 section 10.1.
WebSocket is for reading, writing and exiting when finished.

Take note of the very similar WebsocketHandler (no capital 'S'), which is a subtype of HTTP.
"""
struct WebSocketHandler <: HttpServer.WebSocketInterface
    handle::Function
end

"""
Performs handshake. If successfull, establishes WebSocket type and calls
handler with the WebSocket and the original request. On exit from handler, closes websocket. No return value.
"""
function HttpServer.handle(handler::WebSocketHandler, req::HttpServer.Request, client::HttpServer.Client)
    websocket_handshake(req, client) || return
    sock = WebSocket(client.sock,true)
    handler.handle(req, sock)
    if isopen(sock)
        try
            close(sock)
        end
    end
end

"""
Fast checking for websockets vs http requests, performed on all new HttpServer requests.
Similar to is_upgrade(r::HTTP.Message)
"""
function HttpServer.is_websocket_handshake(handler::WebSocketHandler, req::HttpServer.Request)
    if req.method == "GET"
        if ismatch(r"upgrade"i, get(req.headers, "Connection", ""))
            if lowercase(get(req.headers, "Upgrade", "")) == "websocket"
                return true
            end
        end
    end
    return false
end
# Inline docs in WebSockets.jl
target(req::HttpServer.Request) = req.resource
subprotocol(req::HttpServer.Request) = get(req.headers, "Sec-WebSocket-Protocol", "")
origin(req::HttpServer.Request) = get(req.headers, "Origin", "")


text:
import NamedTupleTools: namedtuple

getN(nt::NamedTuple{N,T}) where {N,T} = N
getN(::Type{NamedTuple{N,T}}) where {N,T} = N

getT(nt::NamedTuple{N,T}) where {N,T} = T
getT(::Type{NamedTuple{N,T}}) where {N,T} = tuple(T.types...)

NTtypes(NT::Type{NamedTuple{N,T}}) where {N,T} = namedtuple(getN(NT),getT(NT))

function variables(m::Model{A,B,M}) where {A,B,M}
    tuple(Soss.variables(m)...)
end

function variables(::Type{Model{A,B,M}}) where {A,B,M}
    variables(Soss.type2model(Model{A,B,M}))
end

max_stars_repo_name: cscherrer/SossGen

max_issues_repo_name: cscherrer/SossGen

max_forks_repo_name: cscherrer/SossGen


text:
using OmegaGrav
using MatterPower

# %% Specify a redshift
redshift = 0

# %% Cosmological parameters
As, ns, kpivot = 2.097e-9, 0.9652, 0.05
Ωm, ΩΛ, Ωb = 0.315, 0.685, 0.049
Ωk = 1 - Ωm - ΩΛ
h0 = 0.674
ωm, fb = Ωm * h0^2, Ωb / Ωm

# %% Tabulate linear growth factor as a function of scale factor, a
sol = setup_growth(Ωm, ΩΛ)
a = 1 / (1 + redshift)
D1 = sol(a)[1]

# %% Define a function to return a linear matter power spectrum (in units of Mpc^3/h^3)
# as a function of the comoving wavenumber, kovh, in units of h/Mpc.
# Here is an example using Einstein & Hu's analytical transfer function
pk(kovh) =
   D1^2 *
   As *
   (kovh * h0 / kpivot)^(ns - 1) *
   (2 * kovh^2 * 2998^2 / 5 / Ωm)^2 *
   t_nowiggle(kovh * h0, ωm, fb)^2 *
   2 *
   π^2 / kovh^3

# %% Compute the non-linear power spectrum using halofit
# Get three parameters [kσ, neff, C] needed for the halofit transform
p = kσ, neff, C = setup_halofit(pk)
# Calculate Ωm(z) = Ωm(z=0)(1+z)^3 / E^2(z), where E^2(z) = H^2(z) / H0^2
z = redshift
E2 = Ωm * (1 + z)^3 + Ωk * (1 + z)^2 + ΩΛ
Ωmz = Ωm * (1 + z)^3 / E2
# Define a function to return a halofit non-linear power spectrum
pknl(kovh) = halofit(pk, p, Ωmz, kovh) # Mpc^3/h^3

# %% Compute `Ωgrav = Ωm * W / 2`
println("redshift = ", z)
# Linear matter power spectrum
Ωgrav_pklin = ograv_pk(pk, z, Ωm)
println("Ωgrav(linear pk) = ", Ωgrav_pklin)
# Non-linear matter power spectrum
Ωgrav_pknl = ograv_pk(pknl, z, Ωm)
println("Ωgrav(non-linear pk) = ", Ωgrav_pknl)


text:
"""
    MetaUtils

contains utilities for metaprogramming in Julia.

```julia
export @show_sexpr,
    show_tree, @show_tree,
    print_subtypes,
    show_expr, @show_expr,
    show_texpr, @show_texpr,
    texpr2expr, teval, @teval
```
"""
module MetaUtils

export @show_sexpr,
    show_tree, @show_tree,
    print_subtypes,
    show_expr, @show_expr,
    show_texpr, @show_texpr,
    texpr2expr, teval, @teval

using InteractiveUtils: InteractiveUtils, subtypes
using AbstractTrees

"""
    @show_sexpr(expr, linenums=false)

shows the lisp style S-expression of `expr` and prints the line number nodes if `linenums` is true.  This is the macro version of `Meta.show_sexpr`.

## Example

```julia
julia> @show_sexpr 2x+1
(:call, :+, (:call, :*, 2, :x), 1)
```

`teval` function can evaluate the output of `@show_sexpr`.
```julia
julia> x = 10; (:call, :+, (:call, :*, 2, :x), 1) |> teval
21
```
"""
macro show_sexpr(expr, linenums=false)
    linenums || Base.remove_linenums!(expr)
    :(Meta.show_sexpr($(QuoteNode(expr))))
end

### 2021-03-14: AbstractTrees.printnode(io::IO, expr::Expr) is already defined in
### AbstractTrees/src/builtins.jl:14
###
### Warning: The following line is type piracy!
#AbstractTrees.printnode(io::IO, expr::Expr) = show(io, expr.head)

"""
    @show_tree(expr, maxdepth=10, linenums=false)

shows the tree form of the expression `expr` with maxdepth and prints the line number nodes if `linenums` is true.

## Example
```julia
julia> @show_tree 2x+1
Expr(:call)
├─ :+
├─ Expr(:call)
│  ├─ :*
│  ├─ 2
│  └─ :x
└─ 1
```
"""
macro show_tree(expr, maxdepth=10, linenums=false)
    linenums || Base.remove_linenums!(expr)
    :(print_tree($(QuoteNode(expr)); maxdepth = $(esc(maxdepth))))
end

"""
    show_tree(expr) = AbstractTrees.print_tree(expr)

can be regarded as the function version of `@show_tree`.
"""
show_tree(expr) = print_tree(expr)

### 2021-03-26 Warning: The following line is type piracy!
#AbstractTrees.children(T::Type) = subtypes(T)

### 2021-03-26: Wrap types in Box to prevent type piracy
###
struct TypeBox{T} x::T end
Base.parent(b::TypeBox) = b.x
Base.show(io::IO, b::TypeBox) = Base.show(io::IO, parent(b))
InteractiveUtils.subtypes(b::TypeBox{<:Type}) = TypeBox.(subtypes(parent(b)))
AbstractTrees.children(b::TypeBox{<:Type}) = subtypes(b)
AbstractTrees.printnode(io::IO, b::TypeBox) = show(io, parent(b))

"""
    print_subtypes(T::Type; kwargs...)
    print_subtypes(io::IO, T::Type; kwargs...)
    print_subtypes(f, io::IO, T::Type; kwargs...)

prints the subtypes of `T` by `AbstractTrees.print_tree`.

## Example
```julia
julia> print_subtypes(AbstractRange)
AbstractRange
├─ LinRange
├─ OrdinalRange
│  ├─ AbstractUnitRange
│  │  ├─ Base.IdentityUnitRange
│  │  ├─ Base.OneTo
│  │  ├─ Base.Slice
│  │  └─ UnitRange
│  └─ StepRange
└─ StepRangeLen
```
"""
print_subtypes(T::Type; kwargs...) = print_tree(TypeBox(T); kwargs...)
print_subtypes(io::IO, T::Type; kwargs...) = print_tree(io, TypeBox(T); kwargs...)
print_subtypes(f, io::IO, T::Type; kwargs...) =  print_tree(f, io::IO, TypeBox(T); kwargs...)

"""
    const expr_indent = 4

is the default indent of showing expressions.
"""
const expr_indent = 4

"""
    show_expr([io::IO,], ex)

shows expression `ex` as a Julia style expression.

# Examples
```julia
julia> show_expr(:(f(x, g(y, z))))
Expr(:call, :f, :x,
    Expr(:call, :g, :y, :z))
```
"""
show_expr(io::IO, ex, inner; indent=expr_indent, head="Expr") = show(io, ex)
show_expr(io::IO, ex; indent=expr_indent, head="Expr") = show_expr(io, ex, 0; indent, head)
show_expr(ex; indent=expr_indent, head="Expr") = show_expr(stdout, ex; indent, head)

function show_expr(io::IO, ex::LineNumberNode, inner; indent=expr_indent, head="Expr")
    print(io, "LineNumberNode(")
    show(io, ex.line); print(io, ", ")
    show(io, ex.file); print(io, ')')
end

# See https://github.com/JuliaLang/julia/issues/6104#issuecomment-37262662
function show_expr(io::IO, ex::QuoteNode, inner; indent=expr_indent, head="Expr")
    print(io, "QuoteNode", "(")
    show_expr(io, ex.value, inner+indent; indent, head)
    print(io, ')')
end

function show_expr(io::IO, ex::Expr, inner; indent=expr_indent, head="Expr")
    iszero(inner) || print(io, "\n")
    print(io, " "^inner, head, "(")
    show_expr(io, ex.head, inner+indent; indent, head)
    for arg in ex.args
        print(io, ", ")
        show_expr(io, arg, inner+indent; indent, head)
    end
    isempty(ex.args) && print(io, ',')
    print(io, ')')
end

"""
    @show_expr(expr, linenums=false)

shows the Juia style expression of `expr` and prints the line number nodes if `linenums` is true.  This is the macro version of `show_expr`.

## Example

```julia
julia> @show_expr 2x+1
Expr(:call, :+,
    Expr(:call, :*, 2, :x), 1)
```

`eval` function can evaluate the output of `@show_expr`.

```julia
julia> x = 10; Expr(:call, :+,
    Expr(:call, :*, 2, :x), 1) |> eval
21
```
"""
macro show_expr(expr, linenums=false)
    linenums || Base.remove_linenums!(expr)
    :(show_expr($(QuoteNode(expr))))
end

"""
    show_texpr([io::IO,], ex)

Yet another `Meta.show_sexpr`.  It shows expression `ex` as a lisp style expression.

Remark: The indentation is different from `Meta.show_sexpr`.

# Examples
```julia
julia> show_texpr(:(f(x, g(y, z))))
Expr(:call, :f, :x,
    Expr(:call, :g, :y, :z))
```
"""
show_texpr(io::IO, ex; indent=expr_indent) = show_expr(io, ex; indent, head="")
show_texpr(ex; indent=expr_indent) = show_texpr(stdout, ex; indent)

"""
    @show_texpr(expr, linenums=false)

Yet another `@show_sexpr`.  It shows the lisp style S-expression of `expr` and prints the line number nodes if `linenums` is true.

Remark: The indentation is different from `@show_sexpr`.

## Example

```julia
julia> @show_texpr 2x+1
(:call, :+,
    (:call, :*, 2, :x), 1)
```

`teval` function can evaluate the output of `@show_texpr`.

```julia
julia> x = 10; (:call, :+,
    (:call, :*, 2, :x), 1) |> teval
21
```
"""
macro show_texpr(expr, linenums=false)
    linenums || Base.remove_linenums!(expr)
    :(show_texpr($(QuoteNode(expr))))
end

"""
    texpr2expr(x, m::Module=Main)

converts a lisp-like tuple expression `x` to the executable expression of Julia.

Example: The expression of `sin(π/6)`

```julia
julia> texpr2expr((:call, :sin, (:call, :/, π, 6)))
:(sin(π / 6))
```
"""
texpr2expr(x, m::Module=Main) = x
texpr2expr(q::QuoteNode, m::Module=Main) = QuoteNode(texpr2expr(q.value))

function texpr2expr(t::Tuple, m::Module=Main)
    isempty(t) && return :(())
    @assert t[1] isa Symbol "The first element of "*sprint(show, t)*" is not a Symbol."
    e = texpr2expr.(t, Ref(m))
    if isdefined(Main, e[1])
        f = Core.eval(m, e[1])
        !isa(f, Core.Builtin) && isa(f, Function) && return Expr(:call, e...)
    end
    Expr(e...)
end

"""
    teval(texpr, m::Module=Main)

evaluates the lisp-like tuple expression `texpr`.

Example: Calculation of `sin(π/6)`

```julia
julia> (:call, :sin, (:call, :/, π, 6)) |> teval
0.49999999999999994
```

In some cases, you can omit `:call`.

```julia
julia> (:sin, (:/, π, 6)) |> teval
0.49999999999999994
```
"""
teval(texpr, m::Module=Main) = Core.eval(m, texpr2expr(texpr, m))

"""
    @teval texpr

evaluates the lisp-like tuple expression `texpr`.

Example: Calculation of `sin(π/6)`

```julia
julia> @teval (:call, :sin, (:call, :/, π, 6))
0.49999999999999994
```

In some cases, you can omit `:call`.

```julia
julia> @teval (:sin, (:/, π, 6))
0.49999999999999994
```
"""
macro teval(texpr)
    esc(texpr2expr(Core.eval(__module__, texpr)))
end

"""
    MetaUtils.@t texpr

shows the Julia expression and the value of the lisp-like tuple expression `texpr`.

Example:

```julia
julia> MetaUtils.@t (:call, :sin, (:call, :/, π, 6))
:(sin(π / 6))
→ 0.49999999999999994
```
"""
macro t(x)
    expr = texpr2expr(Core.eval(__module__, x))
    show(expr); print("\n→ "); show(Core.eval(__module__, expr))
    print("\n")
end

"""
    MetaUtils.@T texpr

shows `show(texpr)`, `show_texpr(texpr)`, the Julia expression, and the value of the lisp-like tuple expression `texpr`.

Example:
```julia
julia> MetaUtils.@T (:call, :sin, (:call, :/, π, 6))
(:call, :sin, (:call, :/, π, 6))
→ (:call, :sin,
    (:call, :/, π, 6))
→ :(sin(π / 6))
→ 0.49999999999999994
```
"""
macro T(x)
    code = Core.eval(__module__, x)
    expr = texpr2expr(code)
    show(code)
    print("\n→ "); show_texpr(expr); print("\n→ ")
    show(expr); print("\n→ "); show(Core.eval(__module__, expr))
    print("\n")
end

end


text:
"""
    Module EntropyStableEuler

Includes general math tools
"""

module EntropyStableEuler

const γ=1.4
export logmean
export u_vfun, v_ufun, betafun, pfun
export euler_fluxes, wavespeed
export vortex, primitive_to_conservative

include("./logmean.jl")
include("./euler_fluxes.jl")
include("./euler_variables.jl")

# 2D isentropic vortex solution for testing. assumes domain around [0,20]x[-5,5]
function vortex(x,y,t,γ=1.4)

    x0 = 5
    y0 = 0
    beta = 5
    r2 = @. (x-x0-t)^2 + (y-y0)^2

    u = @. 1 - beta*exp(1.0-r2)*(y-y0)/(2.0*pi)
    v = @. beta*exp(1.0-r2)*(x-x0-t)/(2.0*pi)
    rho = @. 1.0 - (1.0/(8.0*γ*pi^2))*(γ-1.0)/2.0*(beta*exp(1.0-r2))^2
    rho = @. rho^(1/(γ-1))
    p = @. rho^γ

    return (rho, u, v, p)
end

end

max_stars_repo_name: yiminllin/ESDG-Fourier

max_issues_repo_name: yiminllin/ESDG-Fourier

max_forks_repo_name: yiminllin/ESDG-Fourier


text:
# contains some utils for Fermionic Tensor Network Construction

using BitBasis
using CUDA
using VUMPS
using VUMPS: dtr
using Zygote

include("contractrules.jl")

_arraytype(::Array{T}) where {T} = Array
_arraytype(::CuArray{T}) where {T} = CuArray

"""
    parity_conserving(T::Array)

Transform an arbitray tensor which has arbitray legs and each leg have index 1 or 2 into parity conserving form

# example

```julia
julia> T = rand(2,2,2)
2×2×2 Array{Float64, 3}:
[:, :, 1] =
 0.863822  0.133604
 0.865495  0.371586

[:, :, 2] =
 0.581621  0.819325
 0.197463  0.801167

julia> parity_conserving(T)
2×2×2 Array{Float64, 3}:
[:, :, 1] =
 0.863822  0.0
 0.0       0.371586

[:, :, 2] =
 0.0       0.819325
 0.197463  0.0
```
"""
function parity_conserving(T::Union{Array,CuArray}) where V<:Real
	s = size(T)
	p = zeros(s)
	bits = map(x -> Int(ceil(log2(x))), s)
	for index in CartesianIndices(T)
		i = Tuple(index) .- 1
		sum(sum.(bitarray.(i,bits))) % 2 == 0 && (p[index] = 1)
	end
	p = _arraytype(T)(p)

	return reshape(p.*T,s...)
end

"""
    function swapgate(n1::Int,n2::Int)

Generate a tensor which represent swapgate in Fermionic Tensor Network. n1,n2 should be power of 2.
The generated tensor have 4 indices. (ijkl).
S(ijkl) = delta(ik)*delta(jl)*parity(gate)

# example
```
julia> swapgate(2,4)
2×4×2×4 Array{Int64, 4}:
[:, :, 1, 1] =
 1  0  0  0
 0  0  0  0

[:, :, 2, 1] =
 0  0  0  0
 1  0  0  0

[:, :, 1, 2] =
 0  1  0  0
 0  0  0  0

[:, :, 2, 2] =
 0   0  0  0
 0  -1  0  0

[:, :, 1, 3] =
 0  0  1  0
 0  0  0  0

[:, :, 2, 3] =
 0  0   0  0
 0  0  -1  0

[:, :, 1, 4] =
 0  0  0  1
 0  0  0  0

[:, :, 2, 4] =
 0  0  0  0
 0  0  0  1
```
"""
function swapgate(n1::Int,n2::Int)
	S = ein"ij,kl->ikjl"(Matrix{ComplexF64}(I,n1,n1),Matrix{ComplexF64}(I,n2,n2))
	for j = 1:n2, i = 1:n1
		sum(bitarray(i-1,Int(ceil(log2(n1)))))%2 != 0 && sum(bitarray(j-1,Int(ceil(log2(n2)))))%2 != 0 && (S[i,j,:,:] .= -S[i,j,:,:])
	end
	return S
end

"""
    function fdag(T::Array{V,5}) where V<:Number

Obtain dag tensor for local peps tensor in Fermionic Tensor Network(by inserting swapgates). The input tensor has indices which labeled by (lurdf)
legs are counting from f and clockwisely.

input legs order: ulfdr
output legs order: ulfdr
"""
function fdag(T::Union{Array{V,5},CuArray{V,5}}) where V<:Number
	nu,nl,nf,nd,nr = size(T)
	Tdag = conj(T)

	S = _arraytype(T){ComplexF64}(swapgate(nl,nu))
	Tdag = ein"(ulfdr,luij),rdpq->jifqp"(Tdag, S, S)
	return Tdag
end

function fdag(T::AbstractZ2Array)
	nu,nl,nf,nd,nr = size(T)
	Tdag = conj(T)

	atype = _arraytype(T.tensor[1])
	S = Zygote.@ignore atype(tensor2Z2tensor(swapgate(nl,nu)))
	Tdag = ein"(ulfdr,luij),rdpq->jifqp"(Tdag, S, S)
	return Tdag
end

"""
    function bulk(T::Array{V,5}) where V<: Number

Obtain bulk tensor in peps, while the input tensor has indices which labeled by (lurdf).
This tensor is ready for GCTMRG (general CTMRG) algorithm
"""
function bulk(T::Union{Array{V,5},CuArray{V,5}}) where V<:Number
	nu,nl,nf,nd,nr = size(T)
	Tdag = fdag(T)
	# u l s d r
	eincode = EinCode(((1,2,3,4,5),(6,7,3,8,9),(2,6,12,13),(4,9,10,11)),(13,1,7,12,8,10,11,5))
	S = _arraytype(T){ComplexF64}(swapgate(nl,nu))
	return	_arraytype(T)(reshape(einsum(eincode,(T,Tdag,S,S)),nu^2,nl^2,nd^2,nr^2))
end

"""
    function bulkop(T::Array{V,5}) where V<: Number

Obtain bulk tensor in peps, while the input tensor has indices which labeled by (lurdf).
This tensor is ready for GCTMRG (general CTMRG) algorithm
"""
function bulkop(T::Union{Array{V,5},CuArray{V,5}}) where V<:Number
	nu,nl,nf,nd,nr = size(T)
	Tdag = fdag(T)
	# u l s d r
	eincode = EinCode(((1,2,3,4,5),(6,7,14,8,9),(2,6,12,13),(4,9,10,11)),(13,1,7,12,8,10,11,5,3,14))
	S = _arraytype(T){ComplexF64}(swapgate(nl,nu))
	return	_arraytype(T)(reshape(einsum(eincode,(T,Tdag,S,S)),nu^2,nl^2,nd^2,nr^2,nf,nf))
end

"""
	calculate enviroment (E1...E6)
	a ────┬──── c
	│     b     │
	├─ d ─┼─ e ─┤
	│     g     │
	f ────┴──── h
	order: fda,abc,dgeb,hgf,ceh
"""
function ipeps_enviroment(T::AbstractArray, key)
	folder, model, Ni, Nj, symmetry, atype, D, χ, tol, maxiter = key
	Ni, Nj = size(T)
	b = reshape([permutedims(bulk(T[i]),(2,3,4,1)) for i = 1:Ni*Nj], (Ni, Nj))
	symmetry == :Z2 && (b = tensor2Z2tensor.(b))
	# VUMPS
	_, ALu, Cu, ARu, ALd, Cd, ARd, FLo, FRo, FL, FR = obs_env(b; χ=χ, maxiter=maxiter, miniter=1, tol = tol, verbose=true, savefile= true, infolder=folder*"/$(model)_$(Ni)x$(Nj)/", outfolder=folder*"/$(model)_$(Ni)x$(Nj)/", updown = true, downfromup = false, show_every=Inf)

	E1 = FLo
	E2 = reshape([ein"abc,cd->abd"(ALu[i],Cu[i]) for i = 1:Ni*Nj], (Ni, Nj))
	E3 = ARu
	E4 = FRo
	E5 = ARd
	E6 = reshape([ein"abc,cd->abd"(ALd[i],Cd[i]) for i = 1:Ni*Nj], (Ni, Nj))
	E7 = FL
	E8 = FR
	# E1,E2,E3,E4,E5,E6,E7,E8 = map(x->Z2tensor2tensor.(x),[E1,E2,E3,E4,E5,E6,E7,E8])
	return (E1,E2,E3,E4,E5,E6,E7,E8)
end

ABBA(i) = i in [1,4] ? 1 : 2

function double_ipeps_energy(ipeps::AbstractArray, key)
	folder, model, Ni, Nj, symmetry, atype, D, χ, tol, maxiter = key
	T = reshape([parity_conserving(ipeps[:,:,:,:,:,ABBA(i)]) for i = 1:Ni*Nj], (Ni, Nj))
	E1,E2,E3,E4,E5,E6,E7,E8 = ipeps_enviroment(T, key)
	etol = 0

	atype = _arraytype(T[1,1]){ComplexF64}
	hx = reshape(atype(hamiltonian(model)), 4, 4, 4, 4)
	hy = reshape(atype(hamiltonian(model)), 4, 4, 4, 4)
	if symmetry == :Z2
		hx = Zygote.@ignore tensor2Z2tensor(hx)
		hy = Zygote.@ignore tensor2Z2tensor(hy)
	end

	for j = 1:Nj, i = 1:Ni
		ir = Ni + 1 - i
		jr = j + 1 - (j==Nj) * Nj

		Tij, Tijr, Tirj = symmetry == :Z2 ? tensor2Z2tensor.([T[i,j], T[i,jr], T[ir,j]]) : [T[i,j], T[i,jr], T[ir,j]]
		ex = (E1[i,j],E2[i,j],E3[i,jr],E4[i,jr],E5[ir,jr],E6[ir,j])
		ρx = square_ipeps_contraction_horizontal(Tij, Tijr, ex, symmetry)
		# ρ1 = reshape(ρ,16,16)
		# @show norm(ρ1-ρ1')
        Ex = ein"ijkl,ijkl -> "(ρx,hx)[]
		nx = dtr(ρx) # nx = ein"ijij -> "(ρx)
		etol += Ex/nx
		println("─ = $(Ex/nx)")

        ey = (E1[ir,j],E2[i,j],E4[ir,j],E6[i,j],E7[i,j],E8[i,j])
		ρy = square_ipeps_contraction_vertical(Tij, Tirj, ey, symmetry)
		# ρ1 = reshape(ρ,16,16)
		# @show norm(ρ1-ρ1')
        Ey = ein"ijkl,ijkl -> "(ρy,hy)[]
		ny = dtr(ρy) # ny = ein"ijij -> "(ρy)[]
		etol += Ey/ny
		println("│ = $(Ey/ny)")
	end

	return real(etol)/Ni/Nj
end

function square_ipeps_contraction_vertical(T1, T2, env, symmetry)
	nu,nl,nf,nd,nr = size(T1)
	χ = size(env[1])[1]
	if symmetry == :Z2
		(E1,E2,E4,E6,E7,E8) = map(x->Z2reshape(x,(χ,nl,nl,χ)),env)
		atype = _arraytype(T1.tensor[1])
		SdD = Zygote.@ignore tensor2Z2tensor(atype(swapgate(nf,nu)))
		SDD = Zygote.@ignore tensor2Z2tensor(atype(swapgate(nl,nu)))
	else
		(E1,E2,E4,E6,E7,E8) = map(x->reshape(x,(χ,nl,nl,χ)),env)
		atype = _arraytype(T1)
		SdD = Zygote.@ignore atype(swapgate(nf,nu))
		SDD = Zygote.@ignore atype(swapgate(nl,nu))
	end

	result = VERTICAL_RULES(T1,fdag(T1),SDD,SdD,SdD,SDD,T2,fdag(T2),SDD,SdD,SdD,SDD,
	E2,E8,E4,E6,E1,E7)
	return result
end

function square_ipeps_contraction_horizontal(T1, T2, env, symmetry)
	nu,nl,nf,nd,nr = size(T1)
	χ = size(env[1])[1]
	if symmetry == :Z2
		(E1,E2,E3,E4,E5,E6) = map(x->Z2reshape(x,(χ,nl,nl,χ)),env)
		atype = _arraytype(T1.tensor[1])
		SdD = Zygote.@ignore tensor2Z2tensor(atype(swapgate(nf,nu)))
		SDD = Zygote.@ignore tensor2Z2tensor(atype(swapgate(nl,nu)))
	else
		(E1,E2,E3,E4,E5,E6) = map(x->reshape(x,(χ,nl,nl,χ)),env)
		atype = _arraytype(T1)
		SdD = Zygote.@ignore atype(swapgate(nf,nu))
		SDD = Zygote.@ignore atype(swapgate(nl,nu))
	end

	result = HORIZONTAL_RULES(T1,SdD,fdag(T1),SdD,SDD,SDD,fdag(T2),SdD,SdD,SDD,T2,SDD,
	E1,E2,E3,E4,E5,E6)
	return result
end


text:
using LinearAlgebra
using SparseArrays
using Logging

import CPLEX

using CLaP

const CUT_PARAMS = [
    "CPXPARAM_MIP_Cuts_BQP",
    "CPXPARAM_MIP_Cuts_Cliques",
    "CPXPARAM_MIP_Cuts_Covers",
    "CPXPARAM_MIP_Cuts_Disjunctive",
    "CPXPARAM_MIP_Cuts_FlowCovers",
    "CPXPARAM_MIP_Cuts_PathCut",
    "CPXPARAM_MIP_Cuts_Gomory",
    "CPXPARAM_MIP_Cuts_GUBCovers",
    "CPXPARAM_MIP_Cuts_Implied",
    "CPXPARAM_MIP_Cuts_LocalImplied",
    "CPXPARAM_MIP_Cuts_LiftProj",
    "CPXPARAM_MIP_Cuts_MIRCut",
    # "CPXPARAM_MIP_Cut_MCFCut",  # For some reason this one raises an error
    "CPXPARAM_MIP_Cuts_RLT",
    "CPXPARAM_MIP_Cuts_ZeroHalfCut"
]

function main(finst, maxrounds=200, maxtime=3600.0; verbose::Bool=true)
    # Read model from file
    cbf = MOI.FileFormats.CBF.Model()
    MOI.read_from_file(cbf, finst)

    # Create standard form problem
    micp_optimizer = MOI.OptimizerWithAttributes(CPLEX.Optimizer,
        "CPX_PARAM_PREIND" => 0,                        # Disable presolve (0)
        "CPX_PARAM_THREADS" => 1,                       # Single thread
        "CPXPARAM_MIP_Strategy_MIQCPStrat" => 2,        # 1: NL-B&B, 2:OA
        [cutparam => -1 for cutparam in CUT_PARAMS]..., # Disable all cuts
        "CPXPARAM_MIP_Limits_Nodes" => 0,               # Root node only
        "CPXPARAM_MIP_Strategy_HeuristicFreq" => -1     # Disable heuristics
    )

    sf = build_standard_form(micp_optimizer, cbf, bridge_type=Float64)

    # Solve root node with aggressive L-a-P cuts
    micp = sf.model
    MOI.set(micp, MOI.RawParameter("CPXPARAM_MIP_Limits_CutPasses"), maxrounds)
    MOI.set(micp, MOI.RawParameter("CPXPARAM_MIP_Limits_CutsFactor"), 1e30)
    MOI.set(micp, MOI.RawParameter("CPXPARAM_MIP_Cuts_LiftProj"), 3)

    # Time limit
    MOI.set(micp, MOI.Silent(), !verbose)
    MOI.set(micp, MOI.TimeLimitSec(), maxtime)  # 1-hour time limit

    # Callback for tracking bound progress
    tstart = time()
    ncalls = 0
    function cbinfo(cbdata)
        x_ = MOI.get(micp, MOI.CallbackVariablePrimal(cbdata), sf.var_indices)
        z_ = dot(sf.c, x_)
        ncalls += 1
        t_ = time() - tstart
        @info "Current stats" z_ t_ ncalls
        return nothing
    end

    MOI.set(micp, MOI.UserCutCallback(), cbinfo)

    tstart = time()
    MOI.optimize!(micp)

    verbose && @show MOI.get(micp, MOI.TerminationStatus())    # Termination status
    verbose && @show MOI.get(micp, MOI.ObjectiveBound())       # Lower bound

    return micp
end

if abspath(PROGRAM_FILE) == @__FILE__
    nrounds = parse(Int, ARGS[2])
    maxtime = parse(Float64, ARGS[3])

    with_logger(Logging.NullLogger()) do
        main(ARGS[1], 2, 5.0, verbose=false)
    end

    main(ARGS[1], nrounds, maxtime)
end

max_stars_repo_name: mtanneau/CLaP

max_issues_repo_name: mtanneau/CLaP

max_forks_repo_name: mtanneau/CLaP


text:
# author: aliyyousuf@gmail.com

using Distributions
using DataFrames

srand(1234)

array_1 = zeros(Float64,30,3)

nd1 = Normal(0.0,1.0)
nd2 = Normal(10.0,2.0)

array_1[:,1] = rand(nd1, 30)
array_1[:,2] = rand(nd2, 30)
array_1[:,3] = rand(5:15,30)

println("Column 1 mean: ", mean(array_1[:,1]), ", variance: ", var(array_1[:,1]))
println("Column 2 mean: ", mean(array_1[:,2]), ", variance: ", var(array_1[:,2]))
println("Column 3 mean: ", mean(array_1[:,3]), ", variance: ", var(array_1[:,3]))

df = convert(DataFrame, array_1)

# Change the name of the columns in df

# Reanaming the columns's name of the dataframe:

rename!(df, f => t for (f, t) = zip([:x1, :x2, :x3], [:Var1, :Var2, :Var3]))

# Declaring array df2:

df2 = df[11:end,:]
describe(df2)

# Adding a new column to df2 named "Cat1":
df2[:Cat1] = rand(["GroupA", "GroupB"], 20)

# Declaring another DataFrame named as df3:
df3 = DataFrame(A = 1:20, B = 21:40, C = 41:60)

# Changing some row's values to NA:
df3[10,1] = df3[15,2] = df3[19,3] = NA

#Remove all rows that contain the NA values:

df4 = completecases!(df3)

max_stars_repo_name: aliyyousuff/MOOC

max_issues_repo_name: aliyyousuff/MOOC

max_forks_repo_name: aliyyousuff/MOOC


text:
#=

# 2: Water collapse (explicit)

```@raw html
	<img src='../assets/collapse_exp.png' alt='missing' width="50%" height="50%" /><br>
```

Simulation of a water column collapsing under its own weight onto dry bottom.
This is, where SPH is more useful than typical mesh-based methods
=#

module collapse_dry

using Printf
using SmoothedParticles
using CSV
using DataFrames

#=
Declare constant parameters
=#

##physical
const dr = 2.0e-2          #average particle distance (decrease to make finer simulation)
const h = 3.0*dr           #size of kernel support
const rho0 = 1000.   	   #fluid density
const m = rho0*dr^2        #particle mass
const c = 50.0             #numerical speed of sound
const g = -9.8*VECY        #gravitational acceleration
const mu = 8.4e-4          #dynamic viscosity of water
const nu = 1.0e-4          #pressure stabilization

##geometrical
const water_column_width = 1.0
const water_column_height = 2.0
const box_height = 3.0
const box_width = 4.0
const wall_width = 2.5*dr

##temporal
const dt = 0.1*h/c
const t_end = 1.0
const dt_frame = t_end/50

##particle types
const FLUID = 0.
const WALL = 1.

#=
Declare variables to be stored in a Particle
=#

mutable struct Particle <: AbstractParticle
	x::RealVector #position
	v::RealVector #velocity
	a::RealVector #acceleration
	P::Float64 #pressure
	rho::Float64 #density
	Drho::Float64 #rate of density
	type::Float64 #particle_type
	Particle(x, type) = new(
		x, VEC0, VEC0,
		0.,
		rho0, 0.,
		type
	)
end

#=
Define geometry and make particles
=#

function make_system()
	grid = Grid(dr, :square)
	box = Rectangle(0., 0., box_width, box_height)
	fluid = Rectangle(0., 0., water_column_width, water_column_height)
	walls = BoundaryLayer(box, grid, wall_width)
	walls = Specification(walls, x -> (x[2] < box_height))
	sys = ParticleSystem(Particle, box + walls, h)
	generate_particles!(sys, grid, fluid, x -> Particle(x, FLUID))
	generate_particles!(sys, grid, walls, x -> Particle(x, WALL))
	return sys
end

#=
Define particle interactions
=#

@inbounds function balance_of_mass!(p::Particle, q::Particle, r::Float64)
	ker = m*rDwendland2(h,r)
	p.Drho += ker*(dot(p.x-q.x, p.v-q.v) + 2*nu*(p.rho-q.rho))
end

function find_pressure!(p::Particle)
	p.rho += p.Drho*dt
	p.Drho = 0.0
	p.P = c^2*(p.rho - rho0)
end

@inbounds function internal_force!(p::Particle, q::Particle, r::Float64)
	if p.type == FLUID
		ker = m*rDwendland2(h,r)
		p.a += -ker*(p.P/rho0^2 + q.P/rho0^2)*(p.x - q.x)
		p.a += +2*ker*mu/rho0^2*(p.v - q.v)
	end
end

function move!(p::Particle)
	p.a = VEC0
	if p.type == FLUID
		p.x += dt*p.v
	end
end

function accelerate!(p::Particle)
	if p.type == FLUID
		p.v += 0.5*dt*(p.a + g)
	end
end

function energy(p::Particle)::Float64
	kinetic = 0.5*m*dot(p.v, p.v)
	potential = -m*dot(g, p.x)
	internal =  0.5*m*c^2*(p.rho - rho0)^2/rho0^2
	return kinetic + potential + internal
end

function compute_max(sys::ParticleSystem)::NTuple{2,Float64}
	H = -Inf
	X = -Inf
	for p in sys.particles
		if p.type == FLUID && p.x[1] > X
			X = p.x[1]
		end
		if p.type == FLUID && p.x[1] > 2*h && p.x[2] > H
			H = p.x[2]
		end
	end
	return (X-1.0,0.5*H)
end

#=
Put everything into a time loop
=#
function main()
	ts = []
	Xs = []
	Hs = []
	sys = make_system()
	out = new_pvd_file("results/collapse_dry")
	#a modified Verlet scheme
	@time for k = 0 : Int64(round(t_end/dt))
	#move particles
		apply!(sys, move!)
		create_cell_list!(sys)
		apply!(sys, balance_of_mass!)
		apply!(sys, find_pressure!)
		apply!(sys, internal_force!)
		apply!(sys, accelerate!)
		#save data at selected frames
		if (k % Int64(round(dt_frame/dt)) == 0)
			@printf("t = %.6e\n", k*dt)
			@printf("E = %.6e\n", sum(energy, sys.particles))
			@printf("\n")
			(X, H) = compute_max(sys)
			push!(Xs, X)
			push!(Hs, H)
			push!(ts, k*dt*sqrt(-2*g[2]))
			save_frame!(out, sys, :v, :P, :rho, :type)
		end
		#accelerate
		apply!(sys, accelerate!)
	end
	save_pvd_file(out)
	df = DataFrame(time = ts, X = Xs, H = Hs)
	CSV.write("results/collapse_dry/data.csv", df)
end ## function main

end ## module


text:
using QXGraphDecompositions
using Test

import LightGraphs; lg = LightGraphs

include("LabeledGraph_tests.jl")
include("elimination_order_tests.jl")
include("tree_decomposition_tests.jl")
include("treewidth_deletion_tests.jl")