text:
function ikegamida_mm(prop_prefs::Matrix{Int}, resp_prefs::Matrix{Int}, caps::Vector{Int})

    # set up
    prop_num, resp_num = size(prop_prefs)[2], size(resp_prefs)[2]
    match_or_unmatch = Array(Bool, prop_num)
    for i in 1:prop_num
        match_or_unmatch[i] = true
    end
    prop_matched, resp_matched = ones(Int64, prop_num) + resp_num, ones(Int64, sum(caps)) + prop_num

    prop_rank = Array(Int64, (resp_num + 1, prop_num))
    resp_rank = Array(Int64, (prop_num + 1, resp_num))

    sorting = Array(Int64, (resp_num + 1, 2))
    sorting[:, 1] = collect(1:(resp_num + 1))
    for i in 1:prop_num
        sorting[:, 2] = prop_prefs[:, i]
        prop_rank[:,i] = sortrows(sorting, by = x->(x[2]))[:,1]
        sorting = sortrows(sorting, by = x->(x[1]))
    end

    sorting2 = Array(Int64, (prop_num + 1, 2))
    sorting2[:, 1] = collect(1:(prop_num + 1))
    for i in 1:resp_num
        sorting2[:, 2] = resp_prefs[:, i]
        resp_rank[:,i] = sortrows(sorting2, by = x->(x[2]))[:,1]
        sorting2 = sortrows(sorting2, by = x->(x[1]))
    end

    insertarray = ones(Int64, maximum(caps) + 1) * (prop_num+1)

    #making indptr
    indptr = Array(Int, resp_num+1)
    indptr[1] = 1
    for i in 1:resp_num
        indptr[i+1] = indptr[i] + caps[i]
    end

    #main loop
    while sum(match_or_unmatch) > 0
        for i in 1:prop_num

            if match_or_unmatch[i] == true

                for j in prop_prefs[:, i]

                    if j == 0
                        prop_matched[i] = 0
                        match_or_unmatch[i] = false
                        break

                    else
                        cutoff = resp_rank[1, j]

                        if resp_rank[i+1, j] < cutoff

                            #capを超えてないなら無条件まっち
                            if prop_num + 1 in resp_matched[indptr[j]:indptr[j+1]-1]

                                for (m,q) in enumerate(resp_matched[indptr[j]:indptr[j+1]-1])

                                    if q == prop_num + 1
                                        resp_matched[indptr[j]+m-1] = i
                                        prop_matched[i] = j
                                        match_or_unmatch[i] = false
                                        break

                                    else
                                        if resp_rank[q+1, j] > resp_rank[i+1, j]
                                            if m == 1
                                                insertarray[m+1:length(resp_matched[indptr[j]:indptr[j+1]-1])] = resp_matched[indptr[j]:indptr[j+1]-1][m:end-1]
                                                insertarray[m] = i
                                            else
                                                insertarray[m+1:length(resp_matched[indptr[j]:indptr[j+1]-1])] = resp_matched[indptr[j]:indptr[j+1]-1][m:end-1]
                                                insertarray[1:m-1] = resp_matched[indptr[j]:indptr[j+1]-1][1:m-1]
                                                insertarray[m] = i
                                            end
                                            resp_matched[indptr[j]:indptr[j+1]-1] = insertarray[1:length(resp_matched[indptr[j]:indptr[j+1]-1])]
                                            prop_matched[i] = j
                                            match_or_unmatch[i] = false
                                            break
                                        end
                                    end
                                end
                                break

                            #capを超えてたら競争
                            else
                                for (n,p) in enumerate(resp_matched[indptr[j]:indptr[j+1]-1])
                                    if resp_rank[p+1, j] > resp_rank[i+1, j]
                                        if n == 1
                                            insertarray[n+1:length(resp_matched[indptr[j]:indptr[j+1]-1])] = resp_matched[indptr[j]:indptr[j+1]-1][n:end-1]
                                            insertarray[n] = i
                                        else
                                            insertarray[n+1:length(resp_matched[indptr[j]:indptr[j+1]-1])] = resp_matched[indptr[j]:indptr[j+1]-1][n:end-1]
                                            insertarray[1:n-1] = resp_matched[indptr[j]:indptr[j+1]-1][1:n-1]
                                            insertarray[n] = i
                                        end
                                        match_or_unmatch[resp_matched[indptr[j]:indptr[j+1]-1][end]] = true
                                        prop_matched[resp_matched[indptr[j]:indptr[j+1]-1][end]] = resp_num + 1
                                        resp_matched[indptr[j]:indptr[j+1]-1] = insertarray[1:length(resp_matched[indptr[j]:indptr[j+1]-1])]
                                        prop_matched[i] = j
                                        match_or_unmatch[i]=false
                                        break
                                    end
                                end
                                if match_or_unmatch[i] == false
                                    break
                                end
                            end
                        end
                    end
                end
            end
        end
    end

    for (i,t) in enumerate(prop_matched)
        if t == resp_num + 1
            prop_matched[i] = 0
        end
    end

    for (i,t) in enumerate(resp_matched)
        if t == prop_num + 1
            resp_matched[i] = 0
        end
    end

    return prop_matched, resp_matched, indptr
end

function ikegamida_mm(prop_prefs::Matrix{Int}, resp_prefs::Matrix{Int})
    caps = ones(Int, size(resp_prefs, 2))
    prop_matches, resp_matches, indptr =
    ikegamida_mm(prop_prefs, resp_prefs, caps)
    return prop_matches, resp_matches
end


text:
using Test, KitML
using Solaris
using Solaris.Flux, Solaris.DiffEqFlux

const SR = Solaris

include("test_io.jl")
include("test_train.jl")
include("test_equation.jl")
include("test_solver.jl")
include("test_closure.jl")

ext: jl


text:
##############################################################################
#
# REFERENCES: Wasserman, "All of Statistics"
#
# NOTES: Fails CDF/Quantile matching test
#
##############################################################################

immutable Bernoulli <: DiscreteUnivariateDistribution
    prob::Float64
    function Bernoulli(p::Real)
        if 0.0 <= p <= 1.0
            new(float64(p))
        else
            error("prob must be in [0,1]")
        end
    end
end

Bernoulli() = Bernoulli(0.5)

cdf(d::Bernoulli, q::Real) = q < 0.0 ? 0.0 : (q >= 1.0 ? 1.0 : 1.0 - d.prob)

entropy(d::Bernoulli) = -xlogx(1.0 - d.prob) - xlogx(d.prob)

insupport(d::Bernoulli, x::Number) = (x == 0) || (x == 1)

kurtosis(d::Bernoulli) = 1.0 / var(d) - 6.0

mean(d::Bernoulli) = d.prob

median(d::Bernoulli) = d.prob < 0.5 ? 0.0 : 1.0

function mgf(d::Bernoulli, t::Real)
    p = d.prob
    return 1.0 - p + p * exp(t)
end

function cf(d::Bernoulli, t::Real)
    p = d.prob
    return 1.0 - p + p * exp(im * t)
end

function modes(d::Bernoulli)
    if d.prob < 0.5
      return [0]
    elseif d.prob == 0.5
      return [0, 1]
    else
      return [1]
    end
end

pdf(d::Bernoulli, x::Real) = x == 0 ? (1.0 - d.prob) : (x == 1 ? d.prob : 0.0)

logpdf(d::Bernoulli, mu::Real, y::Real) = y == 0 ? log(1.0 - mu) : (y == 1 ? log(mu) : -Inf)

quantile(d::Bernoulli, p::Real) = 0.0 < p < 1.0 ? (p <= (1.0 - d.prob) ? 0 : 1) : NaN

rand(d::Bernoulli) = rand() > d.prob ? 0 : 1

skewness(d::Bernoulli) = (1.0 - 2.0 * d.prob) / std(d)

var(d::Bernoulli) = d.prob * (1.0 - d.prob)

# GLM methods
function devresid(d::Bernoulli, y::Real, mu::Real, wt::Real)
    2wt * (xlogxdmu(y, mu) + xlogxdmu(1.0 - y, 1.0 - mu))
end

function devresid(d::Bernoulli, y::Vector{Float64}, mu::Vector{Float64}, wt::Vector{Float64})
    [2wt[i] * (xlogxdmu(y[i], mu[i]) + xlogxdmu(1.0 - y[i], 1.0 - mu[i])) for i in 1:length(y)]
end

mustart(d::Bernoulli,  y::Real, wt::Real) = (wt * y + 0.5) / (wt + 1.0)

var(d::Bernoulli, mu::Real) = max(eps(), mu * (1.0 - mu))


text:
module QuadTreeMeshes

import GeometryTypes
import FixedSizeArrays

const ElIndex = Int
const Point = GeometryTypes.Point{2, Float64}
const triangle_index = Int
const vertex_index = Int

# package code goes here
include("QuadTree.jl")
include("Meshes.jl")
include("PlotRecipes.jl")

end # module


text:
# Try to make constraints with different variable combos
@constraint(m2, x + y - z <= 0)
@constraint(m2, thor[i = 1:5], xs[i] + sum(y2s[i, j] for j = 1:6) == 42)
@constraint(m2, z + 2 >= -23)
@constraint(m2, y + z == 23)
@constraint(m2, x + z <= 42)

# Ensure all the variables and constraints were added
size(JuMP.prepConstrMatrix(m2)) == (9, 84)


text:
using CmdStan, Test

ProjDir = dirname(@__FILE__)
cd(ProjDir)

@testset "Bernoulli" begin

  isdir("tmp") &&
    rm("tmp", recursive=true);

  bernoullimodel = "
  data {
    int<lower=1> N;
    int<lower=0,upper=1> y[N];
  }
  parameters {
    real<lower=0,upper=1> theta;
  }
  model {
    theta ~ beta(1,1);
    y ~ bernoulli(theta);
  }
  ";

  observeddata = Dict("N" => 10, "y" => [0, 1, 0, 1, 0, 0, 0, 0, 0, 1])

  global stanmodel, rc, chn, chns, cnames, summary_df

  #tmpdir = ProjDir*"/tmp"

  stanmodel = Stanmodel(Sample(save_warmup=false, num_warmup=1000,
    num_samples=2000, thin=1), name="bernoulli", model=bernoullimodel,
    printsummary=false,
    #tmpdir=tmpdir
  );

  rc, a3d, cnames = stan(stanmodel, observeddata, ProjDir, diagnostics=false,
    CmdStanDir=CMDSTAN_HOME);

  if rc == 0
    sdf  = read_summary(stanmodel)
    @test sdf[sdf.parameters .== :theta, :mean][1] ≈ 0.34 rtol=0.1
  end

  isdir("tmp") &&
    rm("tmp", recursive=true);

end # testset


text:
using LMCLUS
using LinearAlgebra
using Test
import Random

