diff --git a/src/chemistry/Titration.jl b/src/chemistry/Titration.jl new file mode 100644 index 0000000..15250ac --- /dev/null +++ b/src/chemistry/Titration.jl @@ -0,0 +1,2385 @@ +### A Pluto.jl notebook ### +# v0.20.19 + +#> [frontmatter] +#> license_url = "https://github.com/JuliaPluto/featured/blob/main/LICENSES/Unlicense" +#> image = "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3f/Vinegar_Titration_-_Color_of_the_Phenolphthalein_reacting_to_NaOH.jpg/960px-Vinegar_Titration_-_Color_of_the_Phenolphthalein_reacting_to_NaOH.jpg" +#> language = "en-US" +#> title = "Simulating titrations" +#> tags = ["chemistry"] +#> date = "2025-09-17" +#> description = "Learn about titrations and indicators. Deepen your understanding by conducting a digital titration yourself! " +#> license = "Unilicense" +#> +#> [[frontmatter.author]] +#> name = "Lucas Hildebrandt" +#> url = "https://github.com/lucashildebrandt" + +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) + #! format: off + return quote + local iv = try Base.loaded_modules[Base.PkgId(Base.UUID("6e696c72-6542-2067-7265-42206c756150"), "AbstractPlutoDingetjes")].Bonds.initial_value catch; b -> missing; end + local el = $(esc(element)) + global $(esc(def)) = Core.applicable(Base.get, el) ? Base.get(el) : iv(el) + el + end + #! format: on +end + +# ╔═╡ 094598f7-8319-4551-b677-de5729672080 +using Plots, PlutoUI, DataFrames, LaTeXStrings, ColorSchemes, Handcalcs, StructuralUnits + +# ╔═╡ 784c8ee4-df28-4bd8-bff7-f3bb2d097b12 +md""" +# Simulating Titrations +""" + +# ╔═╡ ce9c2c18-5b35-4b05-a3d9-6eb67c7a5529 +md""" +In this notebook, we want to see how the interactive and reactive features of Pluto can help us understand one of the most common analytical techniques in chemistry: titrations. + +!!! question "Is this for me?" + + This notebook is intended for highschool students, university students studying chemistry or another natural science, or others who are interested in seeing what this notebook has to offer. Basic chemistry knowledge is recommended (e.g. knowing acids and bases, familiarity with the pH scale), but some short reminders are included. Feel free to give the notebook a try nonetheless. + + For those further interested in how the titration curves were plotted and how the equations were derived, check out the code in combination to the appendix at the end of the notebook. +""" + +# ╔═╡ 0f262891-af4b-4007-82f6-7aae20f91dbd +md""" +## The Basics +📚 *The explanations are based on [Titration (Wikipedia)](https://en.wikipedia.org/wiki/Titration), [Acid-base titration (Wikipedia)](https://en.wikipedia.org/wiki/Acid%E2%80%93base_titration) and [Binnewies et al., 2016](https://doi.org/10.1007/978-3-662-45067-3). For further reading, check out the links or take a look at a general chemistry textbook of your choice.* +""" + +# ╔═╡ ee2a647a-0cba-46c6-afb0-ba16bf0f0150 +md""" +Titrations are used to analyse samples and determine unknown concentrations. One of the most common types of titration is the acid-base titration. To find out the concentration of an analyte, e.g. an acid like hydrochloric acid (HCl), you use a titrant solution, e.g. a base like sodium hydroxide (NaOH), with a known concentration. The base and acid react with each other in a neutralisation reaction to form water. + +```math +\mathrm{H_{3}O^{+}} + \mathrm{OH^{-}} \rightarrow \mathrm{H_{2}O} +``` + +By meassuring how much base is needed to convert the acid completly, the concentration of the acid is determined. + +!!! question "Is that always the case?" + This is a very brief explanation to illustrate the key idea of titrations and in this form it is only valid for very strong acids and bases, which dissociate completly, while weaker acids and bases do not. Therefore, only for very strong acids the concentration of hydronium ions (``\mathrm{H_{3}O^{+}}``) is equal to the concentration of acid (``\mathrm{HA}`` in general form). + + ```math + c\mathrm{(H_3O^+)} = c\mathrm{(HA)} + ``` + + For the other cases (weaker acids, di- or triprotonic acids etc.) the chemistry is a bit more complex. We will look at some of these cases later. Of course, the analyte can also be a base, in which case an acid is used as titrant. +""" + +# ╔═╡ 83a21840-a772-469e-999d-c066f60e2e0e +md""" +The experiment is done with a so called burette, which can be seen in the picture below. It allows the base to be added in very small steps, most common up to ``0.1~\mathrm{mL}``. +""" + +# ╔═╡ 7705230b-91dc-4851-9e1b-37a642e66657 +Resource( + "https://upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Acid_and_Base_Titration.jpg/250px-Acid_and_Base_Titration.jpg", + :alt => "Burette and erlenmeyer flask", + :width => 200 +) + +# ╔═╡ 657f405a-a7f8-4915-ba60-46464a01873f +md""" +### Titration Curves +""" + +# ╔═╡ 7c79ba77-e2b6-4e0d-8522-f0b540e6815f +md""" +#### Very Strong Acids +""" + +# ╔═╡ ad925028-59c3-433d-a54a-3f644d11b639 +md""" +To see if the acid is completly converted, the pH value at each point of added base can be measured with a pH electrode. +This allows the plotting of a titration curve. The inflection point of this curve is the equivalence point. At this stage, the acid has reacted completly with the added base. Because this example is a titration of a strong acid (HCl) and strong base (NaOH), the neutralisation results in a neutral sodium chloride solution (NaCl) and therefore the equivalence point is at pH 7. +""" + +# ╔═╡ 8cea32f9-a670-4269-a586-c7bdb339a80d +begin + begin + pointX_strong = 25.0 + v_Base_end_ex = 25 * 0.1 / 0.1 * 2 + v_Base_ex::Vector{Float64} = collect(0:0.005:v_Base_end_ex) + end + function calc_pH_strong(v_Base_added_ex::Float64) #v as elements of the vector v_Base + if v_Base_added_ex*0.1 <= 25*0.1 + c_H_ex::Float64 = ((0.1 * 25 - 0.1 * v_Base_added_ex) / (25 + v_Base_added_ex)) + 10^(-7) + else + c_OH⁻_ex = (0.1 * v_Base_added_ex - 0.1 * 25) / (25 + v_Base_added_ex) + c_H_ex = 10^(-14) / c_OH⁻_ex + end + pH = -log(10, c_H_ex) + end + ######### + pH_total_strong = map(calc_pH_strong, v_Base_ex) + pH_Value_strong = round(calc_pH_strong(pointX_strong), sigdigits=3) + + plot_attrs_strong = ( + legend=:bottomright, + xlabel="Added volume of titrant / [L]", + ylabel="pH-Value", + xlims=(-1,v_Base_end_ex+2), + ylims=(0, 14), + title="Titration curve of 0.1 M HCl against 0.1 M NaOH", + dpi=300 + ) + + plot(v_Base_ex, pH_total_strong, label="titration curve", linewidth=2;plot_attrs_strong...) + scatter!([pointX_strong], [calc_pH_strong(pointX_strong)], label="Equivalence point") +end + +# ╔═╡ 7205b4a5-d032-43c6-8232-a5d3cffb29d6 +md""" +!!! question "Why is the curve shaped like this?" + The shape of the curve can be explained by the logarithmic nature of the pH scale. The pH value of a solution is defined as the *negative decadic logarithm* of the hydronium-ion concentration + + ```math + \mathrm{pH} = -\log{c\mathrm{(H_3O^+)}}. + ``` + + When 90 % of the acid is neutralised, the pH value is changed by one unit. When further 9 % are neutralised and overall 99 % acid is converted, the pH value changes by another unit. Next, only 0.9 % more acid needs to be converted, to change the pH value by another unit. Because of this logarithmic behaviour, the pH value does not change much at the beginning of the titration. As we get closer to the equivalence point, the pH value rises quickly until there is a jump around the equivalence point. Afterwards, the pH level rises because of the added base. +""" + +# ╔═╡ d9adecaa-6ae8-46d4-955f-4a89a82a46c9 +md""" +#### Strong and Medium-strong Acids +""" + +# ╔═╡ 9264917e-724d-4220-bbee-ec026285e475 +md""" +Lets take a look at weaker acids like acetic acid (``\mathrm{CH_3COOH}``). As mentioned before, they do not dissociate completly, but an equilibrium + +```math +\mathrm{CH_3COOH} + \mathrm{H_2O} \longleftrightarrow \mathrm{CH_3COO^-} + \mathrm{H_3O^+} +``` + +is formed. As every equilibrium, it can be described by an equilibrium constant ``K``. In the case of an acid, it is called the acid constant ``K_{\mathrm{a}}``. As seen before, while the concentration of hydronium-ions is often represented by the negative decadic logarithm, in the same fashion ``K_{\mathrm{a}}`` is often represented as + +```math +\mathrm{p}K\mathrm{_a} = -\log{K_{\mathrm{a}}}. +``` + +These constants describe the strength of the acids. The lower the ``\mathrm{p}K\mathrm{_a}``, the stronger the acid. The classification of acids is as follows: very strong acids: ``\mathrm{p}K\mathrm{_a} < 0``, strong acids: ``0 < \mathrm{p}K\mathrm{_a} < 3`` and medium-strong acids: ``3 < \mathrm{p}K\mathrm{_a} < 7``. +""" + +# ╔═╡ 4882a030-f1d6-4b8b-a86f-a20e64fe4a6c +md""" +Here is a table with some monoprotonic acids and their ``\mathrm{p}K\mathrm{_a}`` values. + +| Acid | pKa | +| ---------------------- |:-------:| +| ``\mathrm{HClO_4}`` | ``-10`` | +| ``\mathrm{HCl}`` | ``-6`` | +| ``\mathrm{HSO_4^-}`` | ``1.92``| +| ``\mathrm{HNO_{2}}`` | ``3.15``| +| ``\mathrm{HF}`` | ``3.17``| +| ``\mathrm{HCOOH}`` | ``3.75``| +| ``\mathrm{CH_{3}COOH}``| ``4.76``| +""" + +# ╔═╡ 733fe755-796d-41db-883a-cfc8d7d077a4 +md""" +Let's compare the titration curve below for acetic acid with the titration curve for hydrochloric acid + +!!! info "Differences between titration curves for strong and weak acids" + + 1) The pH value at the **start** is higher, although in both cases the starting concentration of the acid is ``c_0\mathrm{(HA)} = 0.1~\mathrm{M}``. Of course, this is the case because the weaker acid does not dissociate completly and forms less hydronium ions with water. + + 2) After the curve rises, there is a flat section where the pH value does not change much by adding the base. This is the **buffer region** of the titration. Adding NaOH to the analyte solution leads to the formation of a sodium acetate solution (`` \mathrm{Na^+} + \mathrm{^-OOCCH_3}``), where the acetate anion is the conjugated base to acetic acid. Solutions consisting of a weak acid and its conjugated base are called buffer solutions. Further added acids or bases dont react with water or hydronium ions to further change the pH value, but react with the pair of weak acid and conjugated base first. The pH value in this region is described by the *Henderson-Hasselbalch equation*\ + ```math + \mathrm{pH} = \mathrm{p}K_{\mathrm{a}} + \log{\frac{c(\mathrm{A^-})}{c(\mathrm{HA})}}. + ``` + 3) In the middle of the buffer region, there is a point where ``c(\mathrm{A^-}) = c(\mathrm{HA})``. The argument of the logarithm becomes one and therefore the logarithmic term becomes zero. This is the **half equivalence point**, where ``\mathrm{pH} = \mathrm{p}K_{\mathrm{a}}``. + + 4) When the **equivalence point** is reached and acetic acid is completly converted to sodium acetate, the resulting solution is slightly basic, because acetate anions act as a weak base. For stronger conjugated bases or solutions of a higher concentration, the pH value at the equivalence point would be higher. + + 5) The section after the equivalence point does not differ much from the curve shown before, as in both cases ``\mathrm{NaOH}`` solution was added to a neutralised solution. +""" + +# ╔═╡ 6ba1348c-3cca-46a4-b109-bfb90f7ef7f2 +begin + pKa_ex = 4.75 + Ka_ex = 10^(-pKa_ex) + pKb_ex = 14 - pKa_ex + Kb_ex = 10^(-pKb_ex) + + c0_H⁺_ex::Float64 = -Ka_ex/2 + sqrt(Ka_ex^2 / 4 + Ka_ex*0.1) #The starting concentration for protons (at the same time for the deprotonated acid) + c0_OH⁻_ex::Float64 = -Kb_ex/2 + sqrt(Kb_ex^2 / 4 + Kb_ex*0.1) # Concentration of OH⁻ at the equivalence point (EP), after the weak acid is completly neutralised + function calc_pH_weak(v_Base_added_ex) + if v_Base_added_ex == 0.0 #at the starting point + pH = -log(10, c0_H⁺_ex) + elseif round((0.1 - c0_H⁺_ex)*25, digits=3) > round(0.1*v_Base_added_ex, digits=3) #between starting point and EP + c_H⁺ = Ka_ex*(0.1*25/(c0_H⁺_ex*25+0.1*v_Base_added_ex) - 1) + pH = -log(10, c_H⁺) + elseif round((0.1-c0_H⁺_ex)*25, digits=3) == round(0.1*v_Base_added_ex, digits=3) #at the EP + pH = 14 - (-log(10, c0_OH⁻_ex)) + elseif round((0.1-c0_H⁺_ex)*25, digits=3) < round(0.1*v_Base_added_ex, digits=3) #after the EP + c_OH⁻ = (0.1 * v_Base_added_ex - ((0.1-c0_H⁺_ex) * 25)) / (25 + v_Base_added_ex) + c0_OH⁻_ex + c_H⁺ = 10^(-14) / c_OH⁻ + pH = -log(10, c_H⁺) + end + end + ######## Get the equivalence point saved globally + half_equivalence_volume_ex = 0 + equivalence_volume_ex = 0 + for i in v_Base_ex + if round(0.1*25/(c0_H⁺_ex*25+0.1*i), digits=3) == 2.000 + global half_equivalence_volume_ex = i + elseif round((0.1-c0_H⁺_ex)*25, digits=3) == round(0.1*i, digits=3) + global equivalence_volume_ex = i + end + end + ######### + pH_total_weak = map(calc_pH_weak, v_Base_ex) + pH_Value_weak = round(calc_pH_weak(equivalence_volume_ex), sigdigits=3) + + plot_attrs_weak = ( + legend=:bottomright, + xlabel="Added volume of titrant / [L]", + ylabel="pH-Value", + xlims=(-1,v_Base_end_ex+2), + ylims=(0, 14), + title=latexstring("\$\\mathrm{Titration~curve~of~0.1~M~CH_3COOH~against~0.1~M~NaOH}\$"), + dpi=300 + ) + + plot(v_Base_ex, pH_total_weak, label="titration curve", linewidth=2;plot_attrs_weak...) + scatter!([equivalence_volume_ex], [calc_pH_weak(equivalence_volume_ex)], label="Equivalence point") + scatter!([half_equivalence_volume_ex], [calc_pH_weak(half_equivalence_volume_ex)], label="Half equivalence point") +end + +# ╔═╡ 975a203f-e2d8-4f21-a4af-62212c7a9423 +md""" +### Indicators +""" + +# ╔═╡ 7f5a2d2a-62fe-4985-b0fb-8559d9124801 +md""" +Another way of determining the equivalence point is by using a pH indicator. These are chemical compounds which change colour depending on the pH value of their environement. Every indicator changes colour at a characteristic pH range. +""" + +# ╔═╡ ffe30f1b-cde3-4f41-ac69-70f4d2634b3a +begin + df_color_grad = DataFrame(Dict( + "Indicator" => [L"\text{Methyl orange}", L"\text{Litmus}", L"\text{Bromothymol blue}", L"\text{Phenolphthalein}", L"\text{Alizarin yellow}"], + "pH range" => [L"3.1 - 4.4", L"5.0 - 8.0", L"6.0 - 7.6", L"8.3 - 10.0", L"10.1 - 12.0"], + "Change in color" => [cgrad([:orange, :red]), cgrad([:red, :blue]), cgrad([:yellow, :blue]), cgrad([:white, :magenta]), cgrad([:yellow, :red])] + )) + + desired_order_grad = ["Indicator", "pH range", "Change in color"] + df_color_grad = df_color_grad[:, desired_order_grad] +end + +# ╔═╡ b3420e1d-413e-463b-9bed-ac6182ce863a +md""" +Indicators themselves are weak organic acids which form conjugated acid-base pairs, where acid and base are of different colors. +As shown before for weak acids, an equilibrium is formed and it shifts when changing the pH value of the environment. +In the following picture, the acid-base pair for the indicator methyl red can be seen. +""" + +# ╔═╡ 512a3218-e9e9-482e-b0b0-59650ea55fd1 +Resource( + "https://i.imgur.com/LxB3LeP.png", + :alt => "Structure of the corresponding aci-base pair of the indicator methyl red.", + :width => 700 +) + +# ╔═╡ 724c61e2-7237-4f3e-ab30-655164288aaf +md""" +To see the color of either the acid or base distinctively, one of them has to be present in tenfold excess. +This is the reason why indicators change their colors inside a range of pH values and not at a single pH value, as this big change in concentrations is necessary. +However, that is not a problem. +As can be seen in the titration curves before, the jump in pH around the equivalence point is usually large enough. +""" + +# ╔═╡ cd5bcc78-ad78-40c8-9356-140a04ea1a69 +md""" +## Interactive Titration Curve +""" + +# ╔═╡ 7c465102-7d68-4827-bd8e-ed8e8ef0e303 +md""" +The table with some monoprotonic acids and their ``\mathrm{p}K\mathrm{_a}`` values is shown here again. +""" + +# ╔═╡ fa8df29f-be0a-498d-8fac-4cbe016f034a +begin + latexacids = [L"\mathrm{HClO_4}",L"\mathrm{HCl}",L"\mathrm{HSO_4^-}",L"\mathrm{HNO_{2}}",L"\mathrm{HF}",L"\mathrm{HCOOH}",L"\mathrm{CH_{3}COOH}"] + stringacids = ["HClO4","HCl","HSO4-","HNO2","HF","HCOOH","CH3COOH"] + acidmap = Dict(s => l for (s,l) in zip(stringacids, latexacids)) + df = DataFrame(Dict("Acid" => latexacids, "pKa" => [-10.0,-6.0,1.92,3.15,3.17,3.75,4.76])) +end + +# ╔═╡ eb8979e7-b163-435d-a909-f020194ffc15 +md""" +Here you can choose from one of the given acids. +""" + +# ╔═╡ 563df061-7e97-4745-b101-cf4aa200da60 +@bind Acid Select(stringacids) + +# ╔═╡ 7cab03c4-048d-4df7-a3a5-b20dfd1e6e9d +md""" +### Control the Added Volume and Check the Indicators +""" + +# ╔═╡ f2b5c3e7-29c1-4f7b-82bb-cfa8da90d494 +md""" +Here you can track the titration by visualising the point in the titration curve at a given added volume of titrant. The slider can also be controlled with the arrow keys for more precise control, which is most iomportant around the equivalence point. +""" + +# ╔═╡ a7e6ac40-51bd-46d7-a21c-ad294fa23d5a +md""" +#### Exercises I +""" + +# ╔═╡ ab20be4e-d214-4c0e-85df-c293724c978e +md""" +1) Take a look at the titration of a strong acid (e.g. HCl) against NaOH and add the base step by step with the slider. Which indicators can you use for the titration and which are not suitable? Just like in the lab, at which stages can you add the titrant faster and at which point should you add the base more slowly and carefully? +2) Now take a look at the titration of a weak acid (e.g. acetic acid) against NaOH. Check again, which indicators are usable for this titration. Did it change compared to the titration against a strong acid? +3) Now try the other acids. Are there differences between medium-strong acids or do they behave the same? +""" + +# ╔═╡ fa5deb25-ee07-4917-bf57-595bced01394 +md""" +### Adjust the Settings +""" + +# ╔═╡ 1a229a8e-2378-4aff-871f-69446b9a4dd2 +md""" +Here you can experiment with some parameters and how they change the titration curve. +""" + +# ╔═╡ 006a4f14-2cd1-439f-8b64-aab99601aba8 +md"To plot a titration curve, you need to know the concentration of the acid you are analysing. It is always important to keep the units in mind! Here you can write it down in ``\frac{\text{mol}}{\text{L}}``. Of course in an analytical titration, this is the value you don't know and need to find out." + +# ╔═╡ 41536d79-8949-42ea-971c-8069918c455d +@bind c0_Acid_string TextField(default="0.1") + +# ╔═╡ 1462be43-386b-4f9a-bae0-304fd058dd93 +md"Additionally, you need to know the volume of the solution you are analysing, which you can write down here in ``\text{mL}``." + +# ╔═╡ 95b20797-e804-4c15-b0d0-7aeb36540234 +@bind v0_Acid_string TextField(default="25") # in mL + +# ╔═╡ 5b088b11-f0af-461a-bc92-61fbfed0e768 +md""" +Next, you need to know the concentration of your titrant, in this example the base, also in ``\frac{\text{mol}}{\text{L}}``. +""" + +# ╔═╡ 2e016b07-2ac0-4fd0-9c0a-3062616666f3 +@bind c0_Base_string TextField(default="0.1") + +# ╔═╡ 8af4355b-b5cf-4017-a660-0b0ca884ad95 +md""" +#### Exercises II +""" + +# ╔═╡ 38c319e0-0124-41fa-9910-173e645e7d03 +md""" +1) Change the concetration of the analyte. What changes in the curve and what stays the same? Can you see any proportionality ("If I double the concentration, [...] is doubled / halved")? +""" + +# ╔═╡ 3b77b70e-be0b-46a7-948d-7289fcc72924 +details("Hint", +md""" +Keep an eye out for the scaling on the x-axis!! +""" +) + +# ╔═╡ 05063b3d-8769-4d54-ad70-f38e95dca7a3 +md""" +2) Before you change the volume of the analyte, try to predict how the curve changes. Now change the volume and check the curve again Look out for proportionalities! +""" + +# ╔═╡ 38ba4eb9-4cd1-41d1-8b14-e07b3c76be3b +md""" +3) Finally, let's take a look at the concentration of the titrant. Try to make a prediction, how it affects the curve and check it afterwards in the same way as before. +""" + +# ╔═╡ d2fe14b6-59a9-4b9d-9028-3c9f41e91d1c +md""" +## Appendix +""" + +# ╔═╡ 76baa379-4a48-4268-871e-9e68db92c528 +md""" +### Modelling the Titration Curve for Strong Acids +""" + +# ╔═╡ d2323592-e4eb-4ac1-ab86-741910e1738c +md""" +At the beginning (no Base added), the acid dissociates completly and the concentration of hydronium ions is +```math + c_0\mathrm{(H_3O^+)} = c_0\mathrm{(HA)} +``` +and therefore the pH value is +```math + \mathrm{pH} = -\log{c_0\mathrm{(H_3O^+)}}. +``` +The concentration is given in the unit ``\mathrm{\frac{mol}{L}}``. +""" + +# ╔═╡ 241fc16e-d252-4ef8-8e6d-267fc327ee88 +details("Unit of the logarithms argument", +md""" +The argument of a logarithm needs to be a dimensionless quantitiy. When using concentrations, the exact description would be +```math + \mathrm{pH} = -\log{\frac{c_0\mathrm{(H_3O^+)}}{c^0}}. +``` +To be even more precise, the **activity** of ``\mathrm{H_3O^+}`` should be used. +```math + \mathrm{pH} = -\log{a\mathrm{(H_3O^+)}}. +``` + +It is a dimensionless quantity, somtetimes called "effective concentration" and considers intermolecular interactions of ions in solution. For further information, click [here](https://en.wikipedia.org/wiki/Thermodynamic_activity) or look into a general chemistry textbook. +""" +) + +# ╔═╡ c1799961-2ae2-4fb0-8934-55fc2a16cc7e +md""" +As we only consider a strong base (NaOH), we can also define +```math + c_0\mathrm{(OH^-)} = c_0\mathrm{(NaOH)}. +``` +While base is added, we need to consider how much hydronium ions are converted. +The easiest way is to consider the amount of substance +```math + n\mathrm{(H_3O^+)} = c\mathrm{(H_3O^+)} * V_{\mathrm{total}} +``` +in the unit ``\text{mol}``. The amount of substance of the added ``\mathrm{OH^-}`` can at any point be written as +```math + n\mathrm{(OH^-)} = c_0\mathrm{(NaOH)} * V_{\text{added}}\mathrm{(NaOH)}. +``` + +Because the hydronium ions are directly converted, the amount of substance between starting point and equivalence point can be written as + +```math +\begin{align} +n\mathrm{(H_3O^+)} &= n_0\mathrm{(H_3O^+)} - n_{\text{added}}\mathrm{(NaOH)} \\ + &= c_0\mathrm{(H_3O^+)} * V_0{\mathrm{(HA)}} - c_0\mathrm{(NaOH)} * V_{\text{added}}\mathrm{(NaOH)}. +\end{align} +``` +To convert the amount of substance into a concentration c``\mathrm{(H_3O^+)}`` to calculate the pH at any given point between starting point and equivalence point, it needs to be divided by the total volume +```math + V_{\mathrm{total}} = V_0{\mathrm{(HA)}} + V_{\text{added}}\mathrm{(NaOH)}, +``` +resulting in the expression +```math +c\mathrm{(H_3O^+)} = \frac{c_0\mathrm{(H_3O^+)} * V_0{\mathrm{(HA)}} - c_0\mathrm{(NaOH)} * V_{\text{added}}\mathrm{(NaOH)}}{V_0{\mathrm{(HA)}} + V_{\text{added}}\mathrm{(NaOH)}}. +``` +The only thing left to consider is the autoprotolysis of water, which can be neglected at high concentrations of ``\mathrm{H_3O^+}``, but needs to be considered for lower concentrations starting at roughly ``10^{-5}~\mathrm{\frac{mol}{L}}``. Although it is not correct, as an approximation it works to add ``10^{-7}~\mathrm{\frac{mol}{L}}`` to the expression above to account for ``c\mathrm{(H_3O^+)}`` at a neutral pH, as for higher concentrations the presence of this term is easily neglectable. + +Finally, we arrive at the expression used in the function for +```math +c\mathrm{(H_3O^+)} = \frac{c_0\mathrm{(H_3O^+)} * V_0{\mathrm{(HA)}} - c_0\mathrm{(NaOH)} * V_{\text{added}}\mathrm{(NaOH)}}{V_0{\mathrm{(HA)}} + V_{\text{added}}\mathrm{(NaOH)}} + 10^{-7}~\mathrm{\frac{mol}{L}}. +``` +between the starting point and equivalence point. + +""" + +# ╔═╡ 874bdbe5-d512-4566-9780-b78f141a8ba0 +md""" +After the equivalence point, we are looking at a neutral solution and further adding the base leads to a diluted basic solution. Therefore, it is easier to talk about he concentration of ``\mathrm{OH^-}`` and convert it to ``c\mathrm{(H_3O^+)}`` afterwards by using the autoprotolysis of water +```math + K_{\mathrm{w}} = 10^{-14} = c\mathrm{(H_3O^+)} * c\mathrm{(OH^-)}. +``` +The concentration of ``\mathrm{OH^-}`` after the equivalence point can be written as +```math + c\mathrm{(OH^-)} = \frac{c_0\mathrm{(NaOH)} * V_{\text{added}}\mathrm{(NaOH)} - c_0\mathrm{(H_3O^+)} * V_0{\mathrm{(HA)}}}{V_0{\mathrm{(HA)}} + V_{\text{added}}\mathrm{(NaOH)}} +``` +and converted to +```math + c\mathrm{(H_3O^+)} = \frac{c\mathrm{(OH^-)}}{10^{-14}}. +``` +Alternatively, the pOH value can be calculated in the same way as pH values are calculated. The pOH can be transformed into the pH value with +```math +\mathrm{pOH} = 14 - \mathrm{pH}, +``` +based on the autoprotolysis of water. +""" + +# ╔═╡ 4811fcde-5bfa-4c45-a32f-d39343651c90 +md""" +### Modelling the Titration Curve for Medium-strong and Weak Acids +""" + +# ╔═╡ 587040b9-c31a-4900-8b5d-26bf7000c570 +md""" +#### At the Starting Point +""" + +# ╔═╡ c780180d-4ca9-464c-9d14-74f9ce5c4501 +md""" +When no Base was added. +""" + +# ╔═╡ 70ccb345-b0bc-456f-bda8-79a501059e6a +md""" +##### Expression for ``c\mathrm{(H_3O^+)}`` +""" + +# ╔═╡ 50437455-4784-43ff-ac9c-5abdb43787fe +md""" +The concentration of hydronium ions of medium-strong and weak acids is given as +```math +c_0\mathrm{(H_3O^+)} = -\frac{K_{\mathrm{a}}}{2} + \sqrt{\frac{K_{\mathrm{a}}^2}{4} + K_{\mathrm{a}} * c_0{\mathrm{(HA)}}}. +``` +Now the acid constant needs to be considered because of the equilibrium +```math +\mathrm{HA} + \mathrm{H_2O} \longleftrightarrow \mathrm{A^-} + \mathrm{H_3O^+} +``` +and the incomplete dissociation of the acid. +""" + +# ╔═╡ ba25c716-b754-4887-b3b9-b85dba0f90d2 +md""" +#### Between Starting Point and Equivalence Point +""" + +# ╔═╡ 8bc4224f-0142-448c-be95-98cbb160071c +md""" +While +```math +\begin{align} +n_0\mathrm{(HA)} &> n_{\mathrm{added}}\mathrm{(OH^-)} \\ +(c_0\mathrm{(HA)} - c_0\mathrm{(H_3O^+)}) * V_0\mathrm{(HA)} &> c_0\mathrm{(NaOH)} * V_{\text{added}}\mathrm{(NaOH)} +\end{align} +``` +""" + +# ╔═╡ fb20a23a-4102-4ee3-a73f-64c2640b0adb +md""" +##### Expression for ``c\mathrm{(H_3O^+)}`` +""" + +# ╔═╡ a27a4577-151d-45c0-9675-288076d2da59 +md""" +With the definition of ``K_{\mathrm{a}}`` out of the law of mass action +```math +K_{\mathrm{a}} = \frac{c\mathrm{(A^-)} * c\mathrm{(H_3O^+)}}{c\mathrm{(HA)}}, +``` +we get for the concentration of hydronium ions +```math +c\mathrm{(H_3O^+)} = K_{\mathrm{a}} * \frac{c\mathrm{(HA)}}{c\mathrm{(A^-)}}. +``` +The concentration of acid at any given point can also be written as ``c\mathrm{(HA)} = c_0\mathrm{(HA)} - c\mathrm{(A^-)}``, thus +```math +\begin{align} +c\mathrm{(H_3O^+)} &= K_{\mathrm{a}} * \frac{c_0\mathrm{(HA)} - c\mathrm{(A^-)}}{c\mathrm{(A^-)}} \\ +&= K_{\mathrm{a}} * \left(\frac{c_0\mathrm{(HA)}}{c\mathrm{(A^-)}} - 1\right). +\end{align} +``` +As only the ratio of concentrations is important here, it can easily be converted to a molar ratio +```math +\frac{c_0\mathrm{(H_3O^+)}}{c\mathrm{(A^-)}} = \frac{\frac{n_0\mathrm{(H_3O^+)}}{V_{\mathrm{total}}}}{\frac{n\mathrm{(A^-)}}{V_{\mathrm{total}}}} = \frac{n_0\mathrm{(H_3O^+)}}{n\mathrm{(A^-)}} +``` +and the expression above turns to +```math +c\mathrm{(H_3O^+)} = K_{\mathrm{a}} * \left(\frac{n_0\mathrm{(HA)}}{n\mathrm{(A^-)}} - 1\right). +``` +The amount of substance of acid at the starting point can easily be expressed by +```math +n_0\mathrm{(HA)} = c_0\mathrm{(HA)} * V_0\mathrm{(HA)}. +``` +""" + +# ╔═╡ 631559da-b114-4932-a031-c555ac56b3bf +md""" +##### Expression for ``n\mathrm{(A^-)}`` +""" + +# ╔═╡ 3f7feb3d-99db-4b5e-a7e5-4f26c9c5ae68 +md""" +As for the deprotonated acid ``\mathrm{A^-}``, we need to consider the amount of substance at the beginning ``n_0\mathrm{(A^-)}`` caused by the equilibrium shown above and additionally the amount of substance formed by the deprotonation of acid ``n_{\mathrm{d}}\mathrm{(A^-)}`` with the added base +```math +\mathrm{HA} + \mathrm{NaOH} \longleftrightarrow \mathrm{Na^+} + \mathrm{A^-} + \mathrm{H_2O}. +``` +Consequently, we can write +```math +n\mathrm{(A^-)} = n_0\mathrm{(A^-)} + n_{\mathrm{d}}\mathrm{(A^-)}. +``` +""" + +# ╔═╡ 975f4b7b-d6a4-4d72-96cc-90832ef22db4 +md""" +Note, that when ``\mathrm{HA}`` reacts with water at the beginning, it forms ``\mathrm{A^-}`` and ``\mathrm{H_3O^+}`` with the same amount +```math +n_0\mathrm{(A^-)} = n_0\mathrm{(H_3O^+)} +``` +and can be written as +```math +n_0\mathrm{(A^-)} = c_0\mathrm{(H_3O^+)} * V_0\mathrm{(HA)} +``` +with the expression for ``c_0\mathrm{(H_3O^+)}`` from the starting point. +""" + +# ╔═╡ 8818efcf-704c-41c2-b0b4-b9da3ce53205 +md""" +When ``\mathrm{HA}`` reacts with ``\mathrm{NaOH}``, the base is completly converted to ``\mathrm{H_2O}`` and ``\mathrm{Ac^-}``. Therefore, ``n_{\mathrm{d}}\mathrm{(A^-)}`` can be written as +```math +n_{\mathrm{d}}\mathrm{(A^-)} = c_0\mathrm{(NaOH)} * V_{\mathrm{added}}\mathrm{(NaOH)}. +``` +In summary, the amount of substance of deprotonated acid at any given point is +```math +n\mathrm{(A^-)} = c_0\mathrm{(H_3O^+)} * V_0\mathrm{(HA)} + c_0\mathrm{(NaOH)} * V_{\mathrm{added}}\mathrm{(NaOH)} +``` +and thus, the concentration of hydronium ions between the starting point and equivalence point is +```math +c\mathrm{(H_3O^+)} = K_{\mathrm{a}} * \left(\frac{c_0\mathrm{(H_3O^+)} * V_0\mathrm{(HA)}}{c_0\mathrm{(H_3O^+)} * V_0\mathrm{(HA)} + c_0\mathrm{(NaOH)} * V_{\mathrm{added}}\mathrm{(NaOH)}} - 1\right). +``` +""" + +# ╔═╡ adc9907a-a224-4400-99e8-5fb6e385adfc +md""" +#### At the Equivalence Point +""" + +# ╔═╡ 5834c3bb-be94-4103-817c-4102bad491cf +md""" +When +```math +\begin{align} +n_0\mathrm{(HA)} &= n_{\mathrm{added}}\mathrm{(OH^-)} \\ +(c_0\mathrm{(HA)} - c_0\mathrm{(H_3O^+)}) * V_0\mathrm{(HA)} &= c_0\mathrm{(NaOH)} * V_{\text{added}}\mathrm{(NaOH)} +\end{align} +``` +""" + +# ╔═╡ 8435c139-ec9b-4ab1-82fc-4f0a20073f81 +md""" +##### Expression for ``c\mathrm{(H_3O^+)}`` +""" + +# ╔═╡ 7e8946ca-8168-4b3a-851b-1e4458c6be77 +md""" +At the equivalence point, the salt of the medium-strong or weak acid remains, which is itself a medium-strong or weak base. Therefore, the concetration of hydroxy ions can be calculated with +```math +c_0\mathrm{(OH^-)} = -\frac{K_{\mathrm{b}}}{2} + \sqrt{\frac{K_{\mathrm{b}}^2}{4} + K_{\mathrm{b}} * c_0{\mathrm{(A^-)}}}, +``` +from which then the pOH and thus the pH value can be calculated or it can first be converted to the concentration of hydonium ions as can be seen in the case of strong acids. +""" + +# ╔═╡ 5e2cdf07-4cf4-4347-a10d-58322aee46eb +md""" +#### After the Equivalence Point +""" + +# ╔═╡ eabac306-fca3-42d4-add8-29c053e5f97d +md""" +When +```math +\begin{align} +n_0\mathrm{(HA)} &< n_{\mathrm{added}}\mathrm{(OH^-)} \\ +(c_0\mathrm{(HA)} - c_0\mathrm{(H_3O^+)}) * V_0\mathrm{(HA)} &< c_0\mathrm{(NaOH)} * V_{\text{added}}\mathrm{(NaOH)} +\end{align} +``` +""" + +# ╔═╡ ab27ac5f-8e35-4c90-bbc5-e60bf699281d +md""" +##### Expression for ``c\mathrm{(OH^-)}`` +""" + +# ╔═╡ c44d318d-a710-4adb-acac-fd7f0f53cec3 +md""" +This is almost the same as for strong acids with some minor differences. Firstly, the amount of substance of ``\mathrm{OH^-}`` from the added base is calculated slightly differently with +```math +\begin{align} + c_{\mathrm{A}}\mathrm{(OH^-)} &= \frac{n_{\mathrm{added}}\mathrm{(OH^-)} - n_0\mathrm{(HA)}}{V_{\mathrm{total}}} \\ + &= \frac{c_0\mathrm{(NaOH)} * V_{\text{added}}\mathrm{(NaOH)} - (c_0\mathrm{(HA)} - c_0\mathrm{(H_3O^+)}) * V_0\mathrm{(HA)}}{V_0\mathrm{(HA)} + V_{\text{added}}\mathrm{(NaOH)}} +\end{align} +``` +""" + +# ╔═╡ 4b5214a5-e35f-431a-9f3e-63eff56d1f45 +md""" +Secondly, the concentration of hydroxyde from the weak base present at the equivalence point needs to be additionally considered. +```math +c_{\mathrm{B}}\mathrm{(OH^-)} = -\frac{K_{\mathrm{b}}}{2} + \sqrt{\frac{K_{\mathrm{b}}^2}{4} + K_{\mathrm{b}} * c_0{\mathrm{(A^-)}}} +``` +In total, we get the expression +```math +\begin{align} +c\mathrm{(OH^-)} =& c_{\mathrm{A}}\mathrm{(OH^-)} + c_{\mathrm{B}}\mathrm{(OH^-)} \\ + =& \frac{c_0\mathrm{(NaOH)} * V_{\text{added}}\mathrm{(NaOH)} - (c_0\mathrm{(HA)} - c_0\mathrm{(H_3O^+)}) * V_0\mathrm{(HA)}}{V_0\mathrm{(HA)} + V_{\text{added}}\mathrm{(NaOH)}} \\ + &-\frac{K_{\mathrm{b}}}{2} + \sqrt{\frac{K_{\mathrm{b}}^2}{4} + K_{\mathrm{b}} * c_0{\mathrm{(A^-)}}} +\end{align} +``` +""" + +# ╔═╡ 435fb7e5-4afd-4c37-b21a-9dd1935c4fe2 +md""" +## Code +""" + +# ╔═╡ 1a9060ae-f257-4892-881a-09c7e7b71747 +md""" +### Packages & Table of Contents +""" + +# ╔═╡ ffc3c232-12c1-408a-af0a-25fadb418a21 +PlutoUI.TableOfContents(include_definitions=true) + +# ╔═╡ d67aad9b-1b53-48e1-bb39-82a2ac52b17c +md""" +### Defining Variables and Functions +""" + +# ╔═╡ 50caa04e-880d-4224-90b4-0a8d9004576b +md""" +#### Titration Curve +""" + +# ╔═╡ 41bed3bd-75f9-4b1a-9ea8-786b338b7503 +#Defining constants and parameters (Acid and Base constants, concentrations and volumes) +begin + pKa = filter(row -> row."Acid" == acidmap[Acid], df)."pKa"[1] + Ka = 10^(-pKa) + pKb = 14 - pKa + Kb = 10^(-pKb) + c0_Acid = parse(Float64, c0_Acid_string) + v0_Acid = parse(Float64, v0_Acid_string) + c0_Base = parse(Float64, c0_Base_string) + v_Base_end = v0_Acid * c0_Acid / c0_Base * 2 + v_Base::Vector{Float64} = collect(0.0:0.005:v_Base_end) + if pKa <= 0 #Very strong acids + c0_H⁺::Float64 = c0_Acid*v0_Acid + c0_OH⁻::Float64 = 10^(-7) + else #Medium-strong and weak acid + c0_H⁺::Float64 = -Ka/2 + sqrt(Ka^2 / 4 + Ka*c0_Acid) #The starting concentration for protons (at the same time for the deprotonated acid) + c0_OH⁻::Float64 = -Kb/2 + sqrt(Kb^2 / 4 + Kb*c0_Acid) # Concentration of OH⁻ at the EP, after the weak acid is completly neutralised + end +end; nothing + +# ╔═╡ 831198d1-d22c-42b5-a198-3bd34139eb0e +@bind pointX Slider(0.0:0.05:v_Base_end) + +# ╔═╡ af04638c-2615-4195-a45e-d6d85af6d6cd +# define Functions +begin + function calc_pH(v_Base_added::Float64)#v as the elements of the vector v_Base + if pKa <= 1.74 #for very strong acids + if v_Base_added*c0_Base <= v0_Acid*c0_Acid #until the equivalence point (EP) is reached + c_H⁺::Float64 = ((c0_Acid * v0_Acid - c0_Base * v_Base_added) / (v0_Acid + v_Base_added)) + 10^(-7) + else #after the EP + c_OH⁻::Float64 = (c0_Base * v_Base_added - c0_Acid * v0_Acid) / (v0_Acid + v_Base_added) + c_H⁺ = 10^(-14) / c_OH⁻ + end + pH = -log(10, c_H⁺) + else #for medium-strong and weak acids + if v_Base_added == 0.0 #at the starting point + pH = -log(10, c0_H⁺) + elseif round((c0_Acid - c0_H⁺)*v0_Acid, digits=3) > round(c0_Base*v_Base_added, digits=3) #between starting point and EP + c_H⁺ = Ka*(c0_Acid*v0_Acid/(c0_H⁺*v0_Acid+c0_Base*v_Base_added) - 1) + pH = -log(10, c_H⁺) + elseif round((c0_Acid-c0_H⁺)*v0_Acid, digits=3) == round(c0_Base*v_Base_added, digits=3) #at the EP + pH = 14 - (-log(10, c0_OH⁻)) + elseif round((c0_Acid-c0_H⁺)*v0_Acid, digits=3) < round(c0_Base*v_Base_added, digits=3) #after the EP + c_OH⁻ = (c0_Base * v_Base_added - ((c0_Acid-c0_H⁺) * v0_Acid)) / (v0_Acid + v_Base_added) + c0_OH⁻ + c_H⁺ = 10^(-14) / c_OH⁻ + pH = -log(10, c_H⁺) + end + end + end +end ; nothing + +# ╔═╡ 02c0320c-7c56-4fe5-8f8c-9ab0f733b28e +begin + if pKa < 7.0 + pH_total = map(calc_pH, v_Base) + + pH_Value = round(calc_pH(pointX), sigdigits=3) + + plot_attrs = ( + legend=:bottomright, + xlabel="Added volume of titrant / [mL]", + ylabel="pH-Value", + xlims=(-1,v_Base_end+2), + ylims=(0, 14), + title=latexstring("\$\\mathrm{Titration~curve~of~}", c0_Acid_string, "\\mathrm{M~} ", strip(acidmap[Acid], '$'), "\\mathrm{~against~}", c0_Base_string," \\mathrm{M~NaOH}\$"), + dpi=300 + ) + + plot(v_Base, pH_total, label="titration curve", linewidth=2;plot_attrs...) + scatter!([pointX], [calc_pH(pointX)], label="Current point of titration") + + if pKa <= 1.74 + equivalence_volume = 0.0 + for i in v_Base + if i*c0_Base == v0_Acid*c0_Acid + global equivalence_volume = i + end + end + scatter!([equivalence_volume], [calc_pH(equivalence_volume)], label="Equivalence point") + else + half_equivalence_volume = 0.0 + equivalence_volume = 0.0 + for i in v_Base + if round(c0_Acid*v0_Acid/(c0_H⁺*v0_Acid+c0_Base*i), digits=3) == 2.000 + global half_equivalence_volume = i + elseif round((c0_Acid-c0_H⁺)*v0_Acid, digits=3) == round(c0_Base*i, digits=3) + global equivalence_volume = i + end + end + scatter!([equivalence_volume], [calc_pH(equivalence_volume)], label="Equivalence point") + scatter!([half_equivalence_volume], [calc_pH(half_equivalence_volume)], label="Half equivalence point") + end + else + println("The given pKa-value does not match a strong or weak acid.") + end +end + +# ╔═╡ 9dee0462-b5af-4962-a65b-7ac7b2faf3df +println("At this point, $pointX millilitre of titrant were added. The pH Value of the \nsolution is $pH_Value.") + +# ╔═╡ 8b9e6746-b731-4b39-a0b8-4b9e4c752cc6 +md""" +#### Indicators +""" + +# ╔═╡ 4127a0c7-897b-41c2-9319-2b1c48369699 +begin + begin #The indicators with their pH range and their colors + Methyl_orange = ColorScheme(range(colorant"red", colorant"yellow", length=130)); + Litmus = ColorScheme(range(colorant"red", colorant"blue", length=300)); + Bromothymol_blue = ColorScheme(range(colorant"yellow", colorant"blue", length=160)); + Phenolphthalein = ColorScheme(range(colorant"white", colorant"magenta", length=180)); + Alizarin_yellow = ColorScheme(range(colorant"yellow", colorant"red", length=190)); nothing + end + # Indexing Methyl Orange + if pH_Value < 3.10 + a::Int64 = 1 + elseif 3.10 <= pH_Value < 4.40 + a::Int64 = Int64(round(100*pH_Value - 309)) + elseif pH_Value >= 4.40 + a::Int64 = size(Methyl_orange) + end + # Indexing Litmus + if pH_Value < 5.00 + b::Int64 = 1 + elseif 5.00 <= pH_Value < 8.00 + b::Int64 = Int64(round(100*pH_Value - 499)) + elseif pH_Value >= 8.00 + b::Int64 = size(Litmus) + end + # Indexing Bromothymol Blue + if pH_Value < 6.00 + c::Int64 = 1 + elseif 6.00 <= pH_Value < 7.60 + c::Int64 = Int64(round(100*pH_Value - 599)) + elseif pH_Value >= 7.60 + c::Int64 = size(Bromothymol_blue) + end + # Indexing Phenolphthalein + if pH_Value < 8.30 + d::Int64 = 1 + elseif 8.30 <= pH_Value < 10.00 + d::Int64 = Int64(round(100*pH_Value - 829)) + elseif pH_Value >= 10.00 + d::Int64 = size(Phenolphthalein) + end + # Indexing Alizarin yellow + if pH_Value < 10.10 + e::Int64 = 1 + elseif 10.10 <= pH_Value < 12.00 + e::Int64 = Int64(round(100*pH_Value - 1009)) + elseif pH_Value >= 12.00 + e::Int64 = size(Alizarin_yellow) + end +end; nothing + +# ╔═╡ 6ebfa6d8-b4a7-4d5e-8d3d-ccf0ba596f25 +# Output of the Indicator color in a Dataframe +begin + df_color = DataFrame(Dict( + "Methyl orange" => [Methyl_orange[a]], + "Litmus" => [Litmus[b]], + "Bromothymol blue" => [Bromothymol_blue[c]], + "Phenolphthalein" => [Phenolphthalein[d]], + "Alizarin yellow" => [Alizarin_yellow[e]] + )) + desired_order = ["Methyl orange", "Litmus", "Bromothymol blue", "Phenolphthalein", "Alizarin yellow"] + df_color = df_color[:, desired_order] +end + +# ╔═╡ c59b620d-a6dd-4e19-ac30-5840568efba4 +md""" +##### Alternative +""" + +# ╔═╡ 67136d72-c447-4268-8c17-b6d9ad3652ca +md""" +Constructing a function and using the existing clamp function, instead of constructing multiple if/else blocks. +""" + +# ╔═╡ ab1430fd-ddd9-48d6-94e8-465cea45ff25 +begin + struct IndicatorRange #Define structure which can be applied to every single indicator with color at beginning / end and the pH range + mincolor + maxcolor + minph + maxph + end + + + function getcolorant(range::IndicatorRange, ph) #Using the structure, define function to return the right color at given pH + factor = (ph - range.minph) / (range.maxph - range.minph) #Inside pH range: gives factor between 0 and 1 + + + factor = clamp(factor, 0, 1) #clamps the factor between 0 and 1, shorter than the if/else block for every indicator above + + range.maxcolor * factor + range.mincolor * (1 - factor) #mixes the color according to the factor depending on pH value + end + + range_Methyl_orange = IndicatorRange(colorant"red", colorant"yellow",3.1,4.4) + range_Litmus = IndicatorRange(colorant"red", colorant"blue",5.0,8.0) + range_Bromothymol_blue = IndicatorRange(colorant"yellow", colorant"blue",6.0,7.6) + range_Phenolphtalein = IndicatorRange(colorant"white", colorant"magenta",8.3,10.0) + range_Alizarin_yellow = IndicatorRange(colorant"yellow", colorant"red",10.1,12.0) + +end + +# ╔═╡ 2ffcfcc2-ac5f-4293-bab0-3fede68c115a +begin + df_color_alt = DataFrame(Dict( + "Methyl orange" => [getcolorant(range_Methyl_orange, pH_Value)], + "Litmus" => [getcolorant(range_Litmus, pH_Value)], + "Bromothymol blue" => [getcolorant(range_Bromothymol_blue, pH_Value)], + "Phenolphthalein" => [getcolorant(range_Phenolphtalein, pH_Value)], + "Alizarin yellow" => [getcolorant(range_Alizarin_yellow, pH_Value)] + )) + df_color_alt = df_color_alt[:, desired_order] +end + +# ╔═╡ cec8f377-dc41-41ba-a3b3-d916acba1147 +md""" +## Interested in Contributing? +""" + +# ╔═╡ 4336e057-2a02-47d6-8fd9-e9cf9ec29399 +md""" +If you are interested in contributing, there is still a lot that can be done! Here are some more ideas listed with some estimation of their *difficulty*. But, if you got some ideas of your own, they are more than welcome! + +- Di- and Triprotonic acids as options (*Medium*) + +- Add a curve with a hidden concentration as an exercise; the concentration can be determined with the curve and checked as an input (*Medium*) + +- Enumerate the equations with the ```\tag{}``` option to improve references to specific equations (*Easy*) + +- Titrations against weak bases can be added (*Medium*) + +- Flip acids and bases: Titrations of bases against acids (*Medium*) + +- Contribute to the visualisation: (*hard*) + + - Add animations of erlenmeyer flask with colorful liquids inside, which maybe even change in volume depending on the added titrant + - change the slider to a tab, which can be openedto fill a flask (new widget) + +- Bugfixing: Further testing of the notebook and find errors and fix them (*medium - hard*) +""" + +# ╔═╡ 00000000-0000-0000-0000-000000000001 +PLUTO_PROJECT_TOML_CONTENTS = """ +[deps] +ColorSchemes = "35d6a980-a343-548e-a6ea-1d62b119f2f4" +DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" +Handcalcs = "e8a07092-c156-4455-ab8e-ed8bc81edefb" +LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +PlutoUI = "7f904dfe-b85e-4ff6-b463-dae2292396a8" +StructuralUnits = "ec81c399-378c-4a82-baa1-80fb2fc85b6c" + +[compat] +ColorSchemes = "~3.30.0" +DataFrames = "~1.7.0" +Handcalcs = "~0.5.2" +LaTeXStrings = "~1.4.0" +Plots = "~1.40.19" +PlutoUI = "~0.7.71" +StructuralUnits = "~0.2.0" +""" + +# ╔═╡ 00000000-0000-0000-0000-000000000002 +PLUTO_MANIFEST_TOML_CONTENTS = """ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.12.0" +manifest_format = "2.0" +project_hash = "94328235689df1ba2a15f455dc0426193557e859" + +[[deps.AbstractPlutoDingetjes]] +deps = ["Pkg"] +git-tree-sha1 = "6e1d2a35f2f90a4bc7c2ed98079b2ba09c35b83a" +uuid = "6e696c72-6542-2067-7265-42206c756150" +version = "1.3.2" + +[[deps.AbstractTrees]] +git-tree-sha1 = "2d9c9a55f9c93e8887ad391fbae72f8ef55e1177" +uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c" +version = "0.4.5" + +[[deps.AliasTables]] +deps = ["PtrArrays", "Random"] +git-tree-sha1 = "9876e1e164b144ca45e9e3198d0b689cadfed9ff" +uuid = "66dad0bd-aa9a-41b7-9441-69ab47430ed8" +version = "1.1.3" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.2" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +version = "1.11.0" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.BitFlags]] +git-tree-sha1 = "0691e34b3bb8be9307330f88d1a3c3f25466c24d" +uuid = "d1d4a3ce-64b1-5f1a-9ba4-7e7e69966f35" +version = "0.1.9" + +[[deps.Bzip2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1b96ea4a01afe0ea4090c5c8039690672dd13f2e" +uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" +version = "1.0.9+0" + +[[deps.Cairo_jll]] +deps = ["Artifacts", "Bzip2_jll", "CompilerSupportLibraries_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"] +git-tree-sha1 = "fde3bf89aead2e723284a8ff9cdf5b551ed700e8" +uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a" +version = "1.18.5+0" + +[[deps.CodeTracking]] +deps = ["InteractiveUtils", "UUIDs"] +git-tree-sha1 = "062c5e1a5bf6ada13db96a4ae4749a4c2234f521" +uuid = "da1fd8a2-8d9e-5ec2-8556-3022fb5608a2" +version = "1.3.9" + +[[deps.CodecZlib]] +deps = ["TranscodingStreams", "Zlib_jll"] +git-tree-sha1 = "962834c22b66e32aa10f7611c08c8ca4e20749a9" +uuid = "944b1d66-785c-5afd-91f1-9de20f533193" +version = "0.7.8" + +[[deps.ColorSchemes]] +deps = ["ColorTypes", "ColorVectorSpace", "Colors", "FixedPointNumbers", "PrecompileTools", "Random"] +git-tree-sha1 = "a656525c8b46aa6a1c76891552ed5381bb32ae7b" +uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4" +version = "3.30.0" + +[[deps.ColorTypes]] +deps = ["FixedPointNumbers", "Random"] +git-tree-sha1 = "67e11ee83a43eb71ddc950302c53bf33f0690dfe" +uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" +version = "0.12.1" +weakdeps = ["StyledStrings"] + + [deps.ColorTypes.extensions] + StyledStringsExt = "StyledStrings" + +[[deps.ColorVectorSpace]] +deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "Requires", "Statistics", "TensorCore"] +git-tree-sha1 = "8b3b6f87ce8f65a2b4f857528fd8d70086cd72b1" +uuid = "c3611d14-8923-5661-9e6a-0046d554d3a4" +version = "0.11.0" + + [deps.ColorVectorSpace.extensions] + SpecialFunctionsExt = "SpecialFunctions" + + [deps.ColorVectorSpace.weakdeps] + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.Colors]] +deps = ["ColorTypes", "FixedPointNumbers", "Reexport"] +git-tree-sha1 = "37ea44092930b1811e666c3bc38065d7d87fcc74" +uuid = "5ae59095-9a9b-59fe-a467-6f913c188581" +version = "0.13.1" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "0037835448781bb46feb39866934e243886d756a" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.0" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.Compiler]] +git-tree-sha1 = "382d79bfe72a406294faca39ef0c3cef6e6ce1f1" +uuid = "807dbc54-b67e-4c79-8afb-eafe4df6f2e1" +version = "0.1.1" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.3.0+1" + +[[deps.ConcurrentUtilities]] +deps = ["Serialization", "Sockets"] +git-tree-sha1 = "d9d26935a0bcffc87d2613ce14c527c99fc543fd" +uuid = "f0e56b4a-5159-44fe-b623-3e5288b988bb" +version = "2.5.0" + +[[deps.Contour]] +git-tree-sha1 = "439e35b0b36e2e5881738abc8857bd92ad6ff9a8" +uuid = "d38c429a-6771-53c6-b99e-75d170b6e991" +version = "0.6.3" + +[[deps.Crayons]] +git-tree-sha1 = "249fe38abf76d48563e2f4556bebd215aa317e15" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.1.1" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataFrames]] +deps = ["Compat", "DataAPI", "DataStructures", "Future", "InlineStrings", "InvertedIndices", "IteratorInterfaceExtensions", "LinearAlgebra", "Markdown", "Missings", "PooledArrays", "PrecompileTools", "PrettyTables", "Printf", "Random", "Reexport", "SentinelArrays", "SortingAlgorithms", "Statistics", "TableTraits", "Tables", "Unicode"] +git-tree-sha1 = "fb61b4812c49343d7ef0b533ba982c46021938a6" +uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" +version = "1.7.0" + +[[deps.DataStructures]] +deps = ["Compat", "InteractiveUtils", "OrderedCollections"] +git-tree-sha1 = "4e1fe97fdaed23e9dc21d4d664bea76b65fc50a0" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.18.22" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +version = "1.11.0" + +[[deps.Dbus_jll]] +deps = ["Artifacts", "Expat_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "473e9afc9cf30814eb67ffa5f2db7df82c3ad9fd" +uuid = "ee1fde0b-3d02-5ea6-8484-8dfef6360eab" +version = "1.16.2+0" + +[[deps.DelimitedFiles]] +deps = ["Mmap"] +git-tree-sha1 = "9e2f36d3c96a820c678f2f1f1782582fcf685bae" +uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab" +version = "1.9.1" + +[[deps.DocStringExtensions]] +git-tree-sha1 = "7442a5dfe1ebb773c29cc2962a8980f47221d76c" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.9.5" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.6.0" + +[[deps.EpollShim_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "8a4be429317c42cfae6a7fc03c31bad1970c310d" +uuid = "2702e6a9-849d-5ed8-8c21-79e8b8f9ee43" +version = "0.0.20230411+1" + +[[deps.ExceptionUnwrapping]] +deps = ["Test"] +git-tree-sha1 = "d36f682e590a83d63d1c7dbd287573764682d12a" +uuid = "460bff9d-24e4-43bc-9d9f-a8973cb893f4" +version = "0.1.11" + +[[deps.Expat_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7bb1361afdb33c7f2b085aa49ea8fe1b0fb14e58" +uuid = "2e619515-83b5-522b-bb60-26c02a35a201" +version = "2.7.1+0" + +[[deps.FFMPEG]] +deps = ["FFMPEG_jll"] +git-tree-sha1 = "83dc665d0312b41367b7263e8a4d172eac1897f4" +uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a" +version = "0.4.4" + +[[deps.FFMPEG_jll]] +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "PCRE2_jll", "Zlib_jll", "libaom_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"] +git-tree-sha1 = "3a948313e7a41eb1db7a1e733e6335f17b4ab3c4" +uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5" +version = "7.1.1+0" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.FixedPointNumbers]] +deps = ["Statistics"] +git-tree-sha1 = "05882d6995ae5c12bb5f36dd2ed3f61c98cbb172" +uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" +version = "0.8.5" + +[[deps.Fontconfig_jll]] +deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Zlib_jll"] +git-tree-sha1 = "f85dac9a96a01087df6e3a749840015a0ca3817d" +uuid = "a3f928ae-7b40-5064-980b-68af3947d34b" +version = "2.17.1+0" + +[[deps.Format]] +git-tree-sha1 = "9c68794ef81b08086aeb32eeaf33531668d5f5fc" +uuid = "1fa38f19-a742-5d3f-a2b9-30dd87b9d5f8" +version = "1.3.7" + +[[deps.FreeType2_jll]] +deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "2c5512e11c791d1baed2049c5652441b28fc6a31" +uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7" +version = "2.13.4+0" + +[[deps.FriBidi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7a214fdac5ed5f59a22c2d9a885a16da1c74bbc7" +uuid = "559328eb-81f9-559d-9380-de523a88c83c" +version = "1.0.17+0" + +[[deps.Future]] +deps = ["Random"] +uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" +version = "1.11.0" + +[[deps.GLFW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libglvnd_jll", "Xorg_libXcursor_jll", "Xorg_libXi_jll", "Xorg_libXinerama_jll", "Xorg_libXrandr_jll", "libdecor_jll", "xkbcommon_jll"] +git-tree-sha1 = "fcb0584ff34e25155876418979d4c8971243bb89" +uuid = "0656b61e-2033-5cc2-a64a-77c0f6c09b89" +version = "3.4.0+2" + +[[deps.GR]] +deps = ["Artifacts", "Base64", "DelimitedFiles", "Downloads", "GR_jll", "HTTP", "JSON", "Libdl", "LinearAlgebra", "Preferences", "Printf", "Qt6Wayland_jll", "Random", "Serialization", "Sockets", "TOML", "Tar", "Test", "p7zip_jll"] +git-tree-sha1 = "1828eb7275491981fa5f1752a5e126e8f26f8741" +uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71" +version = "0.73.17" + +[[deps.GR_jll]] +deps = ["Artifacts", "Bzip2_jll", "Cairo_jll", "FFMPEG_jll", "Fontconfig_jll", "FreeType2_jll", "GLFW_jll", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Libtiff_jll", "Pixman_jll", "Qt6Base_jll", "Zlib_jll", "libpng_jll"] +git-tree-sha1 = "27299071cc29e409488ada41ec7643e0ab19091f" +uuid = "d2c73de3-f751-5644-a686-071e5b155ba9" +version = "0.73.17+0" + +[[deps.GettextRuntime_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll"] +git-tree-sha1 = "45288942190db7c5f760f59c04495064eedf9340" +uuid = "b0724c58-0f36-5564-988d-3bb0596ebc4a" +version = "0.22.4+0" + +[[deps.Glib_jll]] +deps = ["Artifacts", "GettextRuntime_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE2_jll", "Zlib_jll"] +git-tree-sha1 = "35fbd0cefb04a516104b8e183ce0df11b70a3f1a" +uuid = "7746bdde-850d-59dc-9ae8-88ece973131d" +version = "2.84.3+0" + +[[deps.Graphite2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "8a6dbda1fd736d60cc477d99f2e7a042acfa46e8" +uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472" +version = "1.3.15+0" + +[[deps.Grisu]] +git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2" +uuid = "42e2da0e-8278-4e71-bc24-59509adca0fe" +version = "1.0.2" + +[[deps.HTTP]] +deps = ["Base64", "CodecZlib", "ConcurrentUtilities", "Dates", "ExceptionUnwrapping", "Logging", "LoggingExtras", "MbedTLS", "NetworkOptions", "OpenSSL", "PrecompileTools", "Random", "SimpleBufferStream", "Sockets", "URIs", "UUIDs"] +git-tree-sha1 = "ed5e9c58612c4e081aecdb6e1a479e18462e041e" +uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3" +version = "1.10.17" + +[[deps.Handcalcs]] +deps = ["AbstractTrees", "CodeTracking", "InteractiveUtils", "LaTeXStrings", "Latexify", "MacroTools", "PrecompileTools", "Revise", "TestHandcalcFunctions"] +git-tree-sha1 = "5325cf7101f688daceab06643391af1dc6d6e0e1" +uuid = "e8a07092-c156-4455-ab8e-ed8bc81edefb" +version = "0.5.2" + +[[deps.HarfBuzz_jll]] +deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll"] +git-tree-sha1 = "f923f9a774fcf3f5cb761bfa43aeadd689714813" +uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566" +version = "8.5.1+0" + +[[deps.Hyperscript]] +deps = ["Test"] +git-tree-sha1 = "179267cfa5e712760cd43dcae385d7ea90cc25a4" +uuid = "47d2ed2b-36de-50cf-bf87-49c2cf4b8b91" +version = "0.0.5" + +[[deps.HypertextLiteral]] +deps = ["Tricks"] +git-tree-sha1 = "7134810b1afce04bbc1045ca1985fbe81ce17653" +uuid = "ac1192a8-f4b3-4bfe-ba22-af5b92cd3ab2" +version = "0.9.5" + +[[deps.IOCapture]] +deps = ["Logging", "Random"] +git-tree-sha1 = "b6d6bfdd7ce25b0f9b2f6b3dd56b2673a66c8770" +uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89" +version = "0.2.5" + +[[deps.InlineStrings]] +git-tree-sha1 = "8f3d257792a522b4601c24a577954b0a8cd7334d" +uuid = "842dd82b-1e85-43dc-bf29-5d0ee9dffc48" +version = "1.4.5" + + [deps.InlineStrings.extensions] + ArrowTypesExt = "ArrowTypes" + ParsersExt = "Parsers" + + [deps.InlineStrings.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Parsers = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.InvertedIndices]] +git-tree-sha1 = "6da3c4316095de0f5ee2ebd875df8721e7e0bdbe" +uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f" +version = "1.3.1" + +[[deps.IrrationalConstants]] +git-tree-sha1 = "e2222959fbc6c19554dc15174c81bf7bf3aa691c" +uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" +version = "0.2.4" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLFzf]] +deps = ["REPL", "Random", "fzf_jll"] +git-tree-sha1 = "82f7acdc599b65e0f8ccd270ffa1467c21cb647b" +uuid = "1019f520-868f-41f5-a6de-eb00f4b6a39c" +version = "0.1.11" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "0533e564aae234aff59ab625543145446d8b6ec2" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.7.1" + +[[deps.JSON]] +deps = ["Dates", "Mmap", "Parsers", "Unicode"] +git-tree-sha1 = "31e996f0a15c7b280ba9f76636b3ff9e2ae58c9a" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "0.21.4" + +[[deps.JpegTurbo_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e95866623950267c1e4878846f848d94810de475" +uuid = "aacddb02-875f-59d6-b918-886e6ef4fbf8" +version = "3.1.2+0" + +[[deps.JuliaInterpreter]] +deps = ["CodeTracking", "InteractiveUtils", "Random", "UUIDs"] +git-tree-sha1 = "6ac9e4acc417a5b534ace12690bc6973c25b862f" +uuid = "aa1ae85d-cabe-5617-a682-6adf51b2e16a" +version = "0.10.3" + +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + +[[deps.LAME_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "059aabebaa7c82ccb853dd4a0ee9d17796f7e1bc" +uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d" +version = "3.100.3+0" + +[[deps.LERC_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "aaafe88dccbd957a8d82f7d05be9b69172e0cee3" +uuid = "88015f11-f218-50d7-93a8-a6af411a945d" +version = "4.0.1+0" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "eb62a3deb62fc6d8822c0c4bef73e4412419c5d8" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "18.1.8+0" + +[[deps.LZO_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1c602b1127f4751facb671441ca72715cc95938a" +uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac" +version = "2.10.3+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "dda21b8cbd6a6c40d9d02a73230f9d70fed6918c" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.0" + +[[deps.Latexify]] +deps = ["Format", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "OrderedCollections", "Requires"] +git-tree-sha1 = "52e1296ebbde0db845b356abbbe67fb82a0a116c" +uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316" +version = "0.16.9" + + [deps.Latexify.extensions] + DataFramesExt = "DataFrames" + SparseArraysExt = "SparseArrays" + SymEngineExt = "SymEngine" + TectonicExt = "tectonic_jll" + + [deps.Latexify.weakdeps] + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SymEngine = "123dc426-2d89-5057-bbad-38513e3affd8" + tectonic_jll = "d7dd28d6-a5e6-559c-9131-7eb760cdacc5" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "0.6.4" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.11.1+1" + +[[deps.LibGit2]] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "OpenSSL_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.9.0+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "Libdl", "OpenSSL_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.3+1" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libffi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "c8da7e6a91781c41a863611c7e966098d783c57a" +uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490" +version = "3.4.7+0" + +[[deps.Libglvnd_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll", "Xorg_libXext_jll"] +git-tree-sha1 = "d36c21b9e7c172a44a10484125024495e2625ac0" +uuid = "7e76a0d4-f3c7-5321-8279-8d96eeed0f29" +version = "1.7.1+1" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.Libmount_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "706dfd3c0dd56ca090e86884db6eda70fa7dd4af" +uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9" +version = "2.41.1+0" + +[[deps.Libtiff_jll]] +deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "LERC_jll", "Libdl", "XZ_jll", "Zlib_jll", "Zstd_jll"] +git-tree-sha1 = "4ab7581296671007fc33f07a721631b8855f4b1d" +uuid = "89763e89-9b03-5906-acba-b20f662cd828" +version = "4.7.1+0" + +[[deps.Libuuid_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d3c8af829abaeba27181db4acb485b18d15d89c6" +uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700" +version = "2.41.1+0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.12.0" + +[[deps.LogExpFunctions]] +deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] +git-tree-sha1 = "13ca9e2586b89836fd20cccf56e57e2b9ae7f38f" +uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +version = "0.3.29" + + [deps.LogExpFunctions.extensions] + LogExpFunctionsChainRulesCoreExt = "ChainRulesCore" + LogExpFunctionsChangesOfVariablesExt = "ChangesOfVariables" + LogExpFunctionsInverseFunctionsExt = "InverseFunctions" + + [deps.LogExpFunctions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ChangesOfVariables = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" + InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.LoggingExtras]] +deps = ["Dates", "Logging"] +git-tree-sha1 = "f02b56007b064fbfddb4c9cd60161b6dd0f40df3" +uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" +version = "1.1.0" + +[[deps.LoweredCodeUtils]] +deps = ["Compiler", "JuliaInterpreter"] +git-tree-sha1 = "b882a7dd7ef37643066ae8f9380beea8fdd89cae" +uuid = "6f1432cf-f94c-5a45-995e-cdbf5db27b0b" +version = "3.4.2" + +[[deps.MIMEs]] +git-tree-sha1 = "c64d943587f7187e751162b3b84445bbbd79f691" +uuid = "6c6e2e6c-3030-632d-7369-2d6c69616d65" +version = "1.1.0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.Markdown]] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MbedTLS]] +deps = ["Dates", "MbedTLS_jll", "MozillaCACerts_jll", "NetworkOptions", "Random", "Sockets"] +git-tree-sha1 = "c067a280ddc25f196b5e7df3877c6b226d390aaf" +uuid = "739be429-bea8-5141-9913-cc70e7f3736d" +version = "1.1.9" + +[[deps.MbedTLS_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "926c6af3a037c68d02596a44c22ec3595f5f760b" +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.28.6+0" + +[[deps.Measures]] +git-tree-sha1 = "c13304c81eec1ed3af7fc20e75fb6b26092a1102" +uuid = "442fdcdd-2543-5da2-b0f3-8c86c306513e" +version = "0.3.2" + +[[deps.Missings]] +deps = ["DataAPI"] +git-tree-sha1 = "ec4f7fbeab05d7747bdf98eb74d130a2a2ed298d" +uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" +version = "1.2.0" + +[[deps.Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" +version = "1.11.0" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2025.5.20" + +[[deps.NaNMath]] +deps = ["OpenLibm_jll"] +git-tree-sha1 = "9b8215b1ee9e78a293f99797cd31375471b2bcae" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "1.1.3" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.3.0" + +[[deps.Ogg_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "b6aa4566bb7ae78498a5e68943863fa8b5231b59" +uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051" +version = "1.3.6+0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.29+0" + +[[deps.OpenLibm_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +version = "0.8.7+0" + +[[deps.OpenSSL]] +deps = ["BitFlags", "Dates", "MozillaCACerts_jll", "OpenSSL_jll", "Sockets"] +git-tree-sha1 = "f1a7e086c677df53e064e0fdd2c9d0b0833e3f6e" +uuid = "4d8831e6-92b7-49fb-bdf8-b643e874388c" +version = "1.5.0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.1+0" + +[[deps.Opus_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "c392fc5dd032381919e3b22dd32d6443760ce7ea" +uuid = "91d4177d-7536-5919-b921-800302f37372" +version = "1.5.2+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "05868e21324cede2207c6f0f466b4bfef6d5e7ee" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.8.1" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.44.0+1" + +[[deps.Pango_jll]] +deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "FriBidi_jll", "Glib_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "275a9a6d85dc86c24d03d1837a0010226a96f540" +uuid = "36c8627f-9965-5494-a995-c6b170f724f3" +version = "1.56.3+0" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools", "UUIDs"] +git-tree-sha1 = "7d2f8f21da5db6a806faf7b9b292296da42b2810" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "2.8.3" + +[[deps.Pixman_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "db76b1ecd5e9715f3d043cec13b2ec93ce015d53" +uuid = "30392449-352a-5448-841d-b1acce4e97dc" +version = "0.44.2+0" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.12.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.PlotThemes]] +deps = ["PlotUtils", "Statistics"] +git-tree-sha1 = "41031ef3a1be6f5bbbf3e8073f210556daeae5ca" +uuid = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a" +version = "3.3.0" + +[[deps.PlotUtils]] +deps = ["ColorSchemes", "Colors", "Dates", "PrecompileTools", "Printf", "Random", "Reexport", "StableRNGs", "Statistics"] +git-tree-sha1 = "3ca9a356cd2e113c420f2c13bea19f8d3fb1cb18" +uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043" +version = "1.4.3" + +[[deps.Plots]] +deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "JLFzf", "JSON", "LaTeXStrings", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "Pkg", "PlotThemes", "PlotUtils", "PrecompileTools", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "RelocatableFolders", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "TOML", "UUIDs", "UnicodeFun", "UnitfulLatexify", "Unzip"] +git-tree-sha1 = "0c5a5b7e440c008fe31416a3ac9e0d2057c81106" +uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +version = "1.40.19" + + [deps.Plots.extensions] + FileIOExt = "FileIO" + GeometryBasicsExt = "GeometryBasics" + IJuliaExt = "IJulia" + ImageInTerminalExt = "ImageInTerminal" + UnitfulExt = "Unitful" + + [deps.Plots.weakdeps] + FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" + GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326" + IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" + ImageInTerminal = "d8c32880-2388-543b-8c61-d9f865259254" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.PlutoUI]] +deps = ["AbstractPlutoDingetjes", "Base64", "ColorTypes", "Dates", "Downloads", "FixedPointNumbers", "Hyperscript", "HypertextLiteral", "IOCapture", "InteractiveUtils", "JSON", "Logging", "MIMEs", "Markdown", "Random", "Reexport", "URIs", "UUIDs"] +git-tree-sha1 = "8329a3a4f75e178c11c1ce2342778bcbbbfa7e3c" +uuid = "7f904dfe-b85e-4ff6-b463-dae2292396a8" +version = "0.7.71" + +[[deps.PooledArrays]] +deps = ["DataAPI", "Future"] +git-tree-sha1 = "36d8b4b899628fb92c2749eb488d884a926614d3" +uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720" +version = "1.4.3" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "5aa36f7049a63a1528fe8f7c3f2113413ffd4e1f" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.2.1" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "0f27480397253da18fe2c12a4ba4eb9eb208bf3d" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.5.0" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "Reexport", "StringManipulation", "Tables"] +git-tree-sha1 = "1101cd475833706e4d0e7b122218257178f48f34" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "2.4.0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.PtrArrays]] +git-tree-sha1 = "1d36ef11a9aaf1e8b74dacc6a731dd1de8fd493d" +uuid = "43287f4e-b6f4-7ad1-bb20-aadabca52c3d" +version = "1.3.0" + +[[deps.Qt6Base_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Fontconfig_jll", "Glib_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "OpenSSL_jll", "Vulkan_Loader_jll", "Xorg_libSM_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Xorg_libxcb_jll", "Xorg_xcb_util_cursor_jll", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_keysyms_jll", "Xorg_xcb_util_renderutil_jll", "Xorg_xcb_util_wm_jll", "Zlib_jll", "libinput_jll", "xkbcommon_jll"] +git-tree-sha1 = "eb38d376097f47316fe089fc62cb7c6d85383a52" +uuid = "c0090381-4147-56d7-9ebc-da0b1113ec56" +version = "6.8.2+1" + +[[deps.Qt6Declarative_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Qt6Base_jll", "Qt6ShaderTools_jll"] +git-tree-sha1 = "da7adf145cce0d44e892626e647f9dcbe9cb3e10" +uuid = "629bc702-f1f5-5709-abd5-49b8460ea067" +version = "6.8.2+1" + +[[deps.Qt6ShaderTools_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Qt6Base_jll"] +git-tree-sha1 = "9eca9fc3fe515d619ce004c83c31ffd3f85c7ccf" +uuid = "ce943373-25bb-56aa-8eca-768745ed7b5a" +version = "6.8.2+1" + +[[deps.Qt6Wayland_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Qt6Base_jll", "Qt6Declarative_jll"] +git-tree-sha1 = "e1d5e16d0f65762396f9ca4644a5f4ddab8d452b" +uuid = "e99dba38-086e-5de3-a5b1-6e4c66e897c3" +version = "6.8.2+1" + +[[deps.REPL]] +deps = ["InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.RecipesBase]] +deps = ["PrecompileTools"] +git-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.3.4" + +[[deps.RecipesPipeline]] +deps = ["Dates", "NaNMath", "PlotUtils", "PrecompileTools", "RecipesBase"] +git-tree-sha1 = "45cf9fd0ca5839d06ef333c8201714e888486342" +uuid = "01d81517-befc-4cb6-b9ec-a95719d0359c" +version = "0.6.12" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.RelocatableFolders]] +deps = ["SHA", "Scratch"] +git-tree-sha1 = "ffdaf70d81cf6ff22c2b6e733c900c3321cab864" +uuid = "05181044-ff0b-4ac5-8273-598c1e38db00" +version = "1.0.1" + +[[deps.Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "62389eeff14780bfe55195b7204c0d8738436d64" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.3.1" + +[[deps.Revise]] +deps = ["CodeTracking", "FileWatching", "JuliaInterpreter", "LibGit2", "LoweredCodeUtils", "OrderedCollections", "REPL", "Requires", "UUIDs", "Unicode"] +git-tree-sha1 = "f6f7d30fb0d61c64d0cfe56cf085a7c9e7d5bc80" +uuid = "295af30f-e4ad-537b-8983-00126c2a3abe" +version = "3.8.0" + + [deps.Revise.extensions] + DistributedExt = "Distributed" + + [deps.Revise.weakdeps] + Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.SentinelArrays]] +deps = ["Dates", "Random"] +git-tree-sha1 = "712fb0231ee6f9120e005ccd56297abbc053e7e0" +uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c" +version = "1.4.8" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[deps.Showoff]] +deps = ["Dates", "Grisu"] +git-tree-sha1 = "91eddf657aca81df9ae6ceb20b959ae5653ad1de" +uuid = "992d4aef-0814-514b-bc4d-f2e9a6c4116f" +version = "1.0.3" + +[[deps.SimpleBufferStream]] +git-tree-sha1 = "f305871d2f381d21527c770d4788c06c097c9bc1" +uuid = "777ac1f9-54b0-4bf8-805c-2214025038e7" +version = "1.2.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[deps.SortingAlgorithms]] +deps = ["DataStructures"] +git-tree-sha1 = "64d974c2e6fdf07f8155b5b2ca2ffa9069b608d9" +uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" +version = "1.2.2" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.12.0" + +[[deps.StableRNGs]] +deps = ["Random"] +git-tree-sha1 = "95af145932c2ed859b63329952ce8d633719f091" +uuid = "860ef19b-820b-49d6-a774-d7a799459cd3" +version = "1.0.3" + +[[deps.Statistics]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "ae3bb1eb3bba077cd276bc5cfc337cc65c3075c0" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.1" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + +[[deps.StatsAPI]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "9d72a13a3f4dd3795a195ac5a44d7d6ff5f552ff" +uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" +version = "1.7.1" + +[[deps.StatsBase]] +deps = ["AliasTables", "DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] +git-tree-sha1 = "2c962245732371acd51700dbb268af311bddd719" +uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +version = "0.34.6" + +[[deps.StringManipulation]] +deps = ["PrecompileTools"] +git-tree-sha1 = "725421ae8e530ec29bcbdddbe91ff8053421d023" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.4.1" + +[[deps.StructuralUnits]] +deps = ["Reexport", "Unitful", "UnitfulLatexify"] +git-tree-sha1 = "0e2a61508c26a096c3c032a55f9f997b13011b59" +uuid = "ec81c399-378c-4a82-baa1-80fb2fc85b6c" +version = "0.2.0" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.8.3+2" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "f2c1efbc8f3a609aadf318094f8fc5204bdaf344" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.12.1" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.TensorCore]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "1feb45f88d133a655e001435632f019a9a1bcdb6" +uuid = "62fd8b95-f654-4bbd-a8a5-9c27f68ccd50" +version = "0.1.1" + +[[deps.Test]] +deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" +version = "1.11.0" + +[[deps.TestHandcalcFunctions]] +git-tree-sha1 = "54dac4d0a0cd2fc20ceb72e0635ee3c74b24b840" +uuid = "6ba57fb7-81df-4b24-8e8e-a3885b6fcae7" +version = "0.2.4" + +[[deps.TranscodingStreams]] +git-tree-sha1 = "0c45878dcfdcfa8480052b6ab162cdd138781742" +uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" +version = "0.11.3" + +[[deps.Tricks]] +git-tree-sha1 = "372b90fe551c019541fafc6ff034199dc19c8436" +uuid = "410a4b4d-49e4-4fbc-ab6d-cb71b17b3775" +version = "0.1.12" + +[[deps.URIs]] +git-tree-sha1 = "bef26fb046d031353ef97a82e3fdb6afe7f21b1a" +uuid = "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4" +version = "1.6.1" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.UnicodeFun]] +deps = ["REPL"] +git-tree-sha1 = "53915e50200959667e78a92a418594b428dffddf" +uuid = "1cfade01-22cf-5700-b092-accc4b62d6e1" +version = "0.4.1" + +[[deps.Unitful]] +deps = ["Dates", "LinearAlgebra", "Random"] +git-tree-sha1 = "6258d453843c466d84c17a58732dda5deeb8d3af" +uuid = "1986cc42-f94f-5a68-af5c-568840ba703d" +version = "1.24.0" + + [deps.Unitful.extensions] + ConstructionBaseUnitfulExt = "ConstructionBase" + ForwardDiffExt = "ForwardDiff" + InverseFunctionsUnitfulExt = "InverseFunctions" + PrintfExt = "Printf" + + [deps.Unitful.weakdeps] + ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" + Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7" + +[[deps.UnitfulLatexify]] +deps = ["LaTeXStrings", "Latexify", "Unitful"] +git-tree-sha1 = "af305cc62419f9bd61b6644d19170a4d258c7967" +uuid = "45397f5d-5981-4c77-b2b3-fc36d6e9b728" +version = "1.7.0" + +[[deps.Unzip]] +git-tree-sha1 = "ca0969166a028236229f63514992fc073799bb78" +uuid = "41fe7b60-77ed-43a1-b4f0-825fd5a5650d" +version = "0.2.0" + +[[deps.Vulkan_Loader_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Wayland_jll", "Xorg_libX11_jll", "Xorg_libXrandr_jll", "xkbcommon_jll"] +git-tree-sha1 = "2f0486047a07670caad3a81a075d2e518acc5c59" +uuid = "a44049a8-05dd-5a78-86c9-5fde0876e88c" +version = "1.3.243+0" + +[[deps.Wayland_jll]] +deps = ["Artifacts", "EpollShim_jll", "Expat_jll", "JLLWrappers", "Libdl", "Libffi_jll"] +git-tree-sha1 = "96478df35bbc2f3e1e791bc7a3d0eeee559e60e9" +uuid = "a2964d1f-97da-50d4-b82a-358c7fce9d89" +version = "1.24.0+0" + +[[deps.XZ_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "fee71455b0aaa3440dfdd54a9a36ccef829be7d4" +uuid = "ffd25f8a-64ca-5728-b0f7-c24cf3aae800" +version = "5.8.1+0" + +[[deps.Xorg_libICE_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "a3ea76ee3f4facd7a64684f9af25310825ee3668" +uuid = "f67eecfb-183a-506d-b269-f58e52b52d7c" +version = "1.1.2+0" + +[[deps.Xorg_libSM_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libICE_jll"] +git-tree-sha1 = "9c7ad99c629a44f81e7799eb05ec2746abb5d588" +uuid = "c834827a-8449-5923-a945-d239c165b7dd" +version = "1.2.6+0" + +[[deps.Xorg_libX11_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll", "Xorg_xtrans_jll"] +git-tree-sha1 = "b5899b25d17bf1889d25906fb9deed5da0c15b3b" +uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc" +version = "1.8.12+0" + +[[deps.Xorg_libXau_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "aa1261ebbac3ccc8d16558ae6799524c450ed16b" +uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec" +version = "1.0.13+0" + +[[deps.Xorg_libXcursor_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXfixes_jll", "Xorg_libXrender_jll"] +git-tree-sha1 = "6c74ca84bbabc18c4547014765d194ff0b4dc9da" +uuid = "935fb764-8cf2-53bf-bb30-45bb1f8bf724" +version = "1.2.4+0" + +[[deps.Xorg_libXdmcp_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "52858d64353db33a56e13c341d7bf44cd0d7b309" +uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05" +version = "1.1.6+0" + +[[deps.Xorg_libXext_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "a4c0ee07ad36bf8bbce1c3bb52d21fb1e0b987fb" +uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3" +version = "1.3.7+0" + +[[deps.Xorg_libXfixes_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "9caba99d38404b285db8801d5c45ef4f4f425a6d" +uuid = "d091e8ba-531a-589c-9de9-94069b037ed8" +version = "6.0.1+0" + +[[deps.Xorg_libXi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXext_jll", "Xorg_libXfixes_jll"] +git-tree-sha1 = "a376af5c7ae60d29825164db40787f15c80c7c54" +uuid = "a51aa0fd-4e3c-5386-b890-e753decda492" +version = "1.8.3+0" + +[[deps.Xorg_libXinerama_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXext_jll"] +git-tree-sha1 = "a5bc75478d323358a90dc36766f3c99ba7feb024" +uuid = "d1454406-59df-5ea1-beac-c340f2130bc3" +version = "1.1.6+0" + +[[deps.Xorg_libXrandr_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXext_jll", "Xorg_libXrender_jll"] +git-tree-sha1 = "aff463c82a773cb86061bce8d53a0d976854923e" +uuid = "ec84b674-ba8e-5d96-8ba1-2a689ba10484" +version = "1.5.5+0" + +[[deps.Xorg_libXrender_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "7ed9347888fac59a618302ee38216dd0379c480d" +uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa" +version = "0.9.12+0" + +[[deps.Xorg_libxcb_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXau_jll", "Xorg_libXdmcp_jll"] +git-tree-sha1 = "bfcaf7ec088eaba362093393fe11aa141fa15422" +uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b" +version = "1.17.1+0" + +[[deps.Xorg_libxkbfile_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "e3150c7400c41e207012b41659591f083f3ef795" +uuid = "cc61e674-0454-545c-8b26-ed2c68acab7a" +version = "1.1.3+0" + +[[deps.Xorg_xcb_util_cursor_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_jll", "Xorg_xcb_util_renderutil_jll"] +git-tree-sha1 = "c5bf2dad6a03dfef57ea0a170a1fe493601603f2" +uuid = "e920d4aa-a673-5f3a-b3d7-f755a4d47c43" +version = "0.1.5+0" + +[[deps.Xorg_xcb_util_image_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_jll"] +git-tree-sha1 = "f4fc02e384b74418679983a97385644b67e1263b" +uuid = "12413925-8142-5f55-bb0e-6d7ca50bb09b" +version = "0.4.1+0" + +[[deps.Xorg_xcb_util_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll"] +git-tree-sha1 = "68da27247e7d8d8dafd1fcf0c3654ad6506f5f97" +uuid = "2def613f-5ad1-5310-b15b-b15d46f528f5" +version = "0.4.1+0" + +[[deps.Xorg_xcb_util_keysyms_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_jll"] +git-tree-sha1 = "44ec54b0e2acd408b0fb361e1e9244c60c9c3dd4" +uuid = "975044d2-76e6-5fbe-bf08-97ce7c6574c7" +version = "0.4.1+0" + +[[deps.Xorg_xcb_util_renderutil_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_jll"] +git-tree-sha1 = "5b0263b6d080716a02544c55fdff2c8d7f9a16a0" +uuid = "0d47668e-0667-5a69-a72c-f761630bfb7e" +version = "0.3.10+0" + +[[deps.Xorg_xcb_util_wm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_jll"] +git-tree-sha1 = "f233c83cad1fa0e70b7771e0e21b061a116f2763" +uuid = "c22f9ab0-d5fe-5066-847c-f4bb1cd4e361" +version = "0.4.2+0" + +[[deps.Xorg_xkbcomp_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxkbfile_jll"] +git-tree-sha1 = "801a858fc9fb90c11ffddee1801bb06a738bda9b" +uuid = "35661453-b289-5fab-8a00-3d9160c6a3a4" +version = "1.4.7+0" + +[[deps.Xorg_xkeyboard_config_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xkbcomp_jll"] +git-tree-sha1 = "00af7ebdc563c9217ecc67776d1bbf037dbcebf4" +uuid = "33bec58e-1273-512f-9401-5d533626f822" +version = "2.44.0+0" + +[[deps.Xorg_xtrans_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "a63799ff68005991f9d9491b6e95bd3478d783cb" +uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10" +version = "1.6.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.3.1+2" + +[[deps.Zstd_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "446b23e73536f84e8037f5dce465e92275f6a308" +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.7+1" + +[[deps.eudev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "c3b0e6196d50eab0c5ed34021aaa0bb463489510" +uuid = "35ca27e7-8b34-5b7f-bca9-bdc33f59eb06" +version = "3.2.14+0" + +[[deps.fzf_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "b6a34e0e0960190ac2a4363a1bd003504772d631" +uuid = "214eeab7-80f7-51ab-84ad-2988db7cef09" +version = "0.61.1+0" + +[[deps.libaom_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "4bba74fa59ab0755167ad24f98800fe5d727175b" +uuid = "a4ae2306-e953-59d6-aa16-d00cac43593b" +version = "3.12.1+0" + +[[deps.libass_jll]] +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "125eedcb0a4a0bba65b657251ce1d27c8714e9d6" +uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0" +version = "0.17.4+0" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.13.1+1" + +[[deps.libdecor_jll]] +deps = ["Artifacts", "Dbus_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "Pango_jll", "Wayland_jll", "xkbcommon_jll"] +git-tree-sha1 = "9bf7903af251d2050b467f76bdbe57ce541f7f4f" +uuid = "1183f4f0-6f2a-5f1a-908b-139f9cdfea6f" +version = "0.2.2+0" + +[[deps.libevdev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "56d643b57b188d30cccc25e331d416d3d358e557" +uuid = "2db6ffa8-e38f-5e21-84af-90c45d0032cc" +version = "1.13.4+0" + +[[deps.libfdk_aac_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "646634dd19587a56ee2f1199563ec056c5f228df" +uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280" +version = "2.0.4+0" + +[[deps.libinput_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "eudev_jll", "libevdev_jll", "mtdev_jll"] +git-tree-sha1 = "91d05d7f4a9f67205bd6cf395e488009fe85b499" +uuid = "36db933b-70db-51c0-b978-0f229ee0e533" +version = "1.28.1+0" + +[[deps.libpng_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "07b6a107d926093898e82b3b1db657ebe33134ec" +uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f" +version = "1.6.50+0" + +[[deps.libvorbis_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll"] +git-tree-sha1 = "11e1772e7f3cc987e9d3de991dd4f6b2602663a5" +uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a" +version = "1.3.8+0" + +[[deps.mtdev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "b4d631fd51f2e9cdd93724ae25b2efc198b059b1" +uuid = "009596ad-96f7-51b1-9f1b-5ce2d5e8a71e" +version = "1.1.7+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.64.0+1" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.5.0+2" + +[[deps.x264_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "14cc7083fc6dff3cc44f2bc435ee96d06ed79aa7" +uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a" +version = "10164.0.1+0" + +[[deps.x265_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e7b67590c14d487e734dcb925924c5dc43ec85f3" +uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76" +version = "4.1.0+0" + +[[deps.xkbcommon_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll", "Xorg_xkeyboard_config_jll"] +git-tree-sha1 = "fbf139bce07a534df0e699dbb5f5cc9346f95cc1" +uuid = "d8fb68d0-12a3-5cfd-a85a-d49703b185fd" +version = "1.9.2+0" +""" + +# ╔═╡ Cell order: +# ╟─784c8ee4-df28-4bd8-bff7-f3bb2d097b12 +# ╟─ce9c2c18-5b35-4b05-a3d9-6eb67c7a5529 +# ╟─0f262891-af4b-4007-82f6-7aae20f91dbd +# ╟─ee2a647a-0cba-46c6-afb0-ba16bf0f0150 +# ╟─83a21840-a772-469e-999d-c066f60e2e0e +# ╟─7705230b-91dc-4851-9e1b-37a642e66657 +# ╟─657f405a-a7f8-4915-ba60-46464a01873f +# ╟─7c79ba77-e2b6-4e0d-8522-f0b540e6815f +# ╟─ad925028-59c3-433d-a54a-3f644d11b639 +# ╟─8cea32f9-a670-4269-a586-c7bdb339a80d +# ╟─7205b4a5-d032-43c6-8232-a5d3cffb29d6 +# ╟─d9adecaa-6ae8-46d4-955f-4a89a82a46c9 +# ╟─9264917e-724d-4220-bbee-ec026285e475 +# ╟─4882a030-f1d6-4b8b-a86f-a20e64fe4a6c +# ╟─733fe755-796d-41db-883a-cfc8d7d077a4 +# ╟─6ba1348c-3cca-46a4-b109-bfb90f7ef7f2 +# ╟─975a203f-e2d8-4f21-a4af-62212c7a9423 +# ╟─7f5a2d2a-62fe-4985-b0fb-8559d9124801 +# ╟─ffe30f1b-cde3-4f41-ac69-70f4d2634b3a +# ╟─b3420e1d-413e-463b-9bed-ac6182ce863a +# ╟─512a3218-e9e9-482e-b0b0-59650ea55fd1 +# ╟─724c61e2-7237-4f3e-ab30-655164288aaf +# ╟─cd5bcc78-ad78-40c8-9356-140a04ea1a69 +# ╟─7c465102-7d68-4827-bd8e-ed8e8ef0e303 +# ╟─fa8df29f-be0a-498d-8fac-4cbe016f034a +# ╟─eb8979e7-b163-435d-a909-f020194ffc15 +# ╟─563df061-7e97-4745-b101-cf4aa200da60 +# ╟─7cab03c4-048d-4df7-a3a5-b20dfd1e6e9d +# ╟─f2b5c3e7-29c1-4f7b-82bb-cfa8da90d494 +# ╟─831198d1-d22c-42b5-a198-3bd34139eb0e +# ╟─02c0320c-7c56-4fe5-8f8c-9ab0f733b28e +# ╟─9dee0462-b5af-4962-a65b-7ac7b2faf3df +# ╟─6ebfa6d8-b4a7-4d5e-8d3d-ccf0ba596f25 +# ╟─a7e6ac40-51bd-46d7-a21c-ad294fa23d5a +# ╟─ab20be4e-d214-4c0e-85df-c293724c978e +# ╟─fa5deb25-ee07-4917-bf57-595bced01394 +# ╟─1a229a8e-2378-4aff-871f-69446b9a4dd2 +# ╟─006a4f14-2cd1-439f-8b64-aab99601aba8 +# ╟─41536d79-8949-42ea-971c-8069918c455d +# ╟─1462be43-386b-4f9a-bae0-304fd058dd93 +# ╟─95b20797-e804-4c15-b0d0-7aeb36540234 +# ╟─5b088b11-f0af-461a-bc92-61fbfed0e768 +# ╟─2e016b07-2ac0-4fd0-9c0a-3062616666f3 +# ╟─8af4355b-b5cf-4017-a660-0b0ca884ad95 +# ╟─38c319e0-0124-41fa-9910-173e645e7d03 +# ╟─3b77b70e-be0b-46a7-948d-7289fcc72924 +# ╟─05063b3d-8769-4d54-ad70-f38e95dca7a3 +# ╟─38ba4eb9-4cd1-41d1-8b14-e07b3c76be3b +# ╟─d2fe14b6-59a9-4b9d-9028-3c9f41e91d1c +# ╟─76baa379-4a48-4268-871e-9e68db92c528 +# ╟─d2323592-e4eb-4ac1-ab86-741910e1738c +# ╟─241fc16e-d252-4ef8-8e6d-267fc327ee88 +# ╟─c1799961-2ae2-4fb0-8934-55fc2a16cc7e +# ╟─874bdbe5-d512-4566-9780-b78f141a8ba0 +# ╟─4811fcde-5bfa-4c45-a32f-d39343651c90 +# ╟─587040b9-c31a-4900-8b5d-26bf7000c570 +# ╟─c780180d-4ca9-464c-9d14-74f9ce5c4501 +# ╟─70ccb345-b0bc-456f-bda8-79a501059e6a +# ╟─50437455-4784-43ff-ac9c-5abdb43787fe +# ╟─ba25c716-b754-4887-b3b9-b85dba0f90d2 +# ╟─8bc4224f-0142-448c-be95-98cbb160071c +# ╟─fb20a23a-4102-4ee3-a73f-64c2640b0adb +# ╟─a27a4577-151d-45c0-9675-288076d2da59 +# ╟─631559da-b114-4932-a031-c555ac56b3bf +# ╟─3f7feb3d-99db-4b5e-a7e5-4f26c9c5ae68 +# ╟─975f4b7b-d6a4-4d72-96cc-90832ef22db4 +# ╟─8818efcf-704c-41c2-b0b4-b9da3ce53205 +# ╟─adc9907a-a224-4400-99e8-5fb6e385adfc +# ╟─5834c3bb-be94-4103-817c-4102bad491cf +# ╟─8435c139-ec9b-4ab1-82fc-4f0a20073f81 +# ╟─7e8946ca-8168-4b3a-851b-1e4458c6be77 +# ╟─5e2cdf07-4cf4-4347-a10d-58322aee46eb +# ╟─eabac306-fca3-42d4-add8-29c053e5f97d +# ╟─ab27ac5f-8e35-4c90-bbc5-e60bf699281d +# ╟─c44d318d-a710-4adb-acac-fd7f0f53cec3 +# ╟─4b5214a5-e35f-431a-9f3e-63eff56d1f45 +# ╟─435fb7e5-4afd-4c37-b21a-9dd1935c4fe2 +# ╟─1a9060ae-f257-4892-881a-09c7e7b71747 +# ╠═094598f7-8319-4551-b677-de5729672080 +# ╠═ffc3c232-12c1-408a-af0a-25fadb418a21 +# ╟─d67aad9b-1b53-48e1-bb39-82a2ac52b17c +# ╟─50caa04e-880d-4224-90b4-0a8d9004576b +# ╠═41bed3bd-75f9-4b1a-9ea8-786b338b7503 +# ╠═af04638c-2615-4195-a45e-d6d85af6d6cd +# ╟─8b9e6746-b731-4b39-a0b8-4b9e4c752cc6 +# ╠═4127a0c7-897b-41c2-9319-2b1c48369699 +# ╟─c59b620d-a6dd-4e19-ac30-5840568efba4 +# ╟─67136d72-c447-4268-8c17-b6d9ad3652ca +# ╠═ab1430fd-ddd9-48d6-94e8-465cea45ff25 +# ╟─2ffcfcc2-ac5f-4293-bab0-3fede68c115a +# ╟─cec8f377-dc41-41ba-a3b3-d916acba1147 +# ╟─4336e057-2a02-47d6-8fd9-e9cf9ec29399 +# ╟─00000000-0000-0000-0000-000000000001 +# ╟─00000000-0000-0000-0000-000000000002