pages tagged julia
wsh
https://rtime.felk.cvut.cz/~sojka/tags/julia/
wsh
ikiwiki
2024-03-18T09:38:50Z
Julia: Počítejte svobodně a rychle
https://rtime.felk.cvut.cz/~sojka/blog/if22/julia-if22/
2024-03-18T09:38:50Z
2022-06-12T20:55:57Z
<div id="table-of-contents" role="doc-toc">
<h2>Table of Contents</h2>
<div id="text-table-of-contents" role="doc-toc">
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org65f1955">1. Characteristics</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orga884741">1.1. Speed</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org3da53cf">1.2. My success story</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org8e0e6a1">2. Installation</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgeb98f86">2.1. IDE: Julia plugin for VS Code</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgbee50d1">3. Calculator</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org88c0758">4. REPL modes</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgd199ebd">5. Variables</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgbec424d">6. Vectors, Arrays</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org9dcb556">6.1. Element-wise operations – broadcasting</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org620e87d">6.2. GPU arrays</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org33a880b">7. Types</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgb3d4012">7.1. Parametric types</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org416351a">7.2. Abstract types and type hierarchy</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org50a12ca">7.3. User-defined types</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org3b19202">8. Functions</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orga53ebdb">8.1. Anonymous functions</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org0bf8881">8.2. Methods and multiple dispatch</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org3beb527">8.3. Multimedia I/O (show examples)</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org570ef47">9. Macros</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org0159296">9.1. Examples</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org49a77a4">9.1.1. Unit testing</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orga0ffce7">9.1.2. Code simplification</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org2f3822d">9.2. Benchmarking, code inspection, optimization</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgdd1bcfd">10. Showcase</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgac0f1f3">10.1. Measurements</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orga417f48">10.2. Unitful</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org3807446">11. Plotting</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgb0fd7e0">12. Package management</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orge5e1e52">12.1. Package manager</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org0f3c69c">12.2. Using packages, modules</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org5f1f9f1">13. Tasks & Channels</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org3f5c012">14. Interfacing other languages</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orge700d88">15. Interactive notebooks</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org515746c">15.1. Jupyter</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org4110152">15.2. Pluto.jl</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgf8aefc2">15.3. Feature comparison</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org5e24701">16. Dataframes.jl</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgd2da5e4">17. Conclusion</a></li>
</ul>
</div>
</div>
<p>
Below are the materials from my today’s
Installfest talk.
<a href="https://pretalx.installfest.cz/installfest-2022/talk/Z8TP3D/">https://pretalx.installfest.cz/installfest-2022/talk/Z8TP3D/</a>
</p>
<div id="outline-container-org65f1955" class="outline-2">
<h2 id="org65f1955"><span class="section-number-2">1.</span> Characteristics</h2>
<div class="outline-text-2" id="text-1">
<p>
<a href="https://julialang.org/">https://julialang.org/</a>
</p>
<ul class="org-ul">
<li>New language – announced 2012</li>
<li>Goal: Solve the “two language” problem
<ul class="org-ul">
<li>Prototype in Python, rewrite in C++ for speed</li>
</ul></li>
<li>Compiled language (LLVM)</li>
<li>Good for interactive work (JIT)</li>
<li>Dynamic types + type inference</li>
<li>Garbage collected</li>
<li><b>Multiple dispatch</b> paradigm
<ul class="org-ul">
<li>one function can have different
implementations based on type of all arguments</li>
</ul></li>
<li>Lisp-like macros</li>
<li>Target domain:
<ul class="org-ul">
<li>Originally: Scientific computations</li>
<li>Nowadays: General purpose, Data Science,
Visualisation, …</li>
</ul></li>
</ul>
</div>
<div id="outline-container-orga884741" class="outline-3">
<h3 id="orga884741"><span class="section-number-3">1.1.</span> Speed</h3>
<div class="outline-text-3" id="text-1-1">
<p width="800">
<a href="https://rtime.felk.cvut.cz/~sojka/blog/if22/julia-is-fast.jpg" width="800"><img src="https://rtime.felk.cvut.cz/~sojka/blog/if22/julia-is-fast.jpg" alt="julia-is-fast.jpg" width="800" /></a>
Source: <a href="https://youtu.be/LT4AP7CUMAw">https://youtu.be/LT4AP7CUMAw</a>
</p>
</div>
</div>
<div id="outline-container-org3da53cf" class="outline-3">
<h3 id="org3da53cf"><span class="section-number-3">1.2.</span> My success story</h3>
<div class="outline-text-3" id="text-1-2">
<ul class="org-ul">
<li>Load & process 2GB CSV file</li>
<li><b>Julia</b>: 40s, 5 GB of memory</li>
<li><b>Python Pandas</b>: 5 min, OUT OF MEMORY</li>
<li><b>Python Pandas + big machine</b>: 15 min, 36 GB of memory</li>
</ul>
</div>
</div>
</div>
<div id="outline-container-org8e0e6a1" class="outline-2">
<h2 id="org8e0e6a1"><span class="section-number-2">2.</span> Installation</h2>
<div class="outline-text-2" id="text-2">
<ul class="org-ul">
<li>distribution package managers</li>
<li>download archive, unzip/untar, run</li>
<li>console application
<img src="https://rtime.felk.cvut.cz/~sojka/tags/julia/julia-terminal.png" alt="julia-terminal.png" /></li>
</ul>
</div>
<div id="outline-container-orgeb98f86" class="outline-3">
<h3 id="orgeb98f86"><span class="section-number-3">2.1.</span> IDE: Julia plugin for VS Code</h3>
<div class="outline-text-3" id="text-2-1">
<p>
<a href="https://code.visualstudio.com/docs/languages/julia">https://code.visualstudio.com/docs/languages/julia</a>
</p>
<div id="orgba2251d" class="figure">
<p><a href="https://rtime.felk.cvut.cz/~sojka/blog/if22/vs-code.png" width="900"><img src="https://rtime.felk.cvut.cz/~sojka/blog/if22/vs-code.png" alt="vs-code.png" width="900" /></a>
</p>
</div>
</div>
</div>
</div>
<div id="outline-container-orgbee50d1" class="outline-2">
<h2 id="orgbee50d1"><span class="section-number-2">3.</span> Calculator</h2>
<div class="outline-text-2" id="text-3">
<div class="org-src-container">
<pre class="src src-julia">1 + 1
3 * 5
</pre>
</div>
</div>
</div>
<div id="outline-container-org88c0758" class="outline-2">
<h2 id="org88c0758"><span class="section-number-2">4.</span> REPL modes</h2>
<div class="outline-text-2" id="text-4">
<p>
Special characters at the start of the line switch
modes:
</p>
<ul class="org-ul">
<li><p>
Help
</p>
<div class="org-src-container">
<pre class="src src-julia">?atan
</pre>
</div></li>
<li><p>
Shell
</p>
<div class="org-src-container">
<pre class="src src-julia">;ls
</pre>
</div></li>
<li><p>
Package manager
</p>
<div class="org-src-container">
<pre class="src src-julia">]add IJulia
</pre>
</div></li>
</ul>
<p>
Return with backspace
</p>
</div>
</div>
<div id="outline-container-orgd199ebd" class="outline-2">
<h2 id="orgd199ebd"><span class="section-number-2">5.</span> Variables</h2>
<div class="outline-text-2" id="text-5">
<div class="org-src-container">
<pre class="src src-julia">x = 1
x
<span class="org-comment-delimiter"># </span><span class="org-comment">Julia likes Unicode :-)</span>
π <span class="org-comment-delimiter"># </span><span class="org-comment">Enter as \pi<TAB></span>
α = atan(1/2)
3α + 100 <span class="org-comment-delimiter"># </span><span class="org-comment">You can skip multiply operator</span>
</pre>
</div>
</div>
</div>
<div id="outline-container-orgbec424d" class="outline-2">
<h2 id="orgbec424d"><span class="section-number-2">6.</span> Vectors, Arrays</h2>
<div class="outline-text-2" id="text-6">
<div class="org-src-container">
<pre class="src src-julia">a=[10,20,30]
a[1] <span class="org-comment-delimiter"># </span><span class="org-comment">one-based indexing</span>
a[2:3]
a[2:<span class="org-keyword">end</span>]
b=[1 2; 3 4]
c=[5 6
7 8]
</pre>
</div>
</div>
<div id="outline-container-org9dcb556" class="outline-3">
<h3 id="org9dcb556"><span class="section-number-3">6.1.</span> Element-wise operations – broadcasting</h3>
<div class="outline-text-3" id="text-6-1">
<div class="org-src-container">
<pre class="src src-julia">a=rand(10_000_000)
b=rand(10_000_000)
a*b <span class="org-comment-delimiter"># </span><span class="org-comment">❌</span>
a.*b
sin(a) <span class="org-comment-delimiter"># </span><span class="org-comment">❌</span>
sin.(a) <span class="org-comment-delimiter"># </span><span class="org-comment">Broadcasting</span>
[sin(i) <span class="org-keyword">for</span> i <span class="org-keyword">in</span> a] <span class="org-comment-delimiter"># </span><span class="org-comment">Comprehension</span>
<span class="org-comment-delimiter"># </span><span class="org-comment">Broadcasting is faster – no need to</span>
<span class="org-comment-delimiter"># </span><span class="org-comment">allocate intermediate memory</span>
<span class="org-julia-macro">@time</span> sin.(a) .+ cos.(b);
<span class="org-julia-macro">@time</span> [sin(i) <span class="org-keyword">for</span> i <span class="org-keyword">in</span> a] .+ [cos(i) <span class="org-keyword">for</span> i <span class="org-keyword">in</span> b];
<span class="org-comment-delimiter"># </span><span class="org-comment">In-place assignment (no memory allocation)</span>
c = zeros(size(a))
<span class="org-julia-macro">@time</span> c .= sin.(a).^2 .+ cos.(b).^2;
<span class="org-comment-delimiter"># </span><span class="org-comment">Tired of writing dots?</span>
@. c = sin(a)^2 + cos(b)^2
</pre>
</div>
</div>
</div>
<div id="outline-container-org620e87d" class="outline-3">
<h3 id="org620e87d"><span class="section-number-3">6.2.</span> GPU arrays</h3>
<div class="outline-text-3" id="text-6-2">
<p>
<a href="https://juliagpu.org/">https://juliagpu.org/</a>
</p>
<ul class="org-ul">
<li>Available APIs
<ul class="org-ul">
<li>CUDA.jl</li>
<li>AMDGPU.jl</li>
<li>oneAPI.jl (Intel)</li>
</ul></li>
<li><p>
High-level (array) API:
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> oneAPI
oneAPI.versioninfo()
a=rand(100_000_000)
b=rand(100_000_000)
c=zeros(size(a))
<span class="org-julia-macro">@time</span> c .= a .* b;
ga = oneArray(a)
gb = oneArray(b)
gc = oneArray(c)
<span class="org-julia-macro">@time</span> gc .= ga .* gb;
</pre>
</div></li>
<li>Possibility to write GPU kernels in Julia</li>
</ul>
</div>
</div>
</div>
<div id="outline-container-org33a880b" class="outline-2">
<h2 id="org33a880b"><span class="section-number-2">7.</span> Types</h2>
<div class="outline-text-2" id="text-7">
<p>
Julia uses dynamic types + type inference.
</p>
<div class="org-src-container">
<pre class="src src-julia">typeof(1)
typeof(1.0)
typeof(<span class="org-type">Int8</span>(1))
typeof(<span class="org-string">"Hello world"</span>)
</pre>
</div>
</div>
<div id="outline-container-orgb3d4012" class="outline-3">
<h3 id="orgb3d4012"><span class="section-number-3">7.1.</span> Parametric types</h3>
<div class="outline-text-3" id="text-7-1">
<div class="org-src-container">
<pre class="src src-julia">1//3
typeof(ans) <span class="org-comment-delimiter"># </span><span class="org-comment">ans = result of previous line</span>
typeof(<span class="org-type">Int8</span>(1)//<span class="org-type">Int8</span>(3))
typeof([1,2,3])
typeof([1 2 3])
typeof(<span class="org-type">Int8</span>[1,2,3])
typeof([1 2;3 4.1])
</pre>
</div>
</div>
</div>
<div id="outline-container-org416351a" class="outline-3">
<h3 id="org416351a"><span class="section-number-3">7.2.</span> Abstract types and type hierarchy</h3>
<div class="outline-text-3" id="text-7-2">
<p>
“is subtype” operator: <:
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-type">Integer</span> <span class="org-default"><:</span> <span class="org-type">Number</span>
<span class="org-type">Int8</span> <span class="org-default"><:</span> <span class="org-type">Integer</span>
<span class="org-type">Int8</span> <span class="org-default"><:</span> <span class="org-type">Number</span>
<span class="org-type">Float32</span> <span class="org-default"><:</span> <span class="org-type">Number</span>
<span class="org-type">Float32</span> <span class="org-default"><:</span> <span class="org-type">Integer</span>
</pre>
</div>
</div>
</div>
<div id="outline-container-org50a12ca" class="outline-3">
<h3 id="org50a12ca"><span class="section-number-3">7.3.</span> User-defined types</h3>
<div class="outline-text-3" id="text-7-3">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">mutable struct</span> <span class="org-type">MyType</span>
id<span class="org-default">::</span><span class="org-type">Int64</span>
text<span class="org-default">::</span><span class="org-type">String</span>
<span class="org-keyword">end</span>
x = MyType(10, <span class="org-string">"Hello"</span>)
<span class="org-comment-delimiter"># </span><span class="org-comment">Define addition of our type</span>
Base.:+(a<span class="org-default">::</span><span class="org-type">MyType</span>, b<span class="org-default">::</span><span class="org-type">MyType</span>) = MyType(a.id + b.id, <span class="org-string">"Sum"</span>)
x + MyType(1, <span class="org-string">"xxx"</span>)
</pre>
</div>
</div>
</div>
</div>
<div id="outline-container-org3b19202" class="outline-2">
<h2 id="org3b19202"><span class="section-number-2">8.</span> Functions</h2>
<div class="outline-text-2" id="text-8">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-comment-delimiter"># </span><span class="org-comment">Mathematics-like definition</span>
<span class="org-function-name">square</span>(x) = x*x
square(4)
<span class="org-comment-delimiter"># </span><span class="org-comment">Programming-like definition</span>
<span class="org-keyword">function</span> <span class="org-function-name">hello</span>(name)
<span class="org-keyword">return</span> <span class="org-string">"Hello "</span> * name
<span class="org-keyword">end</span>
hello(<span class="org-string">"Michal"</span>)
square(<span class="org-string">"Hello"</span>)
<span class="org-comment-delimiter"># </span><span class="org-comment">Operators are functions too</span>
+(1,2)
<span class="org-function-name">→</span>(a,b) = (a+b)/(a-b)
3→1
</pre>
</div>
</div>
<div id="outline-container-orga53ebdb" class="outline-3">
<h3 id="orga53ebdb"><span class="section-number-3">8.1.</span> Anonymous functions</h3>
<div class="outline-text-3" id="text-8-1">
<p>
Functional programming features.
</p>
<div class="org-src-container">
<pre class="src src-julia">x->x^2
ans(5) <span class="org-comment-delimiter"># </span><span class="org-comment">call</span>
a=rand(10)
<span class="org-comment-delimiter"># </span><span class="org-comment">Return elements > 0.5</span>
filter(x->x>0.5, a)
[x <span class="org-keyword">for</span> x <span class="org-keyword">in</span> a <span class="org-keyword">if</span> x > 0.5]
a[a .> 0.5]
</pre>
</div>
</div>
</div>
<div id="outline-container-org0bf8881" class="outline-3">
<h3 id="org0bf8881"><span class="section-number-3">8.2.</span> Methods and multiple dispatch</h3>
<div class="outline-text-3" id="text-8-2">
<p>
Functions can have <b>multiple methods</b>
(implementations). The method to call is selected
based on types of all arguments.
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-function-name">fun</span>(x<span class="org-default">::</span><span class="org-type">Number</span>) = <span class="org-string">"Number "</span>*string(x)
methods(fun)
fun(1)
fun(1.1)
fun(<span class="org-string">"1.1"</span>)
<span class="org-function-name">fun</span>(x<span class="org-default">::</span><span class="org-type">String</span>) = <span class="org-string">"String "</span>*x
methods(fun)
fun(<span class="org-string">"1.1"</span>)
<span class="org-comment-delimiter"># </span><span class="org-comment">Functions can have many methods</span>
methods(+)
methods(show)
</pre>
</div>
</div>
</div>
<div id="outline-container-org3beb527" class="outline-3">
<h3 id="org3beb527"><span class="section-number-3">8.3.</span> Multimedia I/O (show examples)</h3>
<div class="outline-text-3" id="text-8-3">
<p>
Values can be presented in different formats:
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-julia-macro">@doc</span> atan
typeof(<span class="org-julia-macro">@doc</span> atan)
show(stdout, MIME(<span class="org-string">"text/plain"</span>), <span class="org-julia-macro">@doc</span> atan)
show(stdout, MIME(<span class="org-string">"text/html"</span>), <span class="org-julia-macro">@doc</span> atan)
</pre>
</div>
</div>
</div>
</div>
<div id="outline-container-org570ef47" class="outline-2">
<h2 id="org570ef47"><span class="section-number-2">9.</span> Macros</h2>
<div class="outline-text-2" id="text-9">
<ul class="org-ul">
<li>Inspired by Lisp</li>
<li>Work at abstract syntax tree level.</li>
<li>Can rewrite/generate programs.
<ul class="org-ul">
<li>Often used for domain specific languages</li>
</ul></li>
<li>No separate macro language, macros are written
in Julia itself.</li>
</ul>
</div>
<div id="outline-container-org0159296" class="outline-3">
<h3 id="org0159296"><span class="section-number-3">9.1.</span> Examples</h3>
<div class="outline-text-3" id="text-9-1">
</div>
<div id="outline-container-org49a77a4" class="outline-4">
<h4 id="org49a77a4"><span class="section-number-4">9.1.1.</span> Unit testing</h4>
<div class="outline-text-4" id="text-9-1-1">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> Test
<span class="org-julia-macro">@test</span> 1 + 1 == 2
</pre>
</div>
</div>
</div>
<div id="outline-container-orga0ffce7" class="outline-4">
<h4 id="orga0ffce7"><span class="section-number-4">9.1.2.</span> Code simplification</h4>
<div class="outline-text-4" id="text-9-1-2">
<div class="org-src-container">
<pre class="src src-julia">sqrt(abs(sin(1)))
<span class="org-comment-delimiter"># </span><span class="org-comment">Pipe syntax (for unary functions only)</span>
1 |> sin |> abs |> sqrt
rnd = rand(10)
sort(rnd, rev=<span class="org-constant">true</span>) .+ 1
<span class="org-comment-delimiter"># </span><span class="org-comment">Pipes with higher-arity functions ⇒ lambdas</span>
rnd |> x -> sort(x, rev=<span class="org-constant">true</span>) |> x -> x .+ 1
<span class="org-keyword">using</span> Pipe
<span class="org-comment-delimiter"># </span><span class="org-comment">Piped value represented by underscore</span>
<span class="org-julia-macro">@pipe</span> rnd |> sort(_, rev=<span class="org-constant">true</span>) |> _ .+ 1
</pre>
</div>
<ul class="org-ul">
<li>Similar: Chains.jl, DataFramesMeta.jl, …</li>
</ul>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-julia-macro">@chain</span> df <span class="org-keyword">begin</span>
dropmissing
filter(<span class="org-julia-quoted-symbol">:id</span> => >(6), _)
groupby(<span class="org-julia-quoted-symbol">:group</span>)
combine(<span class="org-julia-quoted-symbol">:age</span> => sum)
<span class="org-keyword">end</span>
</pre>
</div>
</div>
</div>
</div>
<div id="outline-container-org2f3822d" class="outline-3">
<h3 id="org2f3822d"><span class="section-number-3">9.2.</span> Benchmarking, code inspection, optimization</h3>
<div class="outline-text-3" id="text-9-2">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-julia-macro">@time</span> rand(<span class="org-type">Int</span>(1e6));
<span class="org-keyword">using</span> BenchmarkTools
<span class="org-julia-macro">@benchmark</span> rand(<span class="org-type">Int</span>(1e6))
<span class="org-julia-macro">@code_native</span> sum(1:5)
a = [1, 2, 3]
<span class="org-comment-delimiter"># </span><span class="org-comment">Don’t perform bounds checking</span>
<span class="org-julia-macro">@inbounds</span> a[2]
</pre>
</div>
</div>
</div>
</div>
<div id="outline-container-orgdd1bcfd" class="outline-2">
<h2 id="orgdd1bcfd"><span class="section-number-2">10.</span> Showcase</h2>
<div class="outline-text-2" id="text-10">
<p>
Example of what is possible with the language.
This is not builtin functionality. Everything is
programmed in Julia.
</p>
</div>
<div id="outline-container-orgac0f1f3" class="outline-3">
<h3 id="orgac0f1f3"><span class="section-number-3">10.1.</span> Measurements</h3>
<div class="outline-text-3" id="text-10-1">
<p>
Computation with confidence intervals
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> Measurements
a = 5.2 ± 1.0
typeof(a)
b = 3.7 ± 1.0
a + b
a * b
a / b
</pre>
</div>
</div>
</div>
<div id="outline-container-orga417f48" class="outline-3">
<h3 id="orga417f48"><span class="section-number-3">10.2.</span> Unitful</h3>
<div class="outline-text-3" id="text-10-2">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> Unitful
<span class="org-keyword">using</span> Unitful.DefaultSymbols
<span class="org-keyword">using</span> Unitful: hr
1m + 3cm |> cm |> float
sin(90)
sin(90°)
sin(π/2)
15m/3s
10km/hr |> m/s
10km/hr |> m/s |> float
0°C |> K |> float
</pre>
</div>
</div>
</div>
</div>
<div id="outline-container-org3807446" class="outline-2">
<h2 id="org3807446"><span class="section-number-2">11.</span> Plotting</h2>
<div class="outline-text-2" id="text-11">
<ul class="org-ul">
<li>Plots supports multiple plotting backends (e.g.
Python matplotlib).</li>
<li>Infamous “Time to first plot” – much better today</li>
</ul>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> Plots
plot(sin.(0:0.1:2π))
</pre>
</div>
<ul class="org-ul">
<li>One of several available interfaces to Gnuplot.</li>
<li>Faster than Plots</li>
</ul>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> Gnuplot
<span class="org-julia-macro">@gp</span> sin.(0:0.1:2π) <span class="org-string">"with lines lw 5"</span> <span class="org-string">"set grid"</span>
</pre>
</div>
</div>
</div>
<div id="outline-container-orgb0fd7e0" class="outline-2">
<h2 id="orgb0fd7e0"><span class="section-number-2">12.</span> Package management</h2>
<div class="outline-text-2" id="text-12">
<ul class="org-ul">
<li>Fast development, breaking changes (packages
with version < 1.0)</li>
<li>Reproducible <b>environments</b> (projects)
<ul class="org-ul">
<li>Which packages and versions</li>
<li>Project.toml, Manifest.toml</li>
</ul></li>
<li>Needs <b>manual setup</b></li>
</ul>
</div>
<div id="outline-container-orge5e1e52" class="outline-3">
<h3 id="orge5e1e52"><span class="section-number-3">12.1.</span> Package manager</h3>
<div class="outline-text-3" id="text-12-1">
<div class="org-src-container">
<pre class="src src-julia">pwd()
<span class="org-comment-delimiter"># </span><span class="org-comment">Switch to package manager</span>
]
?
<span class="org-comment-delimiter"># </span><span class="org-comment">create a new project or activate existing</span>
activate .
add Pipe
;cat Project.toml
cat Manifest.toml
</pre>
</div>
</div>
</div>
<div id="outline-container-org0f3c69c" class="outline-3">
<h3 id="org0f3c69c"><span class="section-number-3">12.2.</span> Using packages, modules</h3>
<div class="outline-text-3" id="text-12-2">
<ul class="org-ul">
<li><p>
Module = namespace
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">module</span> MyMod
<span class="org-keyword">export</span> x
x=1
y=2
<span class="org-keyword">end</span>
x
MyMod.x
</pre>
</div>
<ul class="org-ul">
<li>Package is a git repo with certain structure</li>
</ul>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-comment-delimiter"># </span><span class="org-comment">introduce exported symbols to current namespace</span>
<span class="org-keyword">using</span> Package
<span class="org-comment-delimiter"># </span><span class="org-comment">introduce just the symbol Package to current namespace</span>
<span class="org-keyword">import</span> Package
</pre>
</div></li>
</ul>
</div>
</div>
</div>
<div id="outline-container-org5f1f9f1" class="outline-2">
<h2 id="org5f1f9f1"><span class="section-number-2">13.</span> Tasks & Channels</h2>
<div class="outline-text-2" id="text-13">
<ul class="org-ul">
<li>Easy to use parallelism</li>
<li>Similar to goroutines in Go</li>
</ul>
</div>
</div>
<div id="outline-container-org3f5c012" class="outline-2">
<h2 id="org3f5c012"><span class="section-number-2">14.</span> Interfacing other languages</h2>
<div class="outline-text-2" id="text-14">
<p>
Direct call to a function from shared library:
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-comment-delimiter"># </span><span class="org-comment">libc call</span>
<span class="org-keyword">ccall</span>(<span class="org-julia-quoted-symbol">:clock</span>, <span class="org-type">Int32</span>, ())
<span class="org-comment-delimiter"># </span><span class="org-comment">using other libraries</span>
<span class="org-keyword">ccall</span>((<span class="org-julia-quoted-symbol">:zlibVersion</span>, <span class="org-string">"libz"</span>), <span class="org-type">Cstring</span>, ()) |> unsafe_string
</pre>
</div>
<p>
Python code can be called transparently from Julia:
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> PyCall
math = pyimport(<span class="org-string">"math"</span>)
math.sin(math.pi / 4) <span class="org-comment-delimiter"># </span><span class="org-comment">returns ≈ 1/√2 = 0.70710678...</span>
</pre>
</div>
</div>
</div>
<div id="outline-container-orge700d88" class="outline-2">
<h2 id="orge700d88"><span class="section-number-2">15.</span> Interactive notebooks</h2>
<div class="outline-text-2" id="text-15">
<ul class="org-ul">
<li>Jupyter vs. Pluto.jl
<ul class="org-ul">
<li>Pluto is something between Jupyter and Excel</li>
</ul></li>
</ul>
</div>
<div id="outline-container-org515746c" class="outline-3">
<h3 id="org515746c"><span class="section-number-3">15.1.</span> Jupyter</h3>
<div class="outline-text-3" id="text-15-1">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> IJulia
notebook()
</pre>
</div>
</div>
</div>
<div id="outline-container-org4110152" class="outline-3">
<h3 id="org4110152"><span class="section-number-3">15.2.</span> Pluto.jl</h3>
<div class="outline-text-3" id="text-15-2">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">import</span> Pluto
Pluto.run()
</pre>
</div>
<p>
See <a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/installfest-pluto.html">./installfest-pluto.html</a>
</p>
</div>
</div>
<div id="outline-container-orgf8aefc2" class="outline-3">
<h3 id="orgf8aefc2"><span class="section-number-3">15.3.</span> Feature comparison</h3>
<div class="outline-text-3" id="text-15-3">
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<colgroup>
<col class="org-left" />
<col class="org-left" />
<col class="org-left" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Feature</th>
<th scope="col" class="org-left">Jupyter</th>
<th scope="col" class="org-left">Pluto.jl</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left">Languages</td>
<td class="org-left">many</td>
<td class="org-left">Julia</td>
</tr>
<tr>
<td class="org-left">File format</td>
<td class="org-left">JSON</td>
<td class="org-left">Julia script with comments</td>
</tr>
<tr>
<td class="org-left">Results</td>
<td class="org-left">Stored in JSON</td>
<td class="org-left">Available only at runtime</td>
</tr>
<tr>
<td class="org-left">Execution order</td>
<td class="org-left">Top-down/manual</td>
<td class="org-left">Dependency-based</td>
</tr>
<tr>
<td class="org-left">Cell updates</td>
<td class="org-left">Manual</td>
<td class="org-left">Automatic</td>
</tr>
<tr>
<td class="org-left">Package management</td>
<td class="org-left">No</td>
<td class="org-left">Yes, reproducible</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
<div id="outline-container-org5e24701" class="outline-2">
<h2 id="org5e24701"><span class="section-number-2">16.</span> Dataframes.jl</h2>
<div class="outline-text-2" id="text-16">
<ul class="org-ul">
<li>Work with tabular data, named columns</li>
<li>Easy import from CSV (CSV.jl)</li>
</ul>
</div>
</div>
<div id="outline-container-orgd2da5e4" class="outline-2">
<h2 id="orgd2da5e4"><span class="section-number-2">17.</span> Conclusion</h2>
<div class="outline-text-2" id="text-17">
<ul class="org-ul">
<li>➕ “Simple”, fast, versatile language</li>
<li>➕ A lot of packages available</li>
<li>➕ Active community</li>
<li>➖ Some packages are not mature, breaking
changes</li>
<li>➖ Compilation can be slow (new session)</li>
</ul>
</div>
</div>
Introduction to Julia
https://rtime.felk.cvut.cz/~sojka/blog/julia-intro/
2019-04-28T13:51:35Z
2019-04-26T21:45:50Z
<div id="table-of-contents" role="doc-toc">
<h2>Table of Contents</h2>
<div id="text-table-of-contents" role="doc-toc">
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org24fbfbd">Calculator</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org991a77b">Variables</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org912532e">Vectors, Arrays</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org2bff1d3">Element-wise operations – broadcasting</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org3ea7943">REPL modes</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgfbb28d0">Types</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgbbe633f">Parametric types</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org005011d">Abstract types and type hierarchy</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orga10cf70">Functions</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org5facd26">Anonymous functions</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org962aeeb">Methods and multiple dispatch</a></li>
</ul>
</li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgbfb446d">Units</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org017013c">Plotting</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orge80d67f">Macros</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#orgfd9d073">Tasks & Channels</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org3d651c0">Jupyter notebooks</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org7ae2cd7">Integration with C/C++</a>
<ul>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org6d6046f">Interactive C++</a></li>
<li><a href="https://rtime.felk.cvut.cz/~sojka/tags/julia/#org910a2de">Complex example</a></li>
</ul>
</li>
</ul>
</div>
</div>
<p>
Transcript of my seminar about <a href="https://julialang.org/">Julia language</a>.
</p>
<div id="outline-container-org24fbfbd" class="outline-2">
<h2 id="org24fbfbd">Calculator</h2>
<div class="outline-text-2" id="text-org24fbfbd">
<div class="org-src-container">
<pre class="src src-julia">1 + 1
3 * 5
</pre>
</div>
</div>
</div>
<div id="outline-container-org991a77b" class="outline-2">
<h2 id="org991a77b">Variables</h2>
<div class="outline-text-2" id="text-org991a77b">
<div class="org-src-container">
<pre class="src src-julia">x = 1
x
π <span class="org-comment-delimiter"># </span><span class="org-comment">Enter as \pi<TAB></span>
α = atan(1/2)
3α + 100
</pre>
</div>
</div>
</div>
<div id="outline-container-org912532e" class="outline-2">
<h2 id="org912532e">Vectors, Arrays</h2>
<div class="outline-text-2" id="text-org912532e">
<div class="org-src-container">
<pre class="src src-julia">a=[10,20,30]
a[1]
a[2:3]
a[2:<span class="org-keyword">end</span>]
b=[1 2; 3 4]
</pre>
</div>
</div>
<div id="outline-container-org2bff1d3" class="outline-3">
<h3 id="org2bff1d3">Element-wise operations – broadcasting</h3>
<div class="outline-text-3" id="text-org2bff1d3">
<div class="org-src-container">
<pre class="src src-julia">a=rand(100_000_000)
b=rand(100_000_000)
a*b
a.*b
sin(a)
sin.(a)
[sin(i) <span class="org-keyword">for</span> i <span class="org-keyword">in</span> a]
<span class="org-julia-macro">@time</span> sin.(a) .+ cos.(b);
<span class="org-julia-macro">@time</span> [sin(i) <span class="org-keyword">for</span> i <span class="org-keyword">in</span> a] .+ [cos(i) <span class="org-keyword">for</span> i <span class="org-keyword">in</span> b];
c = zeros(size(a))
<span class="org-julia-macro">@time</span> c .= sin.(a).^2 .+ cos.(b).^2;
@. c = sin(a)^2 + cos(b)^2
</pre>
</div>
</div>
</div>
</div>
<div id="outline-container-org3ea7943" class="outline-2">
<h2 id="org3ea7943">REPL modes</h2>
<div class="outline-text-2" id="text-org3ea7943">
<ul class="org-ul">
<li><p>
Help
</p>
<div class="org-src-container">
<pre class="src src-julia">?atan
<span class="org-julia-macro">@doc</span> atan
</pre>
</div></li>
<li><p>
Shell
</p>
<div class="org-src-container">
<pre class="src src-julia">;ls
</pre>
</div></li>
<li><p>
Package manager
</p>
<div class="org-src-container">
<pre class="src src-julia">]add IJulia
</pre>
</div></li>
</ul>
<p>
Return with backspace
</p>
</div>
</div>
<div id="outline-container-orgfbb28d0" class="outline-2">
<h2 id="orgfbb28d0">Types</h2>
<div class="outline-text-2" id="text-orgfbb28d0">
<p>
Julia uses dynamic types + type inference.
</p>
<div class="org-src-container">
<pre class="src src-julia">typeof(1)
typeof(1.0)
typeof(<span class="org-type">Int8</span>(1))
typeof(<span class="org-string">"Hello world"</span>)
</pre>
</div>
</div>
<div id="outline-container-orgbbe633f" class="outline-3">
<h3 id="orgbbe633f">Parametric types</h3>
<div class="outline-text-3" id="text-orgbbe633f">
<div class="org-src-container">
<pre class="src src-julia">1//3
typeof(ans)
typeof(<span class="org-type">Int8</span>(1)//<span class="org-type">Int8</span>(3))
[1,2,3]
[1 2 3]
<span class="org-type">Int8</span>[1,2,3]
[1 2;3 4.1]
</pre>
</div>
</div>
</div>
<div id="outline-container-org005011d" class="outline-3">
<h3 id="org005011d">Abstract types and type hierarchy</h3>
<div class="outline-text-3" id="text-org005011d">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-type">Integer</span> <span class="org-default"><:</span> <span class="org-type">Number</span>
<span class="org-type">Int8</span> <span class="org-default"><:</span> <span class="org-type">Integer</span>
<span class="org-type">Int8</span> <span class="org-default"><:</span> <span class="org-type">Number</span>
<span class="org-type">Float32</span> <span class="org-default"><:</span> <span class="org-type">Number</span>
<span class="org-type">Float32</span> <span class="org-default"><:</span> <span class="org-type">Integer</span>
</pre>
</div>
</div>
</div>
</div>
<div id="outline-container-orga10cf70" class="outline-2">
<h2 id="orga10cf70">Functions</h2>
<div class="outline-text-2" id="text-orga10cf70">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-function-name">f</span>(x) = x*x
f(4)
<span class="org-keyword">function</span> <span class="org-function-name">hello</span>(name)
<span class="org-keyword">return</span> <span class="org-string">"Hello "</span> * name
<span class="org-keyword">end</span>
hello(<span class="org-string">"Michal"</span>)
f(<span class="org-string">"Hello"</span>)
+(1,2)
<span class="org-function-name">→</span>(a,b) = (a+b)/(a-b)
3→1
</pre>
</div>
</div>
<div id="outline-container-org5facd26" class="outline-3">
<h3 id="org5facd26">Anonymous functions</h3>
<div class="outline-text-3" id="text-org5facd26">
<div class="org-src-container">
<pre class="src src-julia">x->x^2
ans(5)
a=rand(10)
filter(x->x>0.5, a)
[x <span class="org-keyword">for</span> x <span class="org-keyword">in</span> a <span class="org-keyword">if</span> x > 0.5]
a[a .> 0.5]
</pre>
</div>
</div>
</div>
<div id="outline-container-org962aeeb" class="outline-3">
<h3 id="org962aeeb">Methods and multiple dispatch</h3>
<div class="outline-text-3" id="text-org962aeeb">
<p>
Function can have multiple implementations. The implementation to call is selected based
on argument types
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-function-name">f</span>(x<span class="org-default">::</span><span class="org-type">Number</span>) = <span class="org-string">"Number "</span>*string(x)
methods(f)
f(1)
f(1.1)
f(<span class="org-string">"1.1"</span>)
<span class="org-function-name">f</span>(x<span class="org-default">::</span><span class="org-type">String</span>) = <span class="org-string">"String "</span>*x
f(<span class="org-string">"1.1"</span>)
methods(+)
methods(show)
</pre>
</div>
</div>
<div id="outline-container-org5b8d975" class="outline-4">
<h4 id="org5b8d975">Show examples</h4>
<div class="outline-text-4" id="text-org5b8d975">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-julia-macro">@doc</span> atan
typeof(<span class="org-julia-macro">@doc</span> atan)
show(stdout, MIME(<span class="org-string">"text/plain"</span>), <span class="org-julia-macro">@doc</span> atan)
show(stdout, MIME(<span class="org-string">"text/html"</span>), <span class="org-julia-macro">@doc</span> atan)
typeof(<span class="org-string">`ls`</span>)
run(<span class="org-string">`ls`</span>)
</pre>
</div>
</div>
</div>
</div>
</div>
<div id="outline-container-orgbfb446d" class="outline-2">
<h2 id="orgbfb446d">Units</h2>
<div class="outline-text-2" id="text-orgbfb446d">
<p>
Example of what is possible with the language. This is not a builtin
functionality. Everything is programmed in Julia.
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> Unitful
<span class="org-keyword">using</span> Unitful.DefaultSymbols
<span class="org-keyword">using</span> Unitful: hr
1m + 3cm |> cm |> float
float(cm(1m + 3cm))
1m + 3cm |> cm |> float
sin(90)
sin(90°)
sin(π/2)
15m/3s
10km/hr |> m/s
10km/hr |> m/s |> float
0°C |> K |> float
</pre>
</div>
</div>
</div>
<div id="outline-container-org017013c" class="outline-2">
<h2 id="org017013c">Plotting</h2>
<div class="outline-text-2" id="text-org017013c">
<p>
Plots supports multiple plotting backends.
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> Plots
pyplot()
plot(sin.(0:0.1:2π)
</pre>
</div>
<p>
One of several available interfaces to Gnuplot.
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> Gaston
plot(sin.(0:0.1:2π)
</pre>
</div>
</div>
</div>
<div id="outline-container-orge80d67f" class="outline-2">
<h2 id="orge80d67f">Macros</h2>
<div class="outline-text-2" id="text-orge80d67f">
<ul class="org-ul">
<li>Inspired by Lisp</li>
<li>Work at parse tree level.</li>
<li>Can rewrite/generate programs.</li>
<li>No separate macro language, macros are written in Julia itself.</li>
</ul>
<p>
Examples (see test suites of many Julia packages):
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-julia-macro">@testset</span>
<span class="org-julia-macro">@test</span>
</pre>
</div>
</div>
</div>
<div id="outline-container-orgfd9d073" class="outline-2">
<h2 id="orgfd9d073">Tasks & Channels</h2>
<div class="outline-text-2" id="text-orgfd9d073">
<ul class="org-ul">
<li>Easy to use parallelism</li>
</ul>
</div>
</div>
<div id="outline-container-org3d651c0" class="outline-2">
<h2 id="org3d651c0">Jupyter notebooks</h2>
<div class="outline-text-2" id="text-org3d651c0">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> IJulia
notebook()
</pre>
</div>
</div>
</div>
<div id="outline-container-org7ae2cd7" class="outline-2">
<h2 id="org7ae2cd7">Integration with C/C++</h2>
<div class="outline-text-2" id="text-org7ae2cd7">
<p>
Direct call to a function from shared library:
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">ccall</span>(<span class="org-julia-quoted-symbol">:clock</span>, <span class="org-type">Int32</span>, ())
<span class="org-keyword">ccall</span>((<span class="org-julia-quoted-symbol">:clock</span>, <span class="org-string">"libc"</span>), <span class="org-type">Int32</span>, ())
</pre>
</div>
</div>
<div id="outline-container-org6d6046f" class="outline-3">
<h3 id="org6d6046f">Interactive C++</h3>
<div class="outline-text-3" id="text-org6d6046f">
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> Cxx
cxx<span class="org-string">"#include <stdio.h>"</span>
icxx<span class="org-string">"""printf("Hello world\n");"""</span>
</pre>
</div>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-comment-delimiter"># </span><span class="org-comment">Passing Julia values to C/C++ functions </span>
x = 42
<span class="org-julia-macro">@cxx</span> printf(pointer(<span class="org-string">"X is %d\n"</span>), x)
</pre>
</div>
</div>
</div>
<div id="outline-container-org910a2de" class="outline-3">
<h3 id="org910a2de">Complex example</h3>
<div class="outline-text-3" id="text-org910a2de">
<p>
Testing a C++ class and plotting results of its work.
</p>
<div class="org-src-container">
<pre class="src src-julia"><span class="org-keyword">using</span> Cxx
<span class="org-keyword">import</span> Cxx.CxxCore
<span class="org-keyword">using</span> Gaston
cxx<span class="org-string">""" #include "stepper.cpp" """</span>
<span class="org-comment-delimiter"># </span><span class="org-comment">Create C++ object and store it in Julia variable</span>
s = icxx<span class="org-string">"Stepper(nullptr, 2020, 100, 20);"</span>
<span class="org-comment-delimiter"># </span><span class="org-comment">Call a method of C++ object</span>
<span class="org-julia-macro">@cxx</span> s->moveTo(2000)
pos = <span class="org-type">Int32</span>[0]
freq = <span class="org-type">Int32</span>[0]
<span class="org-keyword">while</span> <span class="org-julia-macro">@cxx</span> s->isMoving()
<span class="org-julia-macro">@cxx</span> s->periodic()
<span class="org-comment-delimiter"># </span><span class="org-comment">Store values from the C++ object in Julia array for later</span>
<span class="org-comment-delimiter"># </span><span class="org-comment">plotting</span>
push!(freq, <span class="org-julia-macro">@cxx</span> s->freq)
push!(pos, <span class="org-julia-macro">@cxx</span> s->getPosition())
<span class="org-keyword">end</span>
<span class="org-comment-delimiter"># </span><span class="org-comment">Plot gathered data</span>
set(grid=<span class="org-string">"on"</span>)
x=0:length(freq)-1
plot(x, freq, xlabel=<span class="org-string">"iteration"</span>, legend=<span class="org-string">"freq"</span>)
plot!(x, [0; pos[2:<span class="org-keyword">end</span>] .- pos[1:<span class="org-keyword">end</span>-1]]./20e-3, plotstyle=<span class="org-string">"points"</span>, color=<span class="org-string">"red"</span>, legend=<span class="org-string">"Δpos/T_s"</span>)
plot!(x, pos, plotstyle=<span class="org-string">"linespoints"</span>, color=<span class="org-string">"green"</span>, legend=<span class="org-string">"pos"</span>)
<span class="org-comment-delimiter"># </span><span class="org-comment">Cxx cannot (yet) change functions once that are defined. Use these</span>
<span class="org-comment-delimiter"># </span><span class="org-comment">to commands to “replace” the compiler object, which allows</span>
<span class="org-comment-delimiter"># </span><span class="org-comment">redefining the functions.</span>
Cxx.CxxCore.reset_init!()
Cxx.new_clang_instance()
</pre>
</div>
</div>
</div>
</div>