The Nextjournal Julia Environment

]st

using Plots; gr()

# define the Lorenz attractor

mutable struct Lorenz

    dt; σ; ρ; β; x; y; z

end

function step!(l::Lorenz)

    dx = l.σ*(l.y - l.x)       ; l.x += l.dt * dx

    dy = l.x*(l.ρ - l.z) - l.y ; l.y += l.dt * dy

    dz = l.x*l.y - l.β*l.z     ; l.z += l.dt * dz

end

attractor = 

  Lorenz((dt = 0.02, σ = 10., ρ = 28., β = 8//3, x = 1., y = 1., z = 1.)...)

# initialize a 3D plot with 1 empty series

plt = plot3d(1, xlim=(-25,25), ylim=(-25,25), zlim=(0,50),

             title = "Lorenz Attractor", marker = 2)

# build an animated gif by pushing new points to the plot, saving every 10th frame

@gif for i=1:1500

    step!(attractor)

    push!(plt, attractor.x, attractor.y, attractor.z)

end every 10

plotly(lw=3)

x = -100:100

Plots.plot(x, 100x.^2)

Plots.plot!(x, x.^3 - x.^2)

using WGLMakie, AbstractPlotting, LinearAlgebra

n = 20

set_theme!(resolution = (600, 500))

f   = (x,y,z) -> x*exp(cos(y)*z)

∇f  = (x,y,z) -> Point3f0(exp(cos(y)*z), -sin(y)*z*x*exp(cos(y)*z), x*cos(y)*exp(cos(y)*z))

∇ˢf = (x,y,z) -> ∇f(x,y,z) - Point3f0(x,y,z)*dot(Point3f0(x,y,z), ∇f(x,y,z))

θ = [0;(0.5:n-0.5)/n;1]

φ = [(0:2n-2)*2/(2n-1);2]

x = [cospi(φ)*sinpi(θ) for θ in θ, φ in φ]

y = [sinpi(φ)*sinpi(θ) for θ in θ, φ in φ]

z = [cospi(θ) for θ in θ, φ in φ]

pts = vec(Point3f0.(x, y, z))

∇ˢF = vec(∇ˢf.(x, y, z)) .* 0.1f0

AbstractPlotting.surface(x, y, z)

AbstractPlotting.arrows!(pts, ∇ˢF, arrowsize = 0.03, linecolor = (:white, 0.6), linewidth = 3)

using VegaLite, VegaDatasets

vega_plot = dataset("cars") |>

@vlplot(

    :point,

    x = :Horsepower,

    y = :Miles_per_Gallon,

    color = :Origin,

    width = 650,

    height = 400

) |> VegaLite.interactive()

using HDF5

# Some methods to traverse the first path in an h5 file.

dd(node::HDF5File) = dd(node[names(node)[1]])

dd(node::HDF5Group) = dd(node[names(node)[1]])

dd(node::HDF5Dataset) = node

dspath = h5open(
NEONDSTowerTemperatureData.hdf5
) do h5

  name(dd(h5))

end

print("First path: $dspath.")

data = h5read(
NEONDSTowerTemperatureData.hdf5
, dspath)

using Plots

Plots.plot([x.data[1] for x in data],[y.data[3] for y in data],

  xrotation=45,legend=:none)

using JLD

struct testData

  x::Int64

  y::String

end

foo = testData(7,"test")

save("/tmp/blah.jld", "foo", foo)

load("/tmp/blah.jld")

using FileIO

load(File(format"CSV",
iris.csv
))

using DataFrames

df = DataFrame(A = 1:5, B = 1:2:10, C = ["a","b","c","d","q"])

df.A .+ df.B

json(["foo", Dict("bar" => ("baz", nothing, 1.0, 2))])

tarArch='x86_64'

dirArch='x64'

JULIA_VERSION_SHORT=${JULIA_VERSION/-rc/}

FILENAME="julia-${JULIA_VERSION}-linux-${tarArch}.tar.gz"

FILEURL="https://julialang-s3.julialang.org/bin/linux/${dirArch}/${JULIA_VERSION_SHORT%[.-]*}/${FILENAME}"

echo "Downloading ${FILEURL}."

curl -fL -o julia.sha256 \

  "https://julialang-s3.julialang.org/bin/checksums/julia-${JULIA_VERSION}.sha256"

curl -fL -o julia.tar.gz.asc "${FILEURL}.asc"

curl -fL -o julia.tar.gz "${FILEURL}"

echo `grep $FILENAME julia.sha256 | cut -d " " -f1` > j256sig

sha256=`cat j256sig`

echo "${sha256} *julia.tar.gz" | sha256sum -c -

export GNUPGHOME="$(mktemp -d)"

JULIA_GPG="3673DF529D9049477F76B37566E3C7DC03D6E495"

gpg --keyserver ha.pool.sks-keyservers.net --recv-keys "$JULIA_GPG"

gpg --batch --verify julia.tar.gz.asc julia.tar.gz

command -v gpgconf > /dev/null && gpgconf --kill all

rm -rf "$GNUPGHOME" julia.tar.gz.asc julia.sha256

mkdir -p "$JULIA_PATH"

tar -xzf julia.tar.gz -C "$JULIA_PATH" --strip-components 1

rm julia.tar.gz j256sig

julia -v

julia -e 'using Pkg; pkg"up; add JSON; precompile"'

julia -e 'using Pkg; pkg"add Conda; build Conda; precompile"'

du -hsx /

"$VERSION"

apt-get -qq update

DEBIAN_FRONTEND=noninteractive apt-get install --no-install-recommends \

  imagemagick libhdf5-dev hdf5-tools mesa-utils \

  libxt6 libxrender1 libgl1-mesa-glx libqt5widgets5 `# for GR` \

  libhttp-parser2.7.1 `# for PlotlyJS`

apt-get clean

rm -r /var/lib/apt/lists/* # Clear package list so it isn't stale

]up; add SoftGlobalScope DataFrames JLD CSV CSVFiles Netpbm NRRD MeshIO HDF5 MAT FileIO JSExpr CSSUtil StatsBase StatsPlots Observables Interact WebSockets HTTP Blink WebIO PlotlyBase PlotlyJS RecipesBase GR Plots ImageCore ImageShow ImageMagick Colors BenchmarkTools FixedPointNumbers IJulia

]dev VegaLite; add VegaDatasets

NODE_FN="node-v${NODE_VERSION}-linux-x64"

NODE_URL="https://nodejs.org/dist/v${NODE_VERSION}/${NODE_FN}.tar.xz"

cd /opt

curl $NODE_URL | tar -Jx

ln -s $NODE_FN node

npm config set python /opt/conda/bin/python

npm config set unsafe-perm true # required because we are root

# Install to VegaLite.jl's directory

cd /root/.julia/dev/VegaLite/deps

npm install --scripts-prepend-node-path=true \

  --production --no-package-lock --no-optional

]add https://github.com/JuliaPlots/WGLMakie.jl Observables AbstractPlotting#master JSCall#master

]build

]precompile

using AbstractPlotting

for res in (AbstractPlotting.High, AbstractPlotting.Low)

  AbstractPlotting.set_glyph_resolution!(res)

  AbstractPlotting.cached_load();

end

using SoftGlobalScope, DataFrames, JLD, CSV, CSVFiles, Netpbm, NRRD, MeshIO, HDF5, MAT, FileIO, JSExpr, CSSUtil, StatsBase, StatsPlots, Observables, Interact, WebSockets, HTTP, Blink, WebIO, PlotlyBase, PlotlyJS, RecipesBase, GR, Plots, ImageCore, ImageShow, ImageMagick, Colors, BenchmarkTools, FixedPointNumbers, IJulia, WGLMakie, AbstractPlotting

IJulia.verbose

"$(Pkg.installed()["SoftGlobalScope"])"

"$(Pkg.installed()["GR"])"

"$(Pkg.installed()["PlotlyBase"])"

"$(Pkg.installed()["PlotlyJS"])"

"$(Pkg.installed()["Plots"])"

"$(Pkg.installed()["AbstractPlotting"])"

"$(Pkg.installed()["JLD"])"

"$(Pkg.installed()["CSV"])"

"$(Pkg.installed()["HDF5"])"

"$(Pkg.installed()["JSON"])"

"$(Pkg.installed()["FileIO"])"

"$(Pkg.installed()["DataFrames"])"

TARFILE="ffmpeg-release-amd64-static.tar.xz"

wget --progress=dot:giga \

  https://johnvansickle.com/ffmpeg/releases/${TARFILE}

wget https://johnvansickle.com/ffmpeg/releases/${TARFILE}.md5

md5sum -c ${TARFILE}.md5

cp $TARFILE /results/