@testset "Utils" begin

	# Test data sampling
	mt = Random.MersenneTwister(0)
	@test length(LMCLUS.randpermset(10,5,mt)) == 5

    S = hcat(fill(1,2,2), fill(2,2,2))
    @test LMCLUS.sample_points(S, 2, rng=mt) == [4, 1]
    @test LMCLUS.sample_points(S, 3, rng=mt) == Int[]
	@test_throws ErrorException LMCLUS.sample_points(S, -3, rng=mt)

	@test length(LMCLUS.sample_points(Matrix(I, 5, 3), 3, rng=mt)) == 3
	@test_throws ErrorException LMCLUS.sample_points(Matrix(I, 5, 3), 5, rng=mt)

	# Test basis forming
	data = float(reshape([1,1,0, 1,2,2, -1,0,2, 0,0,1],3,4))
	basis = data[:, 2:end]
	result = float(reshape([1,2,2,-2,-1,2, 2,-2,1],3,3))/3.0
	@test LMCLUS.orthogonalize(basis) ≈ result
	data = float(reshape([1,1,0, 2,3,2, 0,1,2, 1,1,1],3,4))
	@test LMCLUS.form_basis(data, collect(1:4))[2] ≈ result

end


text:
using PyCall
xr = pyimport("xarray")
using Elefridge
using JLD

path = "/Users/milan/cams/gridded/"
filelist = filter(x->endswith(x,".grib"),readdir(path))

n = length(filelist)
varnames = Array{String,1}(undef,n)
Hlin = Array{Float64,1}(undef,n)
Hlog = Array{Float64,1}(undef,n)

for (i,file) in enumerate(filelist)
    if true
        varname = split(split(file,"_")[end],".")[1]
        varnames[i] = varname
        println("---")
        println("Reading $varname")
        X = xr.open_dataarray(joinpath(path,file),engine="cfgrib").data

        if any(X .<= 0f0)
            println("Negative/zero entries found.")
            X = X[X.>0f0]  # remove
        end

        Xlin = LinQuant16Array(X)
        Hlin[i] = bitentropy(Xlin)

        Xlog = LogQuant16Array(X)
        Hlog[i] = bitentropy(Xlog)

        println("Hlin = $(Hlin[i]) bit, Hlog = $(Hlog[i]) bit")
    end
end

# save("/Users/milan/cams/entropy/unstructured_linlog16_nozeroes.jld","varnames",varnames,"Hlin",Hlin,"Hlog",Hlog)


text:
include("Styles.jl")

import Base.error
function Base.error(err_msg::String, t::Token)
    s = max(1,t.line-3)
    lines = readlines(file_to_parse)[s:t.line]

    code = ""
    ln = 0
    for (i,l) in enumerate(lines)
        ln = "  $(i+s-1).  "
        code *= "$ln$l\n"
    end
    code = code[1:end-1]
    println(code)

    println(" "^(t.col-3+length(ln))*"^^^^^")

    println("$CRED"*"$err_msg at line $(t.line):$(t.col)")
    println("Compilation failed$CEND")

    error("void")
end

max_stars_repo_name: GabrielTrettel/Portran

max_issues_repo_name: GabrielTrettel/Portran

max_forks_repo_name: GabrielTrettel/Portran


text:
module OmegaCoreTestModels

function test_model()
  # Normally distributed random variable with id 1
  x = 1 ~ Normal(0, 1)

  # Normally distributed random variable with id 2 and x as mean
  y = 2 ~ Uniform(x, pw(+, x, 1))
  x_ = 0.1
  y_ = 0.3

  # An omega object -- like a trace
  ω = SimpleΩ(Dict((1,) => x_, (2,) => y_))

  # model -- tuple-valued random variable ω -> (x(ω), y(ω)), becase we want joint pdf
  m = (x, y)ₚ
  (x, y, m)
end

end

max_stars_repo_name: zenna/expect

max_issues_repo_name: zenna/expect

max_forks_repo_name: zenna/expect


text:
@symbol_func function delta_x(cur_reactor::AbstractReactor)
  cur_delta = cur_reactor.delta_95

  cur_delta *= 1.5

  cur_delta
end


text:
### A Pluto.jl notebook ###
# v0.15.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

# ╔═╡ 77b8cb0d-80b3-4676-9ce9-f7cb0848d513
# Carregar os pacotes
begin
	using PlutoUI
	using Plots
	using LaTeXStrings

	plotly()
end;

# ╔═╡ 02a9f752-e036-4646-859d-409d211f98b1
# funções úteis
begin

	# arredar para d digits o valor v
	fn(v,d) = round(v, digits = d)

	f1(v) = fn(v,1)
	f2(v) = fn(v,2)
	f3(v) = fn(v,3)

	# parse uma string para float, se a string for missing
	# utiliza-se o valor padrão strstd
	# necessária para iniciar inputs
	function myparse(str, strstd)

		if ismissing(str)
			str = strstd
		end

		return parse(Float64, str)

	end

end;

# ╔═╡ 540f6120-e958-11eb-3257-190c7446c60d
md"""
# Exemplo de Mecânica dos Sólidos

## Cálculo de uma viga biapoiada
"""

# ╔═╡ d63c87b2-088f-4cad-82c1-074c0f3ae0f5
md"""
Neste exemplo vamos calcular as _**Tensão normal resultante do momento fletor**_ (``\sigma_x``) e apresentaremos:

- 1. o _**modelo**_ para cálculo do momento fletor em uma viga biapoiada, e as tensões devido o momento fletor;
- 2. em seguidas vamos apresentar de forma sucinta o _**algoritmo**_ que será implementado;
- 3. vamos implementar o _**código**_ e
- 4. por fim vamos fazer _**simulações e análises**_.
"""

# ╔═╡ 245c085c-8389-49bb-9f75-6ab927bcee77
md"""
### 1.1 Modelo
"""

# ╔═╡ b3f52508-6522-46c3-8928-b2777ea9f4b7
md"""
Uma _**viga biapoiada**_ apresenta a configuração mostrada na Figura abaixo. A viga possui um comprimento ``L``, é apoia nas extremidades ``A`` e ``B``, no nosso caso, tera seção com dimensões retangulares ``a`` e ``b``. Vamos considerar ainda uma única força vertical com intersidade ``P`` a uma distância ``S`` da extremidade ``A``.

$(PlutoUI.LocalResource("./figures/fig_001.svg", :width => 400))
_Figuras feitas no Powerpoint_.

"""

# ╔═╡ 34cd8cf8-9710-40d9-843b-49de3fd3213b
md"""
Considerando as equações de equilíbrio estático, somatório dos momentos em relação à extremidade ``A`` e somatório as forças na direção ``y``, respectivamente:

```math
\begin{align}
\tag{1}
\sum M_A &= 0 \\
&\\
-P S + B L &= 0 \\
 B &= P \dfrac{S}{L}
\end{align}
```
e

```math
\begin{align}
\tag{2}
\sum F_y &= 0 \\
&\\
A + B - P &= 0 \\
A &= P - P \dfrac{S}{L} \\
A &= P\left(1-\dfrac{S}{L}\right)
\end{align}
```

As _**forças de reação**_ ``A`` e ``B``, juntamente com a força ``P``, são os _**esforços externos**_ atuando sobre a viga. A seguir vamos encontrar os esforços internos.

"""

# ╔═╡ 7e933bc9-b117-4d77-ac19-a822d40bb77c
md"""
Para encontrar os _**esforços internos**_, que inclui o _**momento Fletor**_, precisamos considerar duas regiões na viga, uma entre ``A`` e ``P`` e outra entre ``P`` e ``B``. Em seguinda analisamos os esforços nas seções em cada uma dessas regiões, conforme a figura abaixo.

$(PlutoUI.LocalResource("./figures/fig_002.svg", :width => 400))
_Figuras feitas no Powerpoint_.

Em cada uma da Seçoes (I) e (II) na figura surgem o esforço cortante ``V`` e o momento fletor ``M``. Para o momento fletor temos

```math
\begin{align}
\tag{3}
\sum M_I &= 0 \\
&\\
M - Ax &= 0\\
M &= Ax
\end{align}
```

e

```math
\begin{align}
\tag{4}
\sum M_{II} &= 0 \\
&\\
M - Ax + P(x-S) &= 0\\
M &= Ax - P(x-S)
\end{align}
```

As equações (3) e (4) podem ser rescritas na forma de funções de ``x``.

```math
\begin{align}
\tag{5}
M_I(x) &= Ax\\
M_{II}(x) &= Ax - P(x-S)
\end{align}
```
"""

# ╔═╡ b90f8465-8329-44fc-9daa-eee723aad74b
md"""
A tensão normal devido a flexão pode ser calculada pela equação

```math
\tag{6}

\sigma_x = \dfrac{M_z y}{I_z}
```
Na Equação (6)

- ``M_z`` é o momento fletor em torno da linha neutra,
- ``y`` é a distância do ponto onde está sendo calculada a tensão normal até a linha neutra e
- ``I_z`` é momento de inércia em relação à linha neutra.

As Figuras abaixo indicam essa variáveis em uma seção da viga.

$(PlutoUI.LocalResource("./figures/fig_003.svg", :width => 250)) $(PlutoUI.LocalResource("./figures/fig_004.svg", :width => 250))
_Figuras feitas no Powerpoint_.

Ao longo da viga ``M_z`` assumirá os valores calculados na Equação (5). Reescrendo temos

```math
\tag{7}
 M_z =
  \begin{cases}
    M_I(x) &= Ax              & \quad \text{para }  0 < x < S\\
    M_{II}(x) &= Ax - P(x-S)  & \quad \text{para }  S < x < L\\
  \end{cases}
```
"""

# ╔═╡ 9b305d25-bd0b-493c-a604-0b59e4f40779
md"""
O _**momento de inércia de um retângulo**_ em torno de uma linha de simetria, como a linha neutra nas figuras acima, é dado por

```math
\tag{8}
I_z = \dfrac{a \times b^3}{12}
```

"""

# ╔═╡ edbf7dc7-413d-4c6e-b90a-1f0e39c08379
md"""
## 1.2 Algoritmo

Vamos implementar um código com os seguintes passos:

1. Entra dos valores de ``L``, ``S``, ``P``, ``a`` e ``b``;
2. Cálculo de ``M_z``;
3. Cálculo de ``I_Z``;
4. Cálculo de ``σ_x`` e
5. Apresentação dos resultados.

"""

# ╔═╡ b92d0d94-1857-4053-aece-6312e1e7a635
md"""

## 1.3 Código

Para solução das equações vamos utilizar o seguinte código em linguagem Julia.

"""

# ╔═╡ 048a165e-bd12-4ac7-803b-79ef18cc5211
md"""
## 1.4 Simulações e Análises

Os gráficos das funções ``σ_x`` e ``Mz``, Eqs. (6) e (7), respectivamente, são úteis para simulações e análise do problema proposto.

#### Simulações

Serão implementadas as Eqs. (6) e (7), em linuguagem julia, e em seguida seus gráficos serão construídos a fim de se observar os comportamentos de ``σ_x`` e ``Mz`` em função dos parâmetos entrada mostrados abaixo.

"""

