Skip to content
Snippets Groups Projects
Commit 5bc4d276 authored by Miroslav Kratochvil's avatar Miroslav Kratochvil :bicyclist:
Browse files

Merge branch 'mk-julia5-hw3' into 'develop' 

Mk julia5 hw3

See merge request !174
parents d2e009c2 c9bdf932
No related branches found
No related tags found
2 merge requests!175Develop,!174Mk julia5 hw3
Pipeline #70620 passed
Hide whitespace changes
Inline Side-by-side
2023/2023-03-09_ProgrammingWithJulia-2/slides/2a-details.md
+ 1
− 72
View file @ 5bc4d276
......@@ -6,82 +6,11 @@
<i class="twa twa-mechanical-leg"></i>
<br>
Compiler &amp; language internals
(part 1)
</div>
# What is this "compiled code"?
You can inspect various stages of code representation (and reveal bugs):
- `code_lowered(+)`
- `code_typed(+)`
- `code_typed(+, (Int, Float64))`
- `code_llvm`
- `code_native`
What happens if we use an abstract type?
<center style="font-size:200%; line-height:120%; margin-bottom: 1em">
Performance rule #1:<br><br>
<strong>Less instructions is typically better,</strong><br>
<strong>less jumps is typically much better.</strong>
</center>
<center style="font-size:200%; line-height:120%; margin-bottom: 1em">
Performance rule #2:<br><br>
<strong>Memory allocations comprise of many instructions<br> and plenty of jumps.</strong>
</center>
# What are all these things starting with `@`?
Macros allow you to generate code before compiler runs it:
- `@info` can know what variable names to display
- `@benchmark` can run the code several times
- `@test` can safely wrap the failing code and print what failed
## Important types for macros:
- symbols: `:abc`, `:+`, ...
- expressions: `:(1+2)`, `quote ... end`
Macros are functions that get unevaluated arguments (as expressions) and return unevaluated results (as expressions).
```julia
macro clear_data(v)
quote
$(Symbol(v, :_orig)) = load_original_data()
$(Symbol(v, :_enriched)) = nothing
$(Symbol(v, :_final)) = nothing
end
end
@clear_data patients # reloads patients_orig, clears patients_enriched, patients_final
```
# Macro use-cases
Use macros to improve your code whenever Julia syntax is too unwieldy.
```julia
model = @reaction_network MyModel begin
c1, s + i --> 2i
c2, i --> r
end
```
(Taken from `Catalyst.jl`)
# How do I package my code?
Use `] generate MyPackageName`.
......
2023/2023-03-21_ProgrammingWithJulia-5/slides/5a-para.md
+ 68
− 31
View file @ 5bc4d276
......@@ -172,30 +172,68 @@ We will simulate a cookie distribution network:
# Homework 3 (Data)
# Homework 3 (Assignment)
Tasks:
- read the cookie network from a JSON file (we'll provide example data, use `JSON.jl`)
- make a nice data structure to hold this problem, make sure the input is valid
- make functions that:
- find the length of the *longest chain* (by transport "steps") from the factory to the muncher
- find out how many cookies the factory needs to produce daily so that *all munchers are fed*
- construct a network where all *transports are split in half*, each half with half cookie consumption
- find out *how many cookies are wasted* by being routed to munchers who can't eat them
- construct a network where the *distribution points are balanced* so that no cookies get wasted
- *BONUS: print the network nicely*
- for simplicity, data structures and functions may be recursive
- performance optimization _is not_ a goal
- nice short code _is_ a goal
# Homework 3 (Example data)
```json
{ type: "distribution point",
serves: [
{ type: "muncher", consumption: 3 },
{ type: "transport",
capacity: 5,
serves: {
type: "distribution point",
serves: [
{ type: "muncher", consumption: 7 },
{ type: "muncher", consumption: 2 },
{ type: "muncher", consumption: 1 }
]
ratios: [1,1,1]
{ "type": "distribution point",
"serves": [
{ "type": "muncher",
"consumption": 3 },
{ "type": "transport",
"capacity": 5,
"serves": {
"type": "distribution point",
"serves": [
{ "type": "muncher",
"consumption": 7 },
{ "type": "muncher",
"consumption": 2 },
{ "type": "muncher",
"consumption": 1 } ],
"ratios": [ 1, 1, 1 ]
}
}
],
ratios: [1,5]
"ratios": [ 1, 5 ]
}
```
Pretty-printed (one possibility):
# Homework 3 (expected results on the example data)
- make one common abstract type for "everything in the network"
- longest chain length: 3 (any of the "nested" munchers is at the longest chain)
- required daily production for feeding all munchers: 36 (7+7+7 cookies for the nested munchers because of 1:1:1 ratio, that needs 5 cookies for transport (26 total), and overfeeds the first muncher by 3 cookies because of 6+30 in ratio 1:5). Alternative ways to compute are OK (if allowing non-integer cookies, we'd get something like 30.24 daily consumption).
- transports split in half: instead of `... -> transport 5 -> ...` the network should contain something like `... -> transport 10 -> transport 10 -> ...`.
- how many cookies are wasted: the easiest way to guess is to assume perfect distribution and make a difference from the required daily production. In this case, if distribution ratios were perfect, the network would consume 15 cookies daily (10 for the nested munchers + 2 for transport + 3 for the other muncher), which wastes 21 or 15.24 cookies depending on the interpretation.
# Homework 3 (expected results)
Pretty-printed example network (one possibility):
```
1 -> munch 3
5 -> transport 5 -> 1 -> munch 7
......@@ -203,20 +241,19 @@ Pretty-printed (one possibility):
1 -> munch 1
```
Balanced distribution network (you don't need to pretty-print the modified network! here we are just showing it in the pretty format):
```
1 -> munch 3
4 -> transport 5 -> 7 -> munch 7
2 -> munch 2
1 -> munch 1
```
This is equally valid:
```
3 -> munch 3
12 -> transport 5 -> 7 -> munch 7
2 -> munch 2
1 -> munch 1
```
# Homework 3 (Assignment)
Tasks:
- read the cookie network from a JSON file (we'll provide example data, use `JSON.jl`)
- make a nice data structure to hold this problem, make sure the input is valid
- make functions that:
- find the length of the *longest chain* (by transport "steps") from the factory to the muncher
- find out how many cookies the factory needs to produce daily so that *all munchers are fed*
- construct a network where all *transports are split in half*, each half with half cookie consumption
- find out *how many cookies are wasted* by being routed to munchers who can't eat them
- construct a network where the *distribution points are balanced* so that no cookies get wasted
- *BONUS: print the network nicely*
- for simplicity, data structures and functions may be recursive
- performance optimization _is not_ a goal
- nice short code _is_ a goal
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment