{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "

Julia Overview

\n", "\n", "

Julia is a language for scientific computing that has similar features as Matlab and Python, but can usually (via automatic just-in-time compilation) achieve performance close to C/C++.

\n", "

Similarly to Python, it can be used interactively on the terminal, for executing script files, or via notebooks. The basic language and the accompanying tools are free software.

\n", "

This is a brief overview of syntax and capabilities. A complete documentation can be found here.

" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Links

\n", "\n", "

Software

\n", "\n", "

Documentation

\n", "\n", "

Examples

\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Basics

\n", "

Built-in capabilities for handling matrices and vectors similar to Matlab

" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2×2 Array{Float64,2}:\n", " 4.0 -1.0\n", " 1.0 2.0" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = [4. -1.; 1. 2.]" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2-element Array{Float64,1}:\n", " 1.0\n", " 2.0" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b = [1., 2.]" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2-element Array{Float64,1}:\n", " 0.4444444444444444\n", " 0.7777777777777778" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = A\\b # solve A*x = b" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2-element Array{Float64,1}:\n", " 0.9999999999999999\n", " 2.0 " ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A*x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Unlike Matlab, Julia differentiates between various basic types:\n", "" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Int64" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "i = 103491;\n", "typeof(i)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.0 + 1.0im" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = 1. + 3im\n", "b = complex(2., 1.)\n", "a/b" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"tip 17: strings are concatenated with *\"" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n = 17\n", "c = 's'\n", "s = \"tip \"*string(n)*\": string\"*string(c)*\" are concatenated with *\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Argument types are strictly enforced:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "ename": "DomainError", "evalue": "DomainError with -1.0:\nlog will only return a complex result if called with a complex argument. Try log(Complex(x)).", "output_type": "error", "traceback": [ "DomainError with -1.0:\nlog will only return a complex result if called with a complex argument. Try log(Complex(x)).", "", "Stacktrace:", " [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31", " [2] log(::Float64) at ./special/log.jl:285", " [3] top-level scope at In[8]:1" ] } ], "source": [ "log(-1.)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.0 + 3.141592653589793im" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "log(complex(-1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Arbitrary unicode characters are allowed as identifiers (entered, e.g., via \\lambda [TAB], A\\^- [TAB] \\^1 [TAB]) - see also the character list" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Eigen{Float64,Float64,Array{Float64,2},Array{Float64,1}}\n", "eigenvalues:\n", "2-element Array{Float64,1}:\n", " 3.0\n", " 3.0\n", "eigenvectors:\n", "2×2 Array{Float64,2}:\n", " 0.707107 0.707107\n", " 0.707107 0.707107" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using LinearAlgebra\n", "λ, Ψ = eigen(A) # eigenvalue decomposition, with two separate return values" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2×2 Array{Float64,2}:\n", " 0.222222 0.111111\n", " -0.111111 0.444444" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A⁻¹= inv(A)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "General note: In the interactive terminal, to display the help for a specific function, type \"?\" and then its name (e.g., \"eig\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Control flow

" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tails\n" ] } ], "source": [ "c = rand();\n", "if c <= 0.49999\n", " println(\"heads\");\n", "elseif c >= 0.50001\n", " println(\"tails\");\n", "else\n", " println(\"side\");\n", "end" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"heads\"" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(rand() <= 0.5 ? \"heads\" : \"tails\")" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 2 3 4 5 6 7 8 9 10 " ] } ], "source": [ "for i = 1:10\n", " print(i, \" \");\n", "end" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 1 1\n", "2 2 1\n", "1 1 1\n", "2 2 1\n", "1 1 1\n", "2 2 1\n", "3 3 1\n" ] } ], "source": [ "p = 0;\n", "while p < 3 && p > -5\n", " p += rand([-1,1]);\n", " println(p, \" \", abs(p), \" \", sign(p));\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Advanced data structures

\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Arrays

" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Matrices and vectors are of Array type. Note that indexing is 1-based." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2-element Array{Float64,1}:\n", " 0.9999999999999999\n", " 2.0 " ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y = zeros(size(A,2));\n", "for i = 1:size(A,1)\n", " for j = 1:size(A,2)\n", " y[i] += A[i,j] * x[j];\n", " end\n", "end\n", "y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Support for Array-based operations is similar to Matlab:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "20-element Array{Float64,1}:\n", " 0.0 \n", " 7.662739828393933e-6 \n", " 0.0001220954599444615\n", " 0.0006138425254290904\n", " 0.0019213270938265815\n", " 0.00463263107424585 \n", " 0.009460977839160578 \n", " 0.017214859280621424 \n", " 0.0287639500805727 \n", " 0.045002106780113724 \n", " 0.06680885149456278 \n", " 0.0950107863621051 \n", " 0.13034437391683382 \n", " 0.17342145188748168 \n", " 0.22469873214322042 \n", " 0.28445236848224176 \n", " 0.3527584743644178 \n", " 0.42948023864709434 \n", " 0.5142620350122585 \n", " 0.6065306597126334 " ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = range(0., stop=1., length=20);\n", "x.^4 .* exp.(-x.^2/2)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2×2 Array{Float64,2}:\n", " 1.0 2.0\n", " 3.0 4.0" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A = [1. 2. ; 3. 4.]" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2-element Array{Float64,1}:\n", " 1.0\n", " 2.0" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A[1,:]" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2×2 Array{Float64,2}:\n", " 5.0 2.0\n", " 6.0 4.0" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A[:,1] = [5, 6];\n", "A" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Arrays can also hold other types (e.g., other Arrays). Note the syntax Type{T} for parameterized types (similar to templates in C++, generics in Java and recent versions of Python)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2×2 Array{Array{Float64,1},2}:\n", " #undef #undef\n", " #undef #undef" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr1 = Array{Array{Float64,1},2}(undef, 2, 2)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2×2 Array{Array{Float64,1},2}:\n", " [] [] \n", " [1.0, 2.0] [2.0, 3.0]" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr1[1,1] = Array{Float64,1}();\n", "arr1[1,2] = Float64[];\n", "arr1[2,1] = Array{Float64,1}([1., 2.]);\n", "arr1[2,2] = Float64[2., 3.];\n", "arr1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Even mixed Arrays are possible (but are usually not best for performance):" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4-element Array{Any,1}:\n", " 1 \n", " 1.0 \n", " \"1\" \n", " [1.0]" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr2 = [1, 1., \"1\", [1.]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Arrays are always handled by reference, copies need to be requested specifically:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a = [2.0, 1.0]\n", "b = [2.0, 1.0]\n", "c = [1.0, 1.0]\n" ] } ], "source": [ "a = [1., 1.];\n", "b = a; # b references the same array as a\n", "c = copy(a); # c is a copy of a\n", "b[1] = 2.; \n", "println(\"a = \", a, \"\\nb = \", b, \"\\nc = \", c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Tuples

\n", "

Tuple is an array type that is indexed similarly as a 1D Array. They are initialized with round brackets or simply by a comma-separated list. Tuples are, however, immutable: they cannot be modified after creation.

" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1, 2)" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = (1, 2)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1, 2)" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = 1, 2" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x = 1, y = 2\n" ] } ], "source": [ "x, y = 1, 2; # same as (x,y) = (1,2)\n", "println(\"x = \", x, \", y = \", y);" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x = 2, y = 1\n" ] } ], "source": [ "y, x = x, y; # swap x and y\n", "println(\"x = \", x, \", y = \", y);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Sets

" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Set(Any[\"abc\", 9, π = 3.1415926535897...])" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "MixedSet = Set();\n", "push!(MixedSet,\"abc\");\n", "push!(MixedSet,π);\n", "push!(MixedSet,9);\n", "MixedSet" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "π in MixedSet" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "9\n" ] } ], "source": [ "SparseIntSet = Set{Int}([-2411, 1022981,9]);\n", "push!(SparseIntSet, 3);\n", "for i in SparseIntSet\n", " if i ∈ MixedSet\n", " println(i);\n", " end\n", "end" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "BitSet([1, 3, 5, 7, 11])" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "DenseIntSet = BitSet([1,3,5,7,11]) # implemented by bit vectors, for non-sparse sets" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Set([7, 9, 1022981, 3, -2411, 5, 11, 1])" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "union(SparseIntSet,DenseIntSet) # analogously: intersect, symdiff, ..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Dictionaries

" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Dict{Tuple{Int64,Int64},Float64} with 3 entries:\n", " (1, 2) => 3.14159\n", " (1, 0) => 2.71828\n", " (9, 9) => 0.0" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D = Dict{Tuple{Int,Int},Float64}((1,2)=>π, (1,0)=>ℯ);\n", "D[(9,9)] = 0.;\n", "D" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "false" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(1,1) ∈ keys(D)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.718281828459045" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "D[(1,0)]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Iterating over collections and other objects

" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using the syntax `for i = I` (or equivalently `for i in I` or `for i ∈ I`) one can iterate over any object for which the functions
\n", "    `iterate(I) → (firstitem, initialstate)`, `iterate(I, state) → (nextitem,newstate)`,
\n", "both returning `nothing` if when no elements remain,\n", "are available, see the documentation. In particular, this applies to the built-in containers:" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.0 2.0 3.0 \n", "2 5 9 13 " ] } ], "source": [ "A = [1., 2., 3.];\n", "for a ∈ A\n", " print(a, \" \");\n", "end\n", "println(\"\");\n", "B = BitSet([13, 5, 2, 9]);\n", "for b ∈ B\n", " print(b, \" \");\n", "end " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The range notation `1:n` does not create a vector as in Matlab, but a `UnitRange` object that can be iterated over (but needs only constant memory!)" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "UnitRange{Int64}" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "typeof(1:10)" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "typeof(0:0.1:1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To obtain an actual vector from any iterable, one can use `collect`" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "11-element Array{Float64,1}:\n", " 0.0\n", " 0.1\n", " 0.2\n", " 0.3\n", " 0.4\n", " 0.5\n", " 0.6\n", " 0.7\n", " 0.8\n", " 0.9\n", " 1.0" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "collect(0:0.1:1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are some useful built-in functions for generating new iterable objects from collections." ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1: 2\n", "2: 5\n", "3: 9\n", "4: 13\n" ] } ], "source": [ "for (i, x) in enumerate(B)\n", " println(i, \": \", x);\n", "end" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1, 4\n", "2, 5\n", "3, 6\n" ] } ], "source": [ "V = [1, 2, 3]; W = [4, 5, 6];\n", "for (x,y) in zip(V, W)\n", " println(x, \", \", y);\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A similar syntax can be used in array comprehensions (similar to Python) and in generator expressions:" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5-element Array{Int64,1}:\n", " 1\n", " 4\n", " 9\n", " 16\n", " 25" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[n^2 for n=1:5]" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3×6 Array{Float64,2}:\n", " 0.5 0.333333 0.25 0.2 0.166667 0.142857\n", " 0.333333 0.25 0.2 0.166667 0.142857 0.125 \n", " 0.25 0.2 0.166667 0.142857 0.125 0.111111" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[1.0/(i+j) for i = 1:3, j = 1:6]" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "55" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sum(i for i=1:10)" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Dict{Float64,Float64} with 5 entries:\n", " 0.0 => 0.0\n", " 0.5 => 1.0\n", " 2.0 => -2.44929e-16\n", " 1.5 => -1.0\n", " 1.0 => 1.22465e-16" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Dict(x => sin(π*x) for x in 0:.5:2.)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Functions and multiple dispatch

" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1.0000000000000002, 1.7320508075688772)" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function f(x,y)\n", " y*cos(x), y*sin(x)\n", "end\n", "f(π/3, 2)" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "newtonstep (generic function with 2 methods)" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function newtonstep(f::Array, Df::Array, x::Array)\n", " println(\"using vector definition\");\n", " return x - Df\\f\n", "end\n", "\n", "function newtonstep(f::Number, Df::Number, x::Number)\n", " println(\"using scalar definition\");\n", " return x - f/Df\n", "end" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "using vector definition\n" ] }, { "data": { "text/plain": [ "2-element Array{Float64,1}:\n", " -1.0\n", " -1.0" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "newtonstep([1,1], [2. -1.; -1. 2.], [0.,0.])" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "using scalar definition\n" ] }, { "data": { "text/plain": [ "-0.5" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "newtonstep(1, 2., 0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Inline declaration and anonymous functions:" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(4, 8)" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f(x) = x^2;\n", "g = x->x^3;\n", "f(2), g(2)" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3-element Array{Tuple{Float64,Float64},1}:\n", " (-1.0, 1.2246467991473532e-16) \n", " (0.5000000000000001, 0.8660254037844386)\n", " (0.9238795325112867, 0.3826834323650898)" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h = x->(cos(x),sin(x));\n", "h.([π, π/3, π/8])" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "11-element Array{Float64,1}:\n", " 1.0 \n", " 0.9510565162951535 \n", " 0.8090169943749475 \n", " 0.5877852522924731 \n", " 0.30901699437494745 \n", " 6.123233995736766e-17\n", " -0.30901699437494734 \n", " -0.587785252292473 \n", " -0.8090169943749473 \n", " -0.9510565162951535 \n", " -1.0 " ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "map(t->t[1], [h(i*π/10) for i = 0:10])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Names of functions that modify their arguments by convention end in !. For instance, push! adds an element to a data structure, whereas empty! removes all content." ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Set(Int64[])" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "SomeSet = Set([1, 2]);\n", "empty!(SomeSet)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "Note the following pitfall, which arises because array indexing with : creates copies:" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2×2 Array{Float64,2}:\n", " 2.0 2.0\n", " 2.0 2.0" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function setone!(v)\n", " fill!(v, 1.);\n", "end\n", "A = [2. 2.; 2. 2.];\n", "setone!(A[:,1]);\n", "A" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To instead pass a reference to the memory of the underlying array, use view:" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2×2 Array{Float64,2}:\n", " 1.0 2.0\n", " 1.0 2.0" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "setone!(view(A,:,1));\n", "A" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Custom types

" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((1.0, 0.0), 6.283185307179586)" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "abstract type RoundShape end\n", "\n", "mutable struct Ellipse <: RoundShape\n", " center::Tuple{Float64,Float64}\n", " A::Real\n", " B::Real\n", "end\n", "\n", "mutable struct Circle <: RoundShape\n", " center::Tuple{Float64,Float64}\n", " r::Real\n", "end\n", "\n", "getcenter(S::RoundShape) = S.center;\n", "\n", "area(S::Ellipse) = π * S.A * S.B;\n", "area(S::Circle) = π * S.r^2;\n", "\n", "Ell = Ellipse((1., 0.), 2, 1);\n", "getcenter(Ell), area(Ell)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that concrete types (such as Ellipse, Circle) can only be subtypes of abstract types (here: RoundShape). Built-in abstract types are, e.g., Number, Real, Integer" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Macros

" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 0.000001 seconds (4 allocations: 160 bytes)\n", "result: 2.5000050000024622e23" ] } ], "source": [ "@time s = 0; for i=1:1e6 s += i^3; end; print(\"result: \", s);" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 0.100751 seconds (286.55 k allocations: 21.845 MiB, 4.34% gc time)\n", "result: 2.5000050000025e23" ] } ], "source": [ "@time s = sum(map(x->x^3, 1:1e6)); print(\"result: \", s);" ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\t.section\t__TEXT,__text,regular,pure_instructions\n", "; Function ^ {\n", "; Location: math.jl:793\n", "; Function Type; {\n", "; Location: math.jl:793\n", "\tvcvtsi2sdl\t%edi, %xmm1, %xmm1\n", "\tdecl\t%eax\n", "\tmovl\t$3298697720, %eax ## imm = 0xC49E21F8\n", "\t.byte\t0xff\t.byte\t0x7f\t.byte\t0x00\n", "\taddb\t%bh, %bh\n", "\tloopne\t0x68\n", "\tnopw\t%cs:(%eax,%eax)\n", ";}}\n" ] } ], "source": [ "@code_native sin(π/2)^2" ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iteration 139: error 2.342321e-05, step size 1.290137e-06\n" ] } ], "source": [ "using Printf\n", "println(@sprintf \"iteration %d: error %e, step size %e\" 139 2.34232131e-5 1.290137e-6)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Modules

" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Modules are used to encapsulate functions and types. Additional modules can be installed by the built-in package manager." ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n", "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaRegistries/General.git`\n", "\u001b[2K\u001b[?25h[1mFetching:\u001b[22m\u001b[39m [========================================>] 100.0 %.0 %\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.0/Project.toml`\n", "\u001b[90m [no changes]\u001b[39m\n", "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.0/Manifest.toml`\n", "\u001b[90m [no changes]\u001b[39m\n" ] } ], "source": [ "using Pkg\n", "Pkg.add(\"StaticArrays\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "They are loaded by using or import (where the latter puts identifiers into a separate directory)" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [], "source": [ "using StaticArrays" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For using and import, julia searches for modules in the directories listed in LOAD_PATH. To also search for module files you have created in /some/directory, add the following line to the file ~/.juliarc.jl,\n", "

push!(LOAD_PATH,\"/some/directory\")

\n", "

See also workflow tips for working with modules, and the Revise package:" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.0/Project.toml`\n", "\u001b[90m [no changes]\u001b[39m\n", "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.0/Manifest.toml`\n", "\u001b[90m [no changes]\u001b[39m\n" ] } ], "source": [ "Pkg.add(\"Revise\");\n", "using Revise" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "After `Revise` has been loaded, every change in " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Language interoperability

\n", "

Julia offers interfaces to FORTRAN, C, C++, and Python. It is especially easy to use existing Python packages:

" ] }, { "cell_type": "code", "execution_count": 65, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.0/Project.toml`\n", "\u001b[90m [no changes]\u001b[39m\n", "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m" ] }, { "data": { "image/png": "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", "text/plain": [ "Figure(PyObject
)" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ " `~/.julia/environments/v1.0/Manifest.toml`\n", "\u001b[90m [no changes]\u001b[39m\n" ] } ], "source": [ "Pkg.add(\"PyPlot\");\n", "using PyPlot\n", "x = range(1e-2,stop=1,length=10000);\n", "plot(x, sin.(1.0./x));" ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.0/Project.toml`\n", "\u001b[90m [no changes]\u001b[39m\n", "\u001b[32m\u001b[1m Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.0/Manifest.toml`\n", "\u001b[90m [no changes]\u001b[39m\n" ] }, { "data": { "text/latex": [ "\\begin{equation*}- x + x^{y} \\left(x y e^{x y} + e^{x y}\\right) e^{y e^{x y}} + x^{y} e^{y e^{x y}} \\log{\\left (x \\right )}\\end{equation*}" ], "text/plain": [ " x⋅y x⋅y \n", " y ⎛ x⋅y x⋅y⎞ y⋅ℯ y y⋅ℯ \n", "-x + x ⋅⎝x⋅y⋅ℯ + ℯ ⎠⋅ℯ + x ⋅ℯ ⋅log(x)" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Pkg.add(\"SymPy\");\n", "using SymPy\n", "x, y = symbols(\"x, y\", real=true);\n", "diff(x^y*exp(y*exp(x*y)) - x*y + 1, y)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "

(Pseudo-)Random numbers

" ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rand([1, 4, 16])" ] }, { "cell_type": "code", "execution_count": 68, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)" ] }, "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rand(\"abc\")" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3×3×3 Array{Float64,3}:\n", "[:, :, 1] =\n", " 0.137612 0.219521 0.258723\n", " 0.846962 0.605823 0.961066\n", " 0.125312 0.598955 0.400506\n", "\n", "[:, :, 2] =\n", " 0.368323 0.776075 0.625162\n", " 0.274516 0.688724 0.984733\n", " 0.163143 0.878335 0.715124\n", "\n", "[:, :, 3] =\n", " 0.436599 0.221008 0.0171596\n", " 0.0239657 0.421176 0.613731 \n", " 0.791671 0.0843151 0.150949 " ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rand(3,3,3)" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2×2×2 Array{Int64,3}:\n", "[:, :, 1] =\n", " -5020191725107600484 -5847271543186582121\n", " -6008095998924860804 -3567908730296754207\n", "\n", "[:, :, 2] =\n", " 9164288876322877779 4615745002041857521\n", " -8504649829447353854 2004894841892499977" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rand(Int, 2, 2, 2)" ] }, { "cell_type": "code", "execution_count": 71, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5-element Array{Float64,1}:\n", " 0.04579687676883348\n", " 0.42363037620611 \n", " 0.17266345126070703\n", " 0.0 \n", " 0.0 " ] }, "execution_count": 71, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using Random\n", "A = zeros(5)\n", "rand!(view(A,1:3))\n", "A" ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5-element Array{Float64,1}:\n", " 0.1824382704421581 \n", " 0.4456902956386928 \n", " 0.17818792893243773\n", " 0.5461182756070553 \n", " 0.12142121921163795" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rng = MersenneTwister(5312) \n", "rand!(rng, A) # similar effect as calling seed!(5312), but this does not change global random number generator" ] }, { "cell_type": "code", "execution_count": 73, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3×3×3 BitArray{3}:\n", "[:, :, 1] =\n", " false true false\n", " false true true\n", " true true false\n", "\n", "[:, :, 2] =\n", " true false false\n", " true true true\n", " false false false\n", "\n", "[:, :, 3] =\n", " false false true\n", " false false true\n", " true true true" ] }, "execution_count": 73, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bitrand(3, 3, 3)" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [], "source": [ "G = randn(1000000);" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "WARNING: using Plots.plot in module Main conflicts with an existing identifier.\n" ] }, { "data": { "image/svg+xml": [ "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "-4\n", "\n", "\n", "-2\n", "\n", "\n", "0\n", "\n", "\n", "2\n", "\n", "\n", "4\n", "\n", "\n", "0\n", "\n", "\n", "5.0×10\n", "\n", "\n", "3\n", "\n", "\n", "1.0×10\n", "\n", "\n", "4\n", "\n", "\n", "1.5×10\n", "\n", "\n", "4\n", "\n", "\n", "2.0×10\n", "\n", "\n", "4\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "y1\n", "\n", "\n" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using Plots; gr()\n", "histogram(G, nbins=200)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Julia 1.0.1", "language": "julia", "name": "julia-1.0" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.0.1" } }, "nbformat": 4, "nbformat_minor": 1 }