# ╔═╡ 7ba40849-d15a-40eb-aabd-e8d027e95ac3
md"""

**Análise**

Observa-se que os gráfico de ``M_z`` é alterado pelos valores de ``P`` e de ``S`` e que os valores de ``σ_x`` seguem o mesmo comportamento de ``Mz`` com a tensão máxima ocorrem em ``S`` onde a força ``P`` é a aplicada.
"""

# ╔═╡ 81c7f997-8f1e-422d-a807-02a0d498a75c
# Gerar campos de input
begin
	Linput = @bind LText html"<input type=text size=2 value=5.0>"
	Pinput = @bind PText html"<input type=text size=4 value=20.0e3>"
	Sinput = @bind SText html"<input type=text size=2 value=2.0>"
	ainput = @bind aText html"<input type=text size=2 value=0.15>"
	binput = @bind bText html"<input type=text size=2 value=0.25>"
	xinput = @bind xText html"<input type=text size=2 value=1.0>"
	yinput = @bind yText html"<input type=text size=2 value=0.125>"
end;

# ╔═╡ 95567daf-6bf4-4f53-a2a6-20c2613d33c9
# converter texto dos inputs e variávis do tipo Float
begin
	L = myparse(LText, "5.0")  # m
	P = myparse(PText, "20.0e3")  # N
	S = myparse(SText, "2.0")  # m
	a = myparse(aText, "0.15")  # m
	b = myparse(bText, "0.25")  # m
	x = myparse(xText, "1.0")  # m
	y = myparse(yText, "0.125")  # m
end;

# ╔═╡ f5bfe0f4-6b2f-4e97-9478-9b14778260a2
begin

# 1. Entra dos valores de L, S, P, a e b;
	# VER CÉLULA A SEGUIR

# 2. Cálculo de M_z;

	A = P*(1-S/L)

	if x < S
		Mz = A*x
	else
		Mz = A*x - P*(x-S)
	end

# 3. Cálculo de I_Z;

	Iz = (a*b^3)/12

# 4. Cálculo de σx

	σx(yy) = Mz * y / Iz

# 5. Apresentação dos resultados.

	# y distancia y para linha neutra

	σxy = σx(y)

end;

# ╔═╡ c784f96e-f4c9-4a53-bf58-981db54f0722
md"""
Para a viga AB podemos fornecer a seguinte entrada:

- de comprimente ``L =`` $(Linput)✍ m,
- para uma força ``P =`` $(Pinput)✍ kN,
- aplicada uma distância ``S =`` $(Sinput)✍ m da extremidade ``A``;
- tendo ainda a viga seção com dimensões ``a =`` $(ainput)✍ m e ``b =`` $(binput)✍ m,
- a tensão normal na seção uma distância ``x =`` $(xinput)✍ m da extremidade ``A``,
- a uma altura ``y =`` $(yinput)✍ m
- será igua a ``σ_x =`` $(f2(σxy/1e6)) ⚡💻 MPa.
"""

# ╔═╡ 30247314-f0c6-4aa7-bd1e-b0cddf192a92
begin

	P*1  # para forçar a atualização desta célula

	# calcular Mz em função de x, os outros parâmetros
	# são mantidos como incluidos acima
	function MZx(x, P = P, S = S, L = L)
		A = P*(1-S/L)

		if x < S
			return A*x
		else
			return A*x - P*(x-S)
		end
	end

	# calcular σ em função de x, os outros parâmetros
	# são mantidos como incluidos acima
	function σ(Mz, y = y, Iz = Iz)
		return Mz*y/Iz
	end

end;

# ╔═╡ 197f863e-5a61-41a5-a3be-65f531d61f45
begin
	barx = 0.0:L/10.0:L
	barz = zeros(Float64, length(barx), 1)

	# gerar uma linha grossa para
	# representar a barra AB
	plot(barx, barz, w=10,
		title = "Momento Fletor na barra AB",
		xlabel = "x [m]",
		ylabel = "Mz [N.m]"
	)

	# plot de σ Mz função de x
	plot!(MZx, 0, S, label = false, w =2)
	plot!(MZx, S, L, label = false, w =2)
end

# ╔═╡ 99546856-120b-42dc-bd84-323624dbc05a
begin
	S*1 # para forçar a atualização desta célula

	σValuesI = σ(MZx.(0:S/10:S))
	σValuesII = σ(MZx.(S:(L-S)/10:L))

	# gerar uma linha grossa para
	# representar a barra AB
	plot(barx, barz, w=10,
		label = false,
		title = "Tensões normais axiais na Barra AB",
		xlabel = "x [m]",
		ylabel = "σ [Pa]"
	)

	# plot de σ em função de x
	plot!(0:S/10:S, σValuesI, label = false, w =2)
	plot!(S:(L-S)/10:L, σValuesII, label = false, w =2)
end

# ╔═╡ 00000000-0000-0000-0000-000000000001
PLUTO_PROJECT_TOML_CONTENTS = """
[deps]
LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
PlutoUI = "7f904dfe-b85e-4ff6-b463-dae2292396a8"

[compat]
LaTeXStrings = "~1.2.1"
Plots = "~1.19.2"
PlutoUI = "~0.7.9"
"""

# ╔═╡ 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 = "c3598e525718abcc440f69cc6d5f60dda0a1b61e"
uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0"
version = "1.0.6+5"

