Chapter 2: variables
   - names can contain utf-8
   Chapter 3: numbers
   see last post
   Chapter 4: basic operations
   - c-like operators with additions:
   x ÷ y integer divide x / y, truncated to an integer
   x \ y inverse divide equivalent to y / x
   x ^ y power raises x to the yth power
   x ⊻ y bitwise xor (exclusive or)
   x ⊼ y bitwise nand (not and)
   x ⊽ y bitwise nor (not or)
   x >>> y logical shift right
   x >> y arithmetic shift right
   √
   - binary operators are all available as in-place op= forms too. using
   this may retype the lvalue.
   ÷ can be typed with \div<tab> in the repl, see also manual
   section [1]https://docs.julialang.org/en/v1/manual/unicode-input/#Unico
   de-Input or called as div()
   note: false * anything = 0, even NaN . This can be used to prevent
   propagation of nans.
   - boolean operators (&& ||) are short-circuiting
   - xor() nand() nor() can be called by name as binary functions
   Each operator has a .op form that performs elementwise operation on
   arrays.
   julia> [1,2,3] .^ 3
   3-element Vector{Int64}:
     1
     8
    27
   This is simply a use of the further . operator, which broadcasts
   functions over array parameters:
   julia> nand.([1,2,3],[4,3,2])
   3-element Vector{Int64}:
    -1
    -3
    -3
   Multiple dot operators in a single expression, even in-place
   assignment, are all fused into a single underlying loop over the
   combined datasize.
   Comparisons can be chained:
   julia> 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
   true
   Chaining works with elementwise comparison.
   Operators can be referenced as values by preceding them with a : .
   Details of operator precedence are canonically defined in the julia
   source code
   [2]https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm
   . Precedence and associativity can be queried at runtime by passing an
   operator to Base.operator_precedence or Base.operator_associativity .
   To convert floats to integers without throwing, use round(), ceil(),
   floor(), or trunc() . These can be passed a value: round(1.2), or a
   type and then a value: round(UInt8, 1.2).
   fld(x,y) floored division; quotient rounded towards -Inf
   cld(x,y) ceiling division; quotient rounded towards +Inf
   rem(x,y) remainder; satisfies x == div(x,y)*y + rem(x,y); sign matches
   x
   mod(x,y) modulus; satisfies x == fld(x,y)*y + mod(x,y); sign matches y
   mod1(x,y) mod with offset 1; returns r∈(0,y] for y>0 or r∈[y,0) for
   y<0, where mod(r, y) == mod(x, y)
   mod2pi(x) modulus with respect to 2pi; 0 <= mod2pi(x) < 2pi
   divrem(x,y) returns (div(x,y),rem(x,y))
   fldmod(x,y) returns (fld(x,y),mod(x,y))
   gcd(x,y...) greatest positive common divisor of x, y,...
   lcm(x,y...) least positive common multiple of x, y,...
   Sign and absolute value functions
   Function Description
   abs(x) a positive value with the magnitude of x
   abs2(x) the squared magnitude of x
   sign(x) indicates the sign of x, returning -1, 0, or +1
   signbit(x) indicates whether the sign bit is on (true) or off (false)
   copysign(x,y) a value with the magnitude of x and the sign of y
   flipsign(x,y) a value with the magnitude of x and the sign of x*y
   Powers, logs and roots
   Function Description
   sqrt(x), √x square root of x
   cbrt(x), ∛x cube root of x
   hypot(x,y) hypotenuse of right-angled triangle with other sides of
   length x and y
   exp(x) natural exponential function at x
   expm1(x) accurate exp(x)-1 for x near zero
   ldexp(x,n) x*2^n computed efficiently for integer values of n
   log(x) natural logarithm of x
   log(b,x) base b logarithm of x
   log2(x) base 2 logarithm of x
   log10(x) base 10 logarithm of x
   log1p(x) accurate log(1+x) for x near zero
   exponent(x) binary exponent of x
   significand(x) binary significand (a.k.a. mantissa) of a floating-point
   number x
   sin    cos    tan    cot    sec    csc
   sinh   cosh   tanh   coth   sech   csch
   asin   acos   atan   acot   asec   acsc
   asinh  acosh  atanh  acoth  asech  acsch
   sinc   cosc
   , with atan also accepting two arguments corresponding to a traditional
   atan2 function.
   sinpi(x) and cospi(x) are provided for more accurate computations of
   sin(pi*x) and cos(pi*x) respectively.
   In order to compute trigonometric functions with degrees instead of
   radians, suffix the function with d.
   sind   cosd   tand   cotd   secd   cscd
   asind  acosd  atand  acotd  asecd  acscd
   More functions:
   [3]https://github.com/JuliaMath/SpecialFunctions.jl
   Homework: Write a julia script that produces a 2x2 matrix containing
   pixels for a raytraced sphere.

References

   1. https://docs.julialang.org/en/v1/manual/unicode-input/#Unicode-Input
   2. https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm
   3. https://github.com/JuliaMath/SpecialFunctions.jl