How To: Set Up a Pluto.jl Server for Teaching Purposes

By: julia on MAXIMILIAN KOEHLER

Re-posted from: https://www.maximiliankoehler.de/posts/pluto-server/

I want to share what my colleague Dennis Ogiermann and me learnt while setting up a server that I’m going to use for a teaching adventure with Julia. I’ll teach exercises in the course “Basics of FEM” for mechanical engineers.
The problems The mechanical engineering students have no or little experience with programming (and very likely no experience with a terminal) There is no time to teach them in depth programming, terminal handling, etc.

The power of lookup functions in Julia

By: Blog by Bogumił Kamiński

Re-posted from: https://bkamins.github.io/julialang/2020/10/23/argmax.html

Introduction

Julia provides four very useful general look-up functions in Base:
argmin, argmax, findmin, and findmax.

Normally they are used with arrays, like this:

julia> a = [2, 1, 5, 0]
4-element Array{Int64,1}:
 2
 1
 5
 0

julia> findmax(a)
(5, 3)

julia> argmax(a)
3

julia> findmin(a)
(0, 4)

julia> argmin(a)
4

However, the beauty of their design is that they work with arbitrary collections
of values that support comparisons. Below I give some examples.

This post was written using Julia 1.5.2, StatsBase.jl v0.32.2 and
DataFrames.jl 0.21.8.

Dictionaries

A quite useful pattern for use of these functions is with dictionaries. Here
is an example:

julia> findmax(d)
(5, 'c')

julia> argmax(d)
'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)

julia> findmin(d)
(0, 'd')

julia> argmin(d)
'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)

Now you might ask when this is useful? Consider that we have some set of
nominal values and want to find the most frequent one. Here is an easy way to
do it using StatsBase.jl:

julia> using Random, StatsBase

julia> Random.seed!(1234);

julia> r = rand(1:10, 1000);

julia> m = countmap(r)
Dict{Int64,Int64} with 10 entries:
  7  => 100
  4  => 91
  9  => 81
  10 => 110
  2  => 107
  3  => 99
  5  => 103
  8  => 107
  6  => 107
  1  => 95

julia> findmax(m) # find the frequency and value of the most frequent item
(110, 10)

julia> findall(==(findmax(m)[1]), m) # make sure it is unique
1-element Array{Int64,1}:
 10

Data frames

When working with data frames we often store data that can be lexicographically
compared. Let us consider the following simple data frame:

julia> using DataFrames

julia> Random.seed!(1234);

julia> df = DataFrame(c=rand('a':'d', 10), n=rand(10))
10×2 DataFrame
│ Row │ c    │ n        │
│     │ Char │ Float64  │
├─────┼──────┼──────────┤
│ 1   │ 'a'  │ 0.372846 │
│ 2   │ 'b'  │ 0.263121 │
│ 3   │ 'c'  │ 0.98869  │
│ 4   │ 'a'  │ 0.489858 │
│ 5   │ 'd'  │ 0.425211 │
│ 6   │ 'a'  │ 0.379765 │
│ 7   │ 'd'  │ 0.286955 │
│ 8   │ 'c'  │ 0.118085 │
│ 9   │ 'd'  │ 0.739658 │
│ 10  │ 'c'  │ 0.97138  │

Assume, as stated above, that we want to find its largest row lexicographically:

julia> findmax(eachrow(df))
(DataFrameRow
│ Row │ c    │ n        │
│     │ Char │ Float64  │
├─────┼──────┼──────────┤
│ 9   │ 'd'  │ 0.739658 │, 9)

Also because eachrow(df) returns an AbstractArray object we can also safely
use maximum function to get the following:

julia> maximum(eachrow(df))
DataFrameRow
│ Row │ c    │ n        │
│     │ Char │ Float64  │
├─────┼──────┼──────────┤
│ 9   │ 'd'  │ 0.739658 │

All this is nice and clean in a fully generic way.

Conclusions

This time conclusions will be a warning. One should clearly understand how these
functions work, as in some cases their behavior might be surprising. Here
is an example:

julia> d = Dict('a':'d' .=> 4:-1:1)
Dict{Char,Int64} with 4 entries:
  'a' => 4
  'c' => 2
  'd' => 1
  'b' => 3

julia> maximum(d)
'd' => 1

julia> findmax(d)
(4, 'a')

And we see that maximum finds a largest key-value pair while findmax
locates the largest value and returns a tuple containing this value
and a key corresponding to it.

Note though that e.g. for NamedTuple the behavior is different:

julia> nt = (a=4, b=3, c=2, d=1)
(a = 4, b = 3, c = 2, d = 1)

julia> maximum(nt)
4

julia> findmax(nt)
(4, :a)

and in this case we consistently get the largest value in both cases.