[[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 = "e2f47f6d8337369411569fd45ae5753ca10394c6"
uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a"
version = "1.16.0+6"

[[ColorSchemes]]
deps = ["ColorTypes", "Colors", "FixedPointNumbers", "Random", "StaticArrays"]
git-tree-sha1 = "ed268efe58512df8c7e224d2e170afd76dd6a417"
uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4"
version = "3.13.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 = "dc7dedc2c2aa9faf59a55c622760a25cbefbe941"
uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
version = "3.31.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 = "ee400abb2298bd13bfc3df1c412ed228061a2385"
uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
version = "1.7.0"

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

[[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"

[[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 = "92d8f9f208637e8d2d28c664051a00569c01493d"
uuid = "5ae413db-bbd1-5e63-b57d-d24a61df00f5"
version = "2.1.5+1"

[[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", "LibVPX_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 = "3cc57ad0a213808473eafef4845a74766242e05f"
uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5"
version = "4.3.1+4"

[[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 = "35895cf184ceaab11fd778b4590144034a167a2f"
uuid = "a3f928ae-7b40-5064-980b-68af3947d34b"
version = "2.13.1+14"

[[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 = "cbd58c9deb1d304f5a245a0b7eb841a2560cfec6"
uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7"
version = "2.10.1+5"

[[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 = "9f473cdf6e2eb360c576f9822e7c765dd9d26dbc"
uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71"
version = "0.58.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 = "eaf96e05a880f3db5ded5a5a8a7817ecba3c7392"
uuid = "d2c73de3-f751-5644-a686-071e5b155ba9"
version = "0.58.0+0"

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

[[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 = "47ce50b742921377301e15005c96e979574e130b"
uuid = "7746bdde-850d-59dc-9ae8-88ece973131d"
version = "2.68.1+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 = "c6a1fff2fd4b1da29d3dccaffb1e1001244d844e"
uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3"
version = "0.9.12"

[[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 = "81690084b6198a2e1da36fcfda16eeca9f9f24e4"
uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
version = "0.21.1"

[[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"

[[LibVPX_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "12ee7e23fa4d18361e7c2cde8f8337d4c3101bc7"
uuid = "dd192d2f-8180-539f-9fb4-cc70b1dcf69a"
version = "1.10.0+0"

[[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 = "6a8a2a625ab0dea913aba95c11370589e0239ff0"
uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
version = "0.5.6"

[[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 = "4ea90bd5d3985ae1f9a908bd4500ae88921c5ce7"
uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28"
version = "1.0.0"

[[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 = "c8abc88faa3f7a3950832ac5d6e690881590d6dc"
uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
version = "1.1.0"

[[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 = "501c20a63a34ac1d015d5304da0e645f42d91c9f"
uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043"
version = "1.0.11"

[[Plots]]
deps = ["Base64", "Contour", "Dates", "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 = "f3d4d35b8cb87adc844c05c722f505776ac29988"
uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
version = "1.19.2"

[[PlutoUI]]
deps = ["Base64", "Dates", "InteractiveUtils", "JSON", "Logging", "Markdown", "Random", "Reexport", "Suppressor"]
git-tree-sha1 = "44e225d5837e2a2345e69a1d1e01ac2443ff9fcb"
uuid = "7f904dfe-b85e-4ff6-b463-dae2292396a8"
version = "0.7.9"

[[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 = "b3fb709f3c97bfc6e948be68beeecb55a0b340ae"
uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
version = "1.1.1"

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

[[Reexport]]
git-tree-sha1 = "5f6c21241f0f655da3952fd60aa18477cf96c220"
uuid = "189a3867-3050-52da-a836-e630ba90ab69"
version = "1.1.0"

[[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 = "1b9a0f17ee0adde9e538227de093467348992397"
uuid = "90137ffa-7385-5640-81b9-e52037218182"
version = "1.2.7"

[[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 = "2f6792d523d7448bbe2fec99eca9218f06cc746d"
uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
version = "0.33.8"

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

[[Suppressor]]
git-tree-sha1 = "a819d77f31f83e5792a76081eee1ea6342ab8787"
uuid = "fd094767-a336-5f1f-9728-57cf17d0bbfb"
version = "0.2.0"

[[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 = "8ed4a3ea724dac32670b062be3ef1c1de6773ae8"
uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
version = "1.4.4"

[[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", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "acc685bcf777b2202a904cdcb49ad34c2fa1880c"
uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0"
version = "0.14.0+4"

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

[[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 = "d713c1ce4deac133e3334ee12f4adff07f81778f"
uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a"
version = "2020.7.14+2"

[[x265_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "487da2f8f2f0c8ee0e83f39d13037d6bbf0a45ab"
uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76"
version = "3.0.0+3"

[[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:
# ╠═77b8cb0d-80b3-4676-9ce9-f7cb0848d513
# ╠═02a9f752-e036-4646-859d-409d211f98b1
# ╠═540f6120-e958-11eb-3257-190c7446c60d
# ╠═d63c87b2-088f-4cad-82c1-074c0f3ae0f5
# ╠═245c085c-8389-49bb-9f75-6ab927bcee77
# ╠═b3f52508-6522-46c3-8928-b2777ea9f4b7
# ╟─34cd8cf8-9710-40d9-843b-49de3fd3213b
# ╠═7e933bc9-b117-4d77-ac19-a822d40bb77c
# ╠═b90f8465-8329-44fc-9daa-eee723aad74b
# ╠═9b305d25-bd0b-493c-a604-0b59e4f40779
# ╠═edbf7dc7-413d-4c6e-b90a-1f0e39c08379
# ╟─b92d0d94-1857-4053-aece-6312e1e7a635
# ╠═f5bfe0f4-6b2f-4e97-9478-9b14778260a2
# ╟─048a165e-bd12-4ac7-803b-79ef18cc5211
# ╠═c784f96e-f4c9-4a53-bf58-981db54f0722
# ╠═30247314-f0c6-4aa7-bd1e-b0cddf192a92
# ╠═99546856-120b-42dc-bd84-323624dbc05a
# ╠═197f863e-5a61-41a5-a3be-65f531d61f45
# ╠═7ba40849-d15a-40eb-aabd-e8d027e95ac3
# ╠═81c7f997-8f1e-422d-a807-02a0d498a75c
# ╠═95567daf-6bf4-4f53-a2a6-20c2613d33c9
# ╟─00000000-0000-0000-0000-000000000001
# ╟─00000000-0000-0000-0000-000000000002

max_stars_repo_name: jefferds/Solid-mechanics-II

max_issues_repo_name: jefferds/Solid-mechanics-II

max_forks_repo_name: jefferds/Solid-mechanics-II


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

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

# ╔═╡ b3d3eb60-ebda-11eb-235d-e74878a5428b
begin
	using ForwardDiff
	using Roots
	using StatsBase
	using Plots
	using PlutoUI
end

# ╔═╡ a98046a7-79d4-4568-bee9-27cb1059a288
begin
"""
    cost(p, q, λ1, λ2, α, μ, ν)
Input parameters and return the cost
"""
function cost(p, q, λ1, λ2, α, μ, ν)
    (p / (ν(α) - λ1 * p - λ2 * q)) + ((1 - p) / (μ(α) - λ1 + λ1 * p))
end

"""
    ∂cost_∂p(p, q, λ1, λ2, α, μ, ν)
Input parameters and return the derivative of the cost with respect to p at the
specified inputs. Derivative calculated using ForwardDiff, provides the same
output as `diff_cost` but is less performant.
"""
function ∂cost_∂p(p, q, λ1, λ2, α, μ, ν)
    ForwardDiff.derivative(ϕ -> cost(ϕ, q, λ1, λ2, α, μ, ν), p)
end

"""
    diff_cost(p, q, λ1, λ2, α, μ, ν)
Input parameters and return the derivative of the cost with respect to p at the
specified inputs. Derivative calculated using ForwardDiff, provides the same
output as `∂cost_∂p` but is more performant.
"""
function diff_cost(p, q, λ1, λ2, α, μ, ν)
    diff_public = (ν(α) - λ2*q)/(λ1*p - ν(α) + λ2*q)^2
    diff_private = μ(α)/(μ(α) - λ1 + λ1*p)^2
    return diff_public - diff_private
end

"""
    find_valid_roots(func)
Input a function and this will find values between 0 and 1 that minimise or
maximise that function. Both interior and boundary solutions are found. If
a boundary solution is found the second part of the return argument is true
and false if not.
"""
function find_valid_roots(func)
    roots = find_zeros(func, 0, 1)
    if length(roots) == 0
        return argmin([func(0), func(1)]) .- 1, true
    else
        return roots, false
    end
end

"""
    classify_roots(func)
Input a function (which should be a derivative) and some values at which its
output is 0 and this function returns the roots and a boolean array in which
1 means minimum and 0 means maximum.
"""
function classify_roots(func, roots)
    # roots is larger than 1 if it is a direct input from `find_valid_roots`
    # in which case it contains whether the root is interior or exterior
    if length(roots) > 1
        if roots[2] == true
            return [roots[1]], [true]
        else
            root_values = roots[1]
        end
    else
        root_values = roots
    end
    second_derivatives = ForwardDiff.derivative.(func, root_values)
    classifications = second_derivatives .> 0 # 1 is minimum
    return root_values, classifications
end

"""
    function pstar(q, λ1, λ2, α, μ, ν)
Returns the best response to an opponents move from the perspective of the
player responding i.e. the argument λ1  may be λ2 in practice if player 2 is
responding to player 1. Calculated numerically, less accurate than `analytic_pstar`
"""
function pstar(q, λ1, λ2, α, μ, ν)
    roots = find_valid_roots(p -> p - ∂cost_∂p(p, q, λ1, λ2, α, μ, ν))
    if length(roots[1]) > 1
        root_values, root_is_minimum =
            classify_roots(p -> ∂cost_∂p(p, q, λ1, λ2, α, μ, ν), roots)
        return (root_values[root_is_minimum])[1]
    else
        return (roots[1])[1]
    end
end

"""
    analytic_pstar(q, λ1, λ2, α, μ, ν)
Returns the best response to an opponents move from the perspective of the
player responding i.e. the argument λ1  may be λ2 in practice if player 2 is
responding to player 1. Calculated analytically, more accurate than `pstar`
"""
function analytic_pstar(q, λ1, λ2, α, μ, ν)
    p = (λ1*Complex(μ(α)*(ν(α) - λ2*q))^(1/2) - μ(α)*Complex(μ(α)*(ν(α) - λ2*q))^(1/2) - ν(α)*Complex(μ(α)*(ν(α) - λ2*q))^(1/2) - λ1*ν(α) + 2*μ(α)*ν(α) + λ2*q*Complex(μ(α)*(ν(α) - λ2*q))^(1/2) + λ1*λ2*q - 2*λ2*μ(α)*q)/(λ1*μ(α) - λ1*ν(α) + λ1*λ2*q) |> real
    return clamp(p, 0, 1)
end

# function analytic_pstar(q, λ1, λ2, α, μ, ν)
#     p = (λ1*Complex(μ(α)*(ν(α) - λ2*q))^(1/2) - μ(α)*Complex(μ(α)*(ν(α) - λ2*q))^(1/2) - ν(α)*Complex(μ(α)*(ν(α) - λ2*q))^(1/2) - λ1*ν(α) + 2*μ(α)*ν(α) + λ2*q*Complex(μ(α)*(ν(α) - λ2*q))^(1/2) + λ1*λ2*q - 2*λ2*μ(α)*q)/(λ1*μ(α) - λ1*ν(α) + λ1*λ2*q)
#     if isreal(p) && (0 < Real(p) < 1)
#         return Real(p)
#     else
#         val_at_zero = analytic_best_responded_cost(0,  parameters...)
#         val_at_one = analytic_best_responded_cost(1,  parameters...)
#         return findmin((val_at_zero, val_at_one))[2]
#     end
# end

"""
    best_responded_cost(p, λ1, λ2, α, μ, ν)
Returns the cost given an input p assuming that the opponent will best respond
to this p. Calculated analytically, but less performant than
`analytic_best_responded_cost`.
"""
function best_responded_cost(p, λ1, λ2, α, μ, ν)
    cost(p, analytic_pstar(p, λ2, λ1, α, μ, ν), parameters...)
end

"""
    analytic_best_responded_cost(p, λ1, λ2, α, μ, ν)
Returns the cost given an input p assuming that the opponent will best respond
to this p. Calculated analytically, more performant than `best_responded_cost`.
"""
function analytic_best_responded_cost(p, λ1, λ2, α, μ, ν)
    real(-(p - 1)/(μ(α) - λ1 + λ1*p) - p/(λ1*p - ν(α) + (λ2*(λ2*Complex(μ(α)*(ν(α) - λ1*p))^(1/2) - μ(α)*Complex(μ(α)*(ν(α) - λ1*p))^(1/2) - ν(α)*Complex(μ(α)*(ν(α) - λ1*p))^(1/2) - λ2*ν(α) + 2*μ(α)*ν(α) + λ1*p*Complex(μ(α)*(ν(α) - λ1*p))^(1/2) + λ1*λ2*p - 2*λ1*μ(α)*p))/(λ2*μ(α) - λ2*ν(α) + λ1*λ2*p)))
end

"""
    ∂best_responded_cost_∂p(p, λ1, λ2, α, μ, ν)
Returns the derivative of the `best_responded_cost` using AD, just as accurate
but less performant than `diff_best_responded_cost`
"""
function ∂best_responded_cost_∂p(p, λ1, λ2, α, μ, ν)
    ForwardDiff.derivative(ϕ -> best_responded_cost(ϕ, λ1, λ2, α, μ, ν), p)
end

"""
    diff_best_responded_cost(p, λ1, λ2, α, μ, ν)
Returns the derivative of the `best_responded_cost` calculated analytically.
More performant than `∂best_responded_cost_∂p`
"""
function diff_best_responded_cost(p, λ1, λ2, α, μ, ν)
    squareroot_factor = real(Complex(μ(α)*(ν(α) - λ1*p))^(1/2))
    A = (
        (λ1*(p - 1)) / (μ(α) - λ1 + λ1*p)^2 -
        (μ(α) - ν(α) + λ1*p)/
        ((squareroot_factor - ν(α) + λ1*p)*(λ2 - μ(α) - ν(α) + λ1*p)) -
        1/(μ(α) - λ1 + λ1*p)
    )
    B = (
        p * λ1 *(
            4*real(Complex(μ(α)*(ν(α) - λ1*p))^(3/2)) -
            μ(α)^3 +
            λ2*μ(α)^2 -
            2*λ1^2*p^2*squareroot_factor -
            4*μ(α)^2*(ν(α) - λ1*p) +
            2*μ(α)^2*squareroot_factor -
            2*ν(α)^2*squareroot_factor -
            λ1*μ(α)*p*(ν(α) - λ1*p) +
            4*λ1*ν(α)*p*squareroot_factor +
            λ2*μ(α)*(ν(α) - λ1*p) +
            μ(α)*ν(α)*(ν(α) - λ1*p) -
            2*λ2*μ(α)*squareroot_factor
        )
    )

    C = (
        2*squareroot_factor *
        (
            squareroot_factor -
            ν(α) +
            λ1*p
        )^2 *
        (λ2 - μ(α) - ν(α) + λ1*p)^2
    )
    return real(A - B/C)
end

"""
    equilibrium_probability(λ1, λ2, α, μ, ν; tolerance = 10e-9, first_actor = 1, returnall = false)
Returns the equilibrium probabilities (i.e. Nash equilibrium) for a given input.
This is calculated by finding an initial minimiser of the cost function and
recursively allowing players to best respond to the other player's actions,
stopping after a certain tolerance level is met
It has optional kwargs:
* tolerance - specifies the absolute difference required to stop the recursion
* first_actor - specifies which player should act first (this may or may not
give different results)
* returnall - defaults to false. If true return the full recursive sequence
"""
function equilibrium_probability(λ1, λ2, α, μ, ν; tolerance = 10e-9, first_actor = 1, returnall = false)
    if first_actor == 1
        parameters = (λ1, λ2, α, μ, ν)
        swapped_parameters = (λ2, λ1, α, μ, ν)
    else
        parameters = (λ2, λ1, α, μ, ν)
        swapped_parameters = (λ1, λ2, α, μ, ν)
    end

    root, ismin = classify_roots(p -> diff_best_responded_cost(p, parameters...), find_valid_roots(p -> diff_best_responded_cost(p, parameters...)))
    if sum(ismin) == 0
        val_at_zero = analytic_best_responded_cost(0,  parameters...)
        val_at_one = analytic_best_responded_cost(1,  parameters...)
        # println("it changed something")
        root = findmin((val_at_zero, val_at_one))[2]
    else
        root = first(root[ismin])
    end
    first_pstar(p) = analytic_pstar(p, parameters...)
    second_pstar(p) = analytic_pstar(p, swapped_parameters...)

    diff = 100
    response1 = 0
    ps = Float64[]
    qs = Float64[]
    if tolerance < 10e-13
        # println("tolerance of less than 10e-13 is dangerous")
        tolerance = 10e-14
    end
    while diff > tolerance
        response1 = second_pstar(root)
        response2 = first_pstar(response1)
        push!(ps, response2)
        push!(qs, response2)
        diff = abs(response2 - root)
        root = response2
    end
    if returnall == true
        return ps, qs
    else
        return root, response1
    end
end

function shaded_regions(mask::BitVector, iterator)
    values, indices = rle(mask)
    cum_indices = cumsum(indices)
    intervals = repeat([[0.0, 0.0]], length(indices))
    intervals[1] = iterator[[1, indices[1]]]
    for i in 2:length(cum_indices)
        intervals[i] = iterator[[cum_indices[i-1], cum_indices[i]]]
    end
    return intervals[.!values]
end

function shapes_from_intervals(intervals)
    shapes = Vector{Shape}(undef, length(intervals))
    for (i, interval) in enumerate(intervals)
        shapes[i] = Shape([(interval[1], 0), (interval[end], 0), (interval[end], 1), (interval[1], 1)])
    end
    return shapes
end

function resize_interval_shapes(
    vector_of_vectors_of_shapes::Vector{Vector{Shape}};
    n = length(vector_of_vectors_of_shapes),
    baseheight = 0)

    new_vec_vec_shapes = Vector{Vector{Shape}}(undef, length(vector_of_vectors_of_shapes))
    for i in 1:length(vector_of_vectors_of_shapes)
        new_shapes = Vector{Shape}(undef, length(vector_of_vectors_of_shapes[i]))
        for (j, shape) in enumerate(vector_of_vectors_of_shapes[i])
            new_ys = (shape.y .* (1/n)) .+ (i-1)/n .+ baseheight
            new_shapes[j] = Shape(shape.x, new_ys)
        end
        new_vec_vec_shapes[i] = new_shapes
    end
    return new_vec_vec_shapes
end

# function resize_interval_shapes(vector_of_shapes::AbstractVector{Shape})
#     n = length(vector_of_shapes)
#     new_shapes = Vector{Shape}(undef, length(vector_of_shapes))
#     for (j, shape) in enumerate(vector_of_shapes)
#         new_ys = (shape.y * (1/n)) .+ (j-1)/n
#         new_shapes[j] = Shape(shape.x, new_ys)
#     end
#     return new_shapes
# end

function calculate_assumptions(ps, qs, λ1, λ2, α, μ, ν; which = "both")
    if which == "mu" || which == "μ"
        return μ.(α) .> λ1 .* (1 .- ps)
    elseif which == "nu" || which == "ν"
        return ν.(α) .> λ1 .* ps .+ λ2 .* qs
    else
        return (μ.(α) .> λ1 .* (1 .- ps), ν.(α) .> λ1 .* ps .+ λ2 .* qs)
    end
end

function plot_assumptions!(plot, ps_list, qs, λ1, λ2, α, μ, ν;
    labels = ["μ violated", "ν violated", "a_μ violated", "a_ν violated"],
    colours = [:red, :blue, :yellow, :gray],
    height = 1/length(ps_list),
    baseheight = 0)

    assumptions = []
    for ps in ps_list
        append!(assumptions, [calculate_assumptions(ps, qs, λ1, λ2, α, μ, ν)...])
    end

    vec_vec_shapes = map(
        assumption -> shapes_from_intervals(shaded_regions(assumption, qs)),
        assumptions
    )

    new_vec_vec_shapes = resize_interval_shapes(vec_vec_shapes; n = 1/height, baseheight = baseheight)

    for (i, vec_shapes) in enumerate(new_vec_vec_shapes)
        plot!(plot, vec_shapes, colour=colours[i], label = [labels[i] fill(nothing, 1, length(vec_shapes)-1)], alpha=0.3)
    end
    return plot
end

function dp_string(number::Real, n::Integer)
    rpad(string(round(number, sigdigits = n)), n+1, "0")[1:n+1]
end
end

# ╔═╡ 9634d95f-2296-4853-82fd-2ad2b41325d2
begin
    μ(α) = 1 / (1.5 * (α))
    ν(α) = 1 / (0.7 * (α))
	iter = 0.01:0.01:2
	α = iter
end

# ╔═╡ 917b7737-42ae-4ed6-a79d-4061e15c182c
md"Player 2 arrival rate (λ2):  $(@bind λ2 Slider(0.00 : 0.01 : 2, default = 1, show_value = true))"

# ╔═╡ ad4dac58-8be4-4d28-be6f-075ba3393ece
md"Job size (λ1) $(@bind λ1 Slider(0.00 : 0.01 : 3, default = 1, show_value = true))"

# ╔═╡ b5d9d0e7-1b7b-4bdb-a393-c6bccc69d183
begin
	probability_tuples = equilibrium_probability.(λ1, λ2, α, μ, ν; tolerance = 10e-9)
	response_probs = first.(probability_tuples)
	response_qrobs = last.(probability_tuples)
    plot(title = "Traffic at each server for varying λ1 for λ2 = $(dp_string(λ2, 3))",
        legend = :outerright,
        size = (800, 600))
    plot!(iter, response_probs, label = "p⋆", ylims = (0,1), xlims = (0,1.76))
    plot!(iter, response_qrobs, label = "q⋆")
    plot!(xlabel = "α", ylabel = "probability")

	p1_assumptions = calculate_assumptions(response_probs, response_qrobs, λ1, λ2, α, μ, ν; which = "both")
    p2_assumptions = calculate_assumptions(response_probs, response_qrobs, λ2, λ1, α, μ, ν; which = "both")
    μ1_shapes = shapes_from_intervals(shaded_regions(p1_assumptions[1], iter))
    ν1_shapes = shapes_from_intervals(shaded_regions(p1_assumptions[2], iter))
    μ2_shapes = shapes_from_intervals(shaded_regions(p2_assumptions[1], iter))
    ν2_shapes = shapes_from_intervals(shaded_regions(p2_assumptions[2], iter))
    vec_shapes = [μ1_shapes, ν1_shapes, μ2_shapes, ν2_shapes]
    resized_shapes = resize_interval_shapes(vec_shapes)

    plot!(resized_shapes[1], colour=:red, label = ["μ overload p1" fill(nothing, 1, length(vec_shapes)-1)], alpha=0.3)
    plot!(resized_shapes[2], colour=:blue, label = ["ν overload p1" fill(nothing, 1, length(vec_shapes)-1)], alpha=0.3)
    plot!(resized_shapes[3], colour=:green, label = ["μ overload p2" fill(nothing, 1, length(vec_shapes)-1)], alpha=0.3)
    plot!(resized_shapes[4], colour=:yellow, label = ["ν overload p2" fill(nothing, 1, length(vec_shapes)-1)], alpha=0.3)
end

# ╔═╡ Cell order:
# ╠═b3d3eb60-ebda-11eb-235d-e74878a5428b
# ╟─a98046a7-79d4-4568-bee9-27cb1059a288
# ╠═9634d95f-2296-4853-82fd-2ad2b41325d2
# ╠═917b7737-42ae-4ed6-a79d-4061e15c182c
# ╠═ad4dac58-8be4-4d28-be6f-075ba3393ece
# ╠═b5d9d0e7-1b7b-4bdb-a393-c6bccc69d183


text:
function value_of(::Type{StepNormalizerMode}, arg0::JString)
    return jcall(StepNormalizerMode, "valueOf", StepNormalizerMode, (JString,), arg0)
end

function values(::Type{StepNormalizerMode})
    return jcall(StepNormalizerMode, "values", Vector{StepNormalizerMode}, ())
end


text:
# ---
# title: 1362. Closest Divisors
# id: problem1362
# author: Tian Jun
# date: 2020-10-31
# difficulty: Medium
# categories: Math
# link: <https://leetcode.com/problems/closest-divisors/description/>
# hidden: true
# ---
#
# Given an integer `num`, find the closest two integers in absolute difference
# whose product equals `num + 1` or `num + 2`.
#
# Return the two integers in any order.
#
#
#
# **Example 1:**
#
#
#
#     Input: num = 8
#     Output: [3,3]
#     Explanation: For num + 1 = 9, the closest divisors are 3 & 3, for num + 2 = 10, the closest divisors are 2 & 5, hence 3 & 3 is chosen.
#
#
# **Example 2:**
#
#
#
#     Input: num = 123
#     Output: [5,25]
#
#
# **Example 3:**
#
#
#
#     Input: num = 999
#     Output: [40,25]
#
#
#
#
# **Constraints:**
#
#   * `1 <= num <= 10^9`
#
#
## @lc code=start
using LeetCode

## add your code here:
## @lc code=end


text:
module Anatomy

using AbstractTrees, GeometryTypes

import Base: OneTo, to_index

export AbstractAnatomicalStructure,
       AnatomicalStructure,
       BilateralStructure,
       LeftStructure,
       RightStructure,
       AnatomicalVector,
       children,
       nchildren,
       left,
       right,
       splitbilaterals

include("anatomicalstructures.jl")
include("positions.jl")
include("anatomicalvector.jl")

include("atlas.jl")
include("Neuroanatomy/Neuroanatomy.jl")

"""
Two quick questions:

2. What is the best way to feed `Makie.jl` mesh components for plotting?
    - A mesh type form
"""

end # module


text:
# Starting random numbers example for Learning Julia
using Random

# generate a random number between 0 and 1
println(rand(), "\n")

# pick a random element from a given collection
for i in 1:3
    println(rand([1, 2, 3, 4, 5, 6])) # choosing 3 random items from the specified array
end
println()

# populate an array with random values
arr = rand(UInt8, 5) # populate an array with 5 unsigned Int8
println(arr, "\n")

# generate a random string
println(randstring("ABCD")) # default: generate a size 8 random string
                            # selected from the specified string
println(randstring('a':'z', 6))
println()

# shuffle a list of elements
vowels = ["A", "E", "I", "O", "U"]
Random.shuffle!(vowels)
println(vowels, "\n")

# use the seed function to control the random number generator
Random.seed!(1000)
println(rand(), ", ", rand())
println("--------")
Random.seed!(1000)
println(rand(), ", ", rand())

max_stars_repo_name: scaotravis/Julia-Course

max_issues_repo_name: scaotravis/Julia-Course

max_forks_repo_name: scaotravis/Julia-Course


text:
# This file contains friendly type-pyracy on `convert` for GeoFormatTypes.jl types

"""
    convert(
        target::Type{<:GeoFormatTypes.GeoFormat},
        mode::Union{GeoFormatTypes.FormatMode, Type{GeoFormatTypes.FormatMode}},
        source::GeoFormatTypes.GeoFormat
    )

Convert a `GeoFormatTypes.GeoFormat` object to Geometry, then to the target format.
The Geom trait is needed to separate out convert for CRS for WellKnownText
and GML, which may contain both.

Both `Geom` and `Mixed` formats are converted to Geometries by default.
To convert a `Mixed` format to crs, `CRS` must be explicitly passed for `mode`.
"""

Base.convert(target::Type{<:GFT.GeoFormat}, mode::Union{GFT.FormatMode,Type{GFT.FormatMode}},
             source::GFT.GeoFormat) =
    convert(target, convert(AbstractGeometry, source))

"""
    convert(::Type{<:AbstractGeometry}, source::GeoFormatTypes.AbstractWellKnownText)
    convert(::Type{<:AbstractGeometry}, source::GeoFormatTypes.WellKnownBinary)
    convert(::Type{<:AbstractGeometry}, source::GeoFormatTypes.GeoJSON)
    convert(::Type{<:AbstractGeometry}, source::GeoFormatTypes.GML)

Convert `GeoFormat` geometry data to an ArchGDAL `Geometry` type
"""

Base.convert(::Type{<:AbstractGeometry}, source::GFT.AbstractWellKnownText) =
    fromWKT(GFT.val(source))
Base.convert(::Type{<:AbstractGeometry}, source::GFT.WellKnownBinary) =
    fromWKB(GFT.val(source))
Base.convert(::Type{<:AbstractGeometry}, source::GFT.GeoJSON) =
    fromJSON(GFT.val(source))
Base.convert(::Type{<:AbstractGeometry}, source::GFT.GML) =
    fromGML(GFT.val(source))

"""
    convert(::Type{<:GeoFormatTypes.AbstractWellKnownText}, source::AbstractGeometry)
    convert(::Type{<:GeoFormatTypes.WellKnownBinary}, source::AbstractGeometry)
    convert(::Type{<:GeoFormatTypes.GeoJSON}, source::AbstractGeometry)
    convert(::Type{<:GeoFormatTypes.GML}, source::AbstractGeometry)
    convert(::Type{<:GeoFormatTypes.KML}, source::AbstractGeometry)

Convert `AbstractGeometry` data to any geometry `GeoFormat`.
"""

Base.convert(::Type{<:GFT.AbstractWellKnownText}, source::AbstractGeometry) =
    GFT.WellKnownText(GFT.Geom(), toWKT(source))
Base.convert(::Type{<:GFT.WellKnownBinary}, source::AbstractGeometry) =
    GFT.WellKnownBinary(GFT.Geom(), toWKB(source))
Base.convert(::Type{<:GFT.GeoJSON}, source::AbstractGeometry) =
    GFT.GeoJSON(toJSON(source))
Base.convert(::Type{<:GFT.GML}, source::AbstractGeometry) =
    GFT.GML(GFT.Geom(), toGML(source))
Base.convert(::Type{<:GFT.KML}, source::AbstractGeometry) =
    GFT.KML(toKML(source))

"""
    convert(target::Type{<:GeoFormatTypes.GeoFormat}, mode::CRS, source::GeoFormat)

Convert `GeoFormat` CRS data to another `GeoFormat` CRS type.
"""

Base.convert(target::Type{<:GFT.GeoFormat}, mode::Union{GFT.CRS,Type{GFT.CRS}},
             source::GFT.GeoFormat) =
    unsafe_convertcrs(target, importCRS(source))

unsafe_convertcrs(::Type{<:GFT.CoordSys}, crsref) =
    GFT.CoordSys(toMICoordSys(crsref))
unsafe_convertcrs(::Type{<:GFT.ProjString}, crsref) =
    GFT.ProjString(toPROJ4(crsref))
unsafe_convertcrs(::Type{<:GFT.WellKnownText}, crsref) =
    GFT.WellKnownText(GFT.CRS(), toWKT(crsref))
unsafe_convertcrs(::Type{<:GFT.ESRIWellKnownText}, crsref) =
    GFT.ESRIWellKnownText(GFT.CRS(), toWKT(morphtoESRI!(crsref)))
unsafe_convertcrs(::Type{<:GFT.GML}, crsref) =
    GFT.GML(toXML(crsref))


text:
const default_color_section = :red
section_color() = Base.repl_color("NCDATASET_SECTION_COLOR" , default_color_section)

const default_color_attribute = :cyan
attribute_color() = Base.repl_color("NCDATASET_ATTRIB_COLOR" , default_color_attribute)

const default_color_variable = :green
variable_color() = Base.repl_color("NCDATASET_VARIABLE_COLOR" , default_color_variable)


text:
# creates a Scale.color_discrete_manual based on a vector / DataFrame column and a Dict
# every unique value in the vector must be a key in the dict
# returns Scale.color_discrete_manual with color order such that Gadfly plotting with color=myColumn will give colors as specified by the Dict.
groupcolors(v, dict::Dict) = Scale.color_discrete_manual(map(x->dict[x], unique(v))...)


text:
int_rules_3_1_3 = @theory begin

    #= ::Subsection::Closed:: =#
    #= 3.1.3*(d+e*x^r)^q*(a+b*log(c*x^n))^p =#
    @apply_utils Antiderivative((~d + ~(e') * (~x) ^ ~(r')) ^ ~(q') * (~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))), ~x) => With([u = IntHide((~d + ~e * (~x) ^ ~r) ^ ~q, ~x)], u * (~a + ~b * log(~c * (~x) ^ ~n)) - ~b * ~n * Antiderivative(SimplifyIntegrand(u / ~x, ~x), ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n, ~r], ~x) && IGtQ(~q, 0)
    @apply_utils Antiderivative((~d + ~(e') * (~x) ^ ~(r')) ^ ~(q') * (~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))), ~x) => With([u = IntHide((~d + ~e * (~x) ^ ~r) ^ ~q, ~x)], Dist(~a + ~b * log(~c * (~x) ^ ~n), u) - ~b * ~n * Antiderivative(SimplifyIntegrand(u / ~x, ~x), ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n, ~r], ~x) && IGtQ(~q, 0)
    @apply_utils Antiderivative((~d + ~(e') * (~x) ^ ~(r')) ^ ~q * (~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))), ~x) => (~x * (~d + ~e * (~x) ^ ~r) ^ (~q + 1) * (~a + ~b * log(~c * (~x) ^ ~n))) / ~d - ((~b * ~n) / ~d) * Antiderivative((~d + ~e * (~x) ^ ~r) ^ (~q + 1), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n, ~q, ~r], ~x) && EqQ(~r * (~q + 1) + 1, 0)
    #= Antiderivative(((~a')+(~b')*log((~c')*(~x)^(~n')))^(~p')/((~d)+(~e')*(~x)^(~r')),~x) :=  1/e*Antiderivative((a+b*log(c*x^n))^p/x^r,x) - d/e*Antiderivative((a+b*log(c*x^n))^p/(x^r*(d+e*x^r)),x) <--  FreeQ([a,b,c,d,e,n,r],x) && IGtQ(p,0) && IGtQ(r,0) =#
    @apply_utils Antiderivative(log(~(c') * ~x) / (~d + ~(e') * ~x), ~x) => (-1 / ~e) * PolyLog(2, 1 - ~c * ~x) <-- FreeQ([~c, ~d, ~e], ~x) && EqQ(~e + ~c * ~d, 0)
    @apply_utils Antiderivative((~(a') + ~(b') * log(~(c') * ~x)) / (~d + ~(e') * ~x), ~x) => ((~a + ~b * log((-(~c) * ~d) / ~e)) * log(~d + ~e * ~x)) / ~e + ~b * Antiderivative(log((-(~e) * ~x) / ~d) / (~d + ~e * ~x), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e], ~x) && GtQ((-(~c) * ~d) / ~e, 0)
    @apply_utils Antiderivative((~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) ^ ~(p') / (~d + ~(e') * ~x), ~x) => (log(1 + (~e * ~x) / ~d) * (~a + ~b * log(~c * (~x) ^ ~n)) ^ ~p) / ~e - ((~b * ~n * ~p) / ~e) * Antiderivative((log(1 + (~e * ~x) / ~d) * (~a + ~b * log(~c * (~x) ^ ~n)) ^ (~p - 1)) / ~x, ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n], ~x) && IGtQ(~p, 0)
    @apply_utils Antiderivative((~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) ^ ~(p') / (~d + ~(e') * ~x) ^ 2, ~x) => (~x * (~a + ~b * log(~c * (~x) ^ ~n)) ^ ~p) / (~d * (~d + ~e * ~x)) - ((~b * ~n * ~p) / ~d) * Antiderivative((~a + ~b * log(~c * (~x) ^ ~n)) ^ (~p - 1) / (~d + ~e * ~x), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n, ~p], ~x) && GtQ(~p, 0)
    @apply_utils Antiderivative((~d + ~(e') * ~x) ^ ~(q') * (~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) ^ ~(p'), ~x) => ((~d + ~e * ~x) ^ (~q + 1) * (~a + ~b * log(~c * (~x) ^ ~n)) ^ ~p) / (~e * (~q + 1)) - ((~b * ~n * ~p) / (~e * (~q + 1))) * Antiderivative(((~d + ~e * ~x) ^ (~q + 1) * (~a + ~b * log(~c * (~x) ^ ~n)) ^ (~p - 1)) / ~x, ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n, ~p, ~q], ~x) && (GtQ(~p, 0) && (NeQ(~q, -1) && (EqQ(~p, 1) || (IntegersQ(2 * ~p, 2 * ~q) && Not(IGtQ(~q, 0)) || EqQ(~p, 2) && NeQ(~q, 1)))))
    @apply_utils Antiderivative((~d + ~(e') * ~x) ^ ~(q') * (~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) ^ ~p, ~x) => ((~x * (~d + ~e * ~x) ^ ~q * (~a + ~b * log(~c * (~x) ^ ~n)) ^ (~p + 1)) / (~b * ~n * (~p + 1)) + ((~d * ~q) / (~b * ~n * (~p + 1))) * Antiderivative((~d + ~e * ~x) ^ (~q - 1) * (~a + ~b * log(~c * (~x) ^ ~n)) ^ (~p + 1), ~x)) - ((~q + 1) / (~b * ~n * (~p + 1))) * Antiderivative((~d + ~e * ~x) ^ ~q * (~a + ~b * log(~c * (~x) ^ ~n)) ^ (~p + 1), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n], ~x) && (LtQ(~p, -1) && GtQ(~q, 0))
    @apply_utils Antiderivative((~d + ~(e') * (~x) ^ 2) ^ ~(q') * (~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))), ~x) => ((~x * (~d + ~e * (~x) ^ 2) ^ ~q * (~a + ~b * log(~c * (~x) ^ ~n))) / (2 * ~q + 1) - ((~b * ~n) / (2 * ~q + 1)) * Antiderivative((~d + ~e * (~x) ^ 2) ^ ~q, ~x)) + ((2 * ~d * ~q) / (2 * ~q + 1)) * Antiderivative((~d + ~e * (~x) ^ 2) ^ (~q - 1) * (~a + ~b * log(~c * (~x) ^ ~n)), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n], ~x) && GtQ(~q, 0)
    @apply_utils Antiderivative((~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) / (~d + ~(e') * (~x) ^ 2) ^ (3 / 2), ~x) => (~x * (~a + ~b * log(~c * (~x) ^ ~n))) / (~d * sqrt(~d + ~e * (~x) ^ 2)) - ((~b * ~n) / ~d) * Antiderivative(1 / sqrt(~d + ~e * (~x) ^ 2), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n], ~x)
    @apply_utils Antiderivative((~d + ~(e') * (~x) ^ 2) ^ ~q * (~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))), ~x) => (-(~x) * (~d + ~e * (~x) ^ 2) ^ (~q + 1) * (~a + ~b * log(~c * (~x) ^ ~n))) / (2 * ~d * (~q + 1)) + ((~b * ~n) / (2 * ~d * (~q + 1))) * Antiderivative((~d + ~e * (~x) ^ 2) ^ (~q + 1), ~x) + ((2 * ~q + 3) / (2 * ~d * (~q + 1))) * Antiderivative((~d + ~e * (~x) ^ 2) ^ (~q + 1) * (~a + ~b * log(~c * (~x) ^ ~n)), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n], ~x) && LtQ(~q, -1)
    @apply_utils Antiderivative((~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) / (~d + ~(e') * (~x) ^ 2), ~x) => With([u = IntHide(1 / (~d + ~e * (~x) ^ 2), ~x)], u * (~a + ~b * log(~c * (~x) ^ ~n)) - ~b * ~n * Antiderivative(u / ~x, ~x)) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n], ~x)
    @apply_utils Antiderivative((~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) / sqrt(~d + ~(e') * (~x) ^ 2), ~x) => (asinh((Rt(~e, 2) * ~x) / sqrt(~d)) * (~a + ~b * log(~c * (~x) ^ ~n))) / Rt(~e, 2) - ((~b * ~n) / Rt(~e, 2)) * Antiderivative(asinh((Rt(~e, 2) * ~x) / sqrt(~d)) / ~x, ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n], ~x) && (GtQ(~d, 0) && PosQ(~e))
    @apply_utils Antiderivative((~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) / sqrt(~d + ~(e') * (~x) ^ 2), ~x) => (asin((Rt(-(~e), 2) * ~x) / sqrt(~d)) * (~a + ~b * log(~c * (~x) ^ ~n))) / Rt(-(~e), 2) - ((~b * ~n) / Rt(-(~e), 2)) * Antiderivative(asin((Rt(-(~e), 2) * ~x) / sqrt(~d)) / ~x, ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n], ~x) && (GtQ(~d, 0) && NegQ(~e))
    @apply_utils Antiderivative((~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) / sqrt(~d + ~(e') * (~x) ^ 2), ~x) => (sqrt(1 + (~e / ~d) * (~x) ^ 2) / sqrt(~d + ~e * (~x) ^ 2)) * Antiderivative((~a + ~b * log(~c * (~x) ^ ~n)) / sqrt(1 + (~e / ~d) * (~x) ^ 2), ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n], ~x) && Not(GtQ(~d, 0))
    @apply_utils Antiderivative((~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) / (sqrt(~d1 + ~(e1') * ~x) * sqrt(~d2 + ~(e2') * ~x)), ~x) => (sqrt(1 + ((~e1 * ~e2) / (~d1 * ~d2)) * (~x) ^ 2) / (sqrt(~d1 + ~e1 * ~x) * sqrt(~d2 + ~e2 * ~x))) * Antiderivative((~a + ~b * log(~c * (~x) ^ ~n)) / sqrt(1 + ((~e1 * ~e2) / (~d1 * ~d2)) * (~x) ^ 2), ~x) <-- FreeQ([~a, ~b, ~c, ~d1, ~e1, ~d2, ~e2, ~n], ~x) && EqQ(~d2 * ~e1 + ~d1 * ~e2, 0)
    @apply_utils Antiderivative((~d + ~(e') * (~x) ^ ~(r')) ^ ~(q') * (~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))), ~x) => With([u = IntHide((~d + ~e * (~x) ^ ~r) ^ ~q, ~x)], Dist(~a + ~b * log(~c * (~x) ^ ~n), u, ~x) - ~b * ~n * Antiderivative(SimplifyIntegrand(u / ~x, ~x), ~x) <-- EqQ(~r, 1) && IntegerQ(~q - 1 / 2) || (EqQ(~r, 2) && EqQ(~q, -1) || InverseFunctionFreeQ(u, ~x))) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n, ~q, ~r], ~x) && (IntegerQ(2 * ~q) && IntegerQ(~r))
    @apply_utils Antiderivative((~d + ~(e') * (~x) ^ ~(r')) ^ ~(q') * (~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) ^ ~(p'), ~x) => With([u = ExpandIntegrand((~a + ~b * log(~c * (~x) ^ ~n)) ^ ~p, (~d + ~e * (~x) ^ ~r) ^ ~q, ~x)], Antiderivative(u, ~x) <-- SumQ(u)) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n, ~p, ~q, ~r], ~x) && (IntegerQ(~q) && (GtQ(~q, 0) || IGtQ(~p, 0) && IntegerQ(~r)))
    @apply_utils Antiderivative((~d + ~(e') * (~x) ^ ~(r')) ^ ~(q') * (~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) ^ ~(p'), ~x) => Unintegrable((~d + ~e * (~x) ^ ~r) ^ ~q * (~a + ~b * log(~c * (~x) ^ ~n)) ^ ~p, ~x) <-- FreeQ([~a, ~b, ~c, ~d, ~e, ~n, ~p, ~q, ~r], ~x)
    @apply_utils Antiderivative((~u) ^ ~(q') * (~(a') + ~(b') * log(~(c') * (~x) ^ ~(n'))) ^ ~(p'), ~x) => Antiderivative(ExpandToSum(~u, ~x) ^ ~q * (~a + ~b * log(~c * (~x) ^ ~n)) ^ ~p, ~x) <-- FreeQ([~a, ~b, ~c, ~n, ~p, ~q], ~x) && (BinomialQ(~u, ~x) && Not(BinomialMatchQ(~u, ~x)))
end

max_stars_repo_path: src/rules/3 Logarithms/3.1.3 (d+e x^r)^q (a+b log(c x^n))^p.jl


text:
using RigidBodyTools
using Test

include("motions.jl")
include("bodies.jl")


text:
# This file is a part of JuliaFEM.
# License is MIT: see https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/LICENSE.md

using JuliaFEM
using JuliaFEM.Preprocess
using JuliaFEM.Testing

@testset "test tet4 + volume load" begin
    X1 = [2.0, 3.0, 4.0]
    X2 = [6.0, 3.0, 2.0]
    X3 = [2.0, 5.0, 1.0]
    X4 = [4.0, 3.0, 6.0]
    e1 = Element(Tet4, [1, 2, 3, 4])
    e1["geometry"] = Node[X1, X2, X3, X4]
    e1["youngs modulus"] = 96.0
    e1["poissons ratio"] = 1/3
    e1["displacement load 3"] = 784.0/110.0
    e2 = Element(Tri3, [1, 2, 3])
    e2["geometry"] = Node[X2, X1, X3]
    e2["displacement 1"] = 0.0
    e2["displacement 2"] = 0.0
    e2["displacement 3"] = 0.0
    p1 = Problem(Elasticity, "tetra", 3)
    p2 = Problem(Dirichlet, "bc", 3, "displacement")
    push!(p1, e1)
    push!(p2, e2)
    s = Solver(Linear)
    push!(s, p1, p2)
    s()
    u_4 = p1.assembly.u[10:end]
    u_expected = [-3.0/220.0, -9.0/220.0, 1.0/10.0]
    @test isapprox(u_4, u_expected)
end

@testset "test tet4 + surface load" begin
    nodes = Dict{Int, Vector{Float64}}(
        1 => [2.0, 3.0, 4.0],
        2 => [6.0, 3.0, 2.0],
        3 => [2.0, 5.0, 1.0],
        4 => [4.0, 3.0, 6.0])
    e1 = Element(Tet4, [1, 2, 3, 4])
    update!(e1, "geometry", nodes)
    e1["youngs modulus"] = 96.0
    e1["poissons ratio"] = 1/3
    e2 = Element(Tri3, [1, 2, 3])
    update!(e2, "geometry", nodes)
    e2["displacement 1"] = 0.0
    e2["displacement 2"] = 0.0
    e2["displacement 3"] = 0.0
    e3 = Element(Tri3, [4, 3, 2])
    update!(e3, "geometry", nodes)
    update!(e3, "surface pressure", -96.0)
    p1 = Problem(Elasticity, "tetra", 3)
    p2 = Problem(Dirichlet, "bc", 3, "displacement")
    push!(p1, e1, e3)
    push!(p2, e2)
    s = Solver(Linear)
    push!(s, p1, p2)
    s()
    u_4 = p1.assembly.u[10:end]
    u_expected = [-17.0/14.0, -27.0/14.0, 1.0]
    info("u_4 = $(u_4)")
    info("u_expected = $(u_expected)")
    @test isapprox(u_4, u_expected)
end

#= TODO: Fix test. Make linear perturbation solver.
@testset "test tet4 + buckling" begin
    X = Dict{Int, Vector{Float64}}(
        1 => [2.0, 3.0, 4.0],
        2 => [6.0, 3.0, 2.0],
        3 => [2.0, 5.0, 1.0],
        4 => [4.0, 3.0, 6.0])
    u = Dict{Int, Vector{Float64}}(
        1 => [0.0, 0.0, 0.0],
        2 => [0.0, 0.0, 0.0],
        3 => [0.0, 0.0, 0.0],
        4 => [-0.25, -0.25, -0.25])
    e1 = Element(Tet4, [1, 2, 3, 4])
    update!(e1, "geometry", X)
    update!(e1, "displacement", u)
    update!(e1, "youngs modulus", 96.0)
    update!(e1, "poissons ratio", 1/3)
    p1 = Problem(Elasticity, "tetra", 3)
    p1.properties.formulation = :continuum_buckling
    push!(p1, e1)
    assemble!(p1, 0.0)
    free_dofs = [10, 11, 12]
    Km = sparse(p1.assembly.K)[free_dofs, free_dofs]
    Kg = sparse(p1.assembly.Kg)[free_dofs, free_dofs]
    dump(full(Km))
    dump(full(Kg))
    la = sort(eigs(Km, -Kg)[1])
    la_expected = [1.0, 4.0]
    info("la = $la")
    info("la_expected = $(la_expected)")
    @test isapprox(la, la_expected)
end
=#


text:
#!/usr/bin/env julia
# del2z <delta.z@aliyun.com>

module FastText

using Flux

end


text:
# ---
# title: 1340. Jump Game V
# id: problem1340
# author: Tian Jun
# date: 2020-10-31
# difficulty: Hard
# categories: Dynamic Programming
# link: <https://leetcode.com/problems/jump-game-v/description/>
# hidden: true
# ---
#
# Given an array of integers `arr` and an integer `d`. In one step you can jump
# from index `i` to index:
#
#   * `i + x` where: `i + x < arr.length` and ` 0 < x <= d`.
#   * `i - x` where: `i - x >= 0` and ` 0 < x <= d`.
#
# In addition, you can only jump from index `i` to index `j` if `arr[i] >
# arr[j]` and `arr[i] > arr[k]` for all indices `k` between `i` and `j` (More
# formally `min(i, j) < k < max(i, j)`).
#
# You can choose any index of the array and start jumping. Return _the maximum
# number of indices_  you can visit.
#
# Notice that you can not jump outside of the array at any time.
#
#
#
# **Example 1:**
#
# ![](https://assets.leetcode.com/uploads/2020/01/23/meta-chart.jpeg)
#
#
#
#     Input: arr = [6,4,14,6,8,13,9,7,10,6,12], d = 2
#     Output: 4
#     Explanation: You can start at index 10. You can jump 10 --> 8 --> 6 --> 7 as shown.
#     Note that if you start at index 6 you can only jump to index 7. You cannot jump to index 5 because 13 > 9. You cannot jump to index 4 because index 5 is between index 4 and 6 and 13 > 9.
#     Similarly You cannot jump from index 3 to index 2 or index 1.
#
#
# **Example 2:**
#
#
#
#     Input: arr = [3,3,3,3,3], d = 3
#     Output: 1
#     Explanation: You can start at any index. You always cannot jump to any index.
#
#
# **Example 3:**
#
#
#
#     Input: arr = [7,6,5,4,3,2,1], d = 1
#     Output: 7
#     Explanation: Start at index 0. You can visit all the indicies.
#
#
# **Example 4:**
#
#
#
#     Input: arr = [7,1,7,1,7,1], d = 2
#     Output: 2
#
#
# **Example 5:**
#
#
#
#     Input: arr = [66], d = 1
#     Output: 1
#
#
#
#
# **Constraints:**
#
#   * `1 <= arr.length <= 1000`
#   * `1 <= arr[i] <= 10^5`
#   * `1 <= d <= arr.length`
#
#
## @lc code=start
using LeetCode

## add your code here:
## @lc code=end


text:
using DSGE
using HDF5, Base.Test

include("../util.jl")
path = dirname(@__FILE__)

# Test hessian! in context of model
m = Model990()
m.testing = true

# Setup paths
mode = h5open(inpath(m, "user", "paramsmode.h5")) do file
    read(file, "params")
end
data = let
    df = load_data(m; try_disk=true, verbose=:none)
    DSGE.df_to_matrix(m, df)
end
hessian_expected = h5open(inpath(m, "user", "hessian.h5")) do file
    read(file, "hessian")
end

# Test subset of hessian elements.
para_free      = [!θ.fixed for θ in m.parameters]
para_free_inds = find(para_free)

max_free_ind = DSGE.n_hessian_test_params(m)
if max_free_ind < maximum(para_free_inds)
    para_free_inds = para_free_inds[1:max_free_ind]
end

@time hessian, _ = hessian!(m, mode, data; verbose=:none)

# The values here are liable to differ between machines, based on different
# architectures/multithreading. Hessian values tend to be large, so these larger tolerances
# are needed.
expect = hessian_expected[1:max_free_ind, 1:max_free_ind]
actual = hessian[1:max_free_ind, 1:max_free_ind]
@test_matrix_approx_eq_eps expect actual 0.1 3.0

m.testing = false

nothing


text:
using Gadfly

set_default_plot_size(6inch, 3inch)

plot(x=rand(12), y=rand(12), color=repeat(["a","b","c"], outer=[4]),
     Scale.color_discrete_manual("red","purple","green"))


text:
# on-device sparse array functionality

using SparseArrays

# NOTE: this functionality is currently very bare-bones, only defining the array types
#       without any device-compatible sparse array functionality

# core types

export CuSparseDeviceVector, CuSparseDeviceMatrixCSC, CuSparseDeviceMatrixCSR,
       CuSparseDeviceMatrixBSR, CuSparseDeviceMatrixCOO

struct CuSparseDeviceVector{Tv,Ti, A} <: AbstractSparseVector{Tv,Ti}
    iPtr::CuDeviceVector{Ti, A}
    nzVal::CuDeviceVector{Tv, A}
    dims::NTuple{2,Int}
    nnz::Ti
end

Base.length(g::CuSparseDeviceVector) = prod(g.dims)
Base.size(g::CuSparseDeviceVector) = g.dims
Base.ndims(g::CuSparseDeviceVector) = 1

struct CuSparseDeviceMatrixCSC{Tv,Ti,A} <: AbstractSparseMatrix{Tv,Ti}
    colPtr::CuDeviceVector{Ti, A}
    rowVal::CuDeviceVector{Ti, A}
    nzVal::CuDeviceVector{Tv, A}
    dims::NTuple{2,Int}
    nnz::Ti
end

Base.length(g::CuSparseDeviceMatrixCSC) = prod(g.dims)
Base.size(g::CuSparseDeviceMatrixCSC) = g.dims
Base.ndims(g::CuSparseDeviceMatrixCSC) = 2

struct CuSparseDeviceMatrixCSR{Tv,Ti,A} <: AbstractSparseMatrix{Tv,Ti}
    rowPtr::CuDeviceVector{Ti, A}
    colVal::CuDeviceVector{Ti, A}
    nzVal::CuDeviceVector{Tv, A}
    dims::NTuple{2, Int}
    nnz::Ti
end

Base.length(g::CuSparseDeviceMatrixCSR) = prod(g.dims)
Base.size(g::CuSparseDeviceMatrixCSR) = g.dims
Base.ndims(g::CuSparseDeviceMatrixCSR) = 2

struct CuSparseDeviceMatrixBSR{Tv,Ti,A} <: AbstractSparseMatrix{Tv,Ti}
    rowPtr::CuDeviceVector{Ti, A}
    colVal::CuDeviceVector{Ti, A}
    nzVal::CuDeviceVector{Tv, A}
    dims::NTuple{2,Int}
    blockDim::Ti
    dir::Char
    nnz::Ti
end

Base.length(g::CuSparseDeviceMatrixBSR) = prod(g.dims)
Base.size(g::CuSparseDeviceMatrixBSR) = g.dims
Base.ndims(g::CuSparseDeviceMatrixBSR) = 2

struct CuSparseDeviceMatrixCOO{Tv,Ti,A} <: AbstractSparseMatrix{Tv,Ti}
    rowInd::CuDeviceVector{Ti, A}
    colInd::CuDeviceVector{Ti, A}
    nzVal::CuDeviceVector{Tv, A}
    dims::NTuple{2,Int}
    nnz::Ti
end

Base.length(g::CuSparseDeviceMatrixCOO) = prod(g.dims)
Base.size(g::CuSparseDeviceMatrixCOO) = g.dims
Base.ndims(g::CuSparseDeviceMatrixCOO) = 2

# input/output

function Base.show(io::IO, ::MIME"text/plain", A::CuSparseDeviceVector)
    println(io, "$(length(A))-element device sparse vector at:")
    println(io, "  iPtr: $(A.iPtr)")
    print(io,   "  nzVal: $(A.nzVal)")
end

function Base.show(io::IO, ::MIME"text/plain", A::CuSparseDeviceMatrixCSR)
    println(io, "$(length(A))-element device sparse matrix CSR at:")
    println(io, "  rowPtr: $(A.rowPtr)")
    println(io, "  colVal: $(A.colVal)")
    print(io,   "  nzVal:  $(A.nzVal)")
end

function Base.show(io::IO, ::MIME"text/plain", A::CuSparseDeviceMatrixCSC)
    println(io, "$(length(A))-element device sparse matrix CSC at:")
    println(io, "  colPtr: $(A.colPtr)")
    println(io, "  rowVal: $(A.rowVal)")
    print(io,   "  nzVal:  $(A.nzVal)")
end

function Base.show(io::IO, ::MIME"text/plain", A::CuSparseDeviceMatrixBSR)
    println(io, "$(length(A))-element device sparse matrix BSR at:")
    println(io, "  rowPtr: $(A.rowPtr)")
    println(io, "  colVal: $(A.colVal)")
    print(io,   "  nzVal:  $(A.nzVal)")
end

function Base.show(io::IO, ::MIME"text/plain", A::CuSparseDeviceMatrixCOO)
    println(io, "$(length(A))-element device sparse matrix COO at:")
    println(io, "  rowPtr: $(A.rowPtr)")
    println(io, "  colInd: $(A.colInd)")
    print(io,   "  nzVal:  $(A.nzVal)")
end


text:
module DefaultApplication

import InteractiveUtils

"""
    DefaultApplication.open(filename; wait = false)

Open a file with the default application determined by the OS.

The argument `wait` is passed to `run`.
"""
function open(filename; wait = false)
    @static if Sys.isapple()
        run(`open $(filename)`; wait = wait)
    elseif Sys.islinux() || Sys.isbsd()
        run(`xdg-open $(filename)`; wait = wait)
    elseif Sys.iswindows()
        cmd = get(ENV, "COMSPEC", "cmd")
        run(`$(ENV["COMSPEC"]) /c start $(filename)`; wait = wait)
    else
        @warn("Opening files the default application is not supported on this OS.",
              KERNEL = Sys.KERNEL)
    end
end

"""
    DefaultApplication.test()

Helper function that creates text file, attempts to open it with the OS-specific
default application, and prints information that helps with debugging.
"""
function test()
    path = tempname() * ".txt"
    write(path, "some text, should be opened in a text editor")
    @info("opening text file with the default application",
          path = path)
    @info("""
        If the file was not opened, please copy the output and open an issue at
        https://github.com/tpapp/DefaultApplication.jl/issues
        """)
    InteractiveUtils.versioninfo(stdout; verbose = true)
    if Sys.iswindows()
        @info("Version information for windows",
              windows_version = Sys.windows_version())
    end
    DefaultApplication.open(path)
end

